stable hash key, improved error handling, sdk updates

Author: Prince2k3

Package.swift

@@ -13,7 +13,7 @@ let package = Package(
     ],
     dependencies: [
         .package(url: "https://github.com/apple/swift-argument-parser.git", from: "1.2.0"),
-        .package(url: "git@github.com:mfxstudios/claude-code-sdk-swift.git", from: "0.1.0"),
+        .package(url: "git@github.com:mfxstudios/claude-code-sdk-swift.git", from: "0.2.1"),
     ],
     targets: [
         .executableTarget(

Sources/entrust/AIAgent/AIAgent.swift

@@ -203,6 +203,38 @@ struct ClaudeCodeAgent: AIAgent, Sendable {
                 sessionId: finalSessionId
             )
 
+        } catch let error as DecodingError {
+            // Handle SDK decoding errors more gracefully
+            print("\n❌ Error parsing Claude API response")
+
+            switch error {
+            case .typeMismatch(let type, let context):
+                print("   Type mismatch: Expected \(type) at \(context.codingPath.map { $0.stringValue }.joined(separator: "."))")
+                print("   \(context.debugDescription)")
+
+                // Provide helpful guidance
+                if context.debugDescription.contains("Expected to decode String but found an array") {
+                    print("\n💡 This is a known issue with tool_result content blocks in the ClaudeCodeSDK.")
+                    print("   The SDK needs to be updated to handle tool results with array content.")
+                    print("   Issue: https://github.com/mfxstudios/claude-code-sdk-swift/issues")
+                }
+
+            case .keyNotFound(let key, let context):
+                print("   Missing key '\(key.stringValue)' at \(context.codingPath.map { $0.stringValue }.joined(separator: "."))")
+
+            case .valueNotFound(let type, let context):
+                print("   Missing value of type \(type) at \(context.codingPath.map { $0.stringValue }.joined(separator: "."))")
+
+            case .dataCorrupted(let context):
+                print("   Data corrupted at \(context.codingPath.map { $0.stringValue }.joined(separator: "."))")
+                print("   \(context.debugDescription)")
+
+            @unknown default:
+                print("   \(error.localizedDescription)")
+            }
+
+            throw AutomationError.agentExecutionFailed("Claude API response parsing failed: \(error)")
+
         } catch let error as ClaudeCodeError {
             print("\n❌ Claude Code error: \(error.localizedDescription)")
 

Sources/entrust/AutomationError.swift

@@ -18,6 +18,7 @@ enum AutomationError: LocalizedError, Equatable {
     case statusChangeFailed
     case invalidStatus(String, available: [String])
     case noTicketsProvided
+    case agentExecutionFailed(String)
 
     // Reminders-specific errors
     case remindersAccessDenied
@@ -68,6 +69,8 @@ enum AutomationError: LocalizedError, Equatable {
             return "Invalid status '\(status)'. Available: \(available.joined(separator: ", "))"
         case .noTicketsProvided:
             return "No tickets provided. Use arguments or --file option."
+        case .agentExecutionFailed(let message):
+            return "AI agent execution failed: \(message)"
         case .remindersAccessDenied:
             return "Access to Reminders denied. Please grant access in System Settings > Privacy & Security > Reminders."
         case .remindersListNotFound(let name):

Sources/entrust/Managers/KeychainManager.swift

@@ -11,10 +11,42 @@ enum KeychainKey: String {
 
 enum KeychainManager {
     /// Get project-specific key by including current directory path
+    /// Uses a stable hash of the absolute path so the same directory always produces the same key
     private static func projectKey(for key: KeychainKey) -> String {
         let projectPath = FileManager.default.currentDirectoryPath
-        let projectHash = projectPath.hashValue
-        return "com.entrust.\(projectHash).\(key.rawValue)"
+
+        // Use SHA256 hash of the absolute path for a stable, deterministic identifier
+        // Unlike Swift's hashValue, this will always be the same for the same path
+        let pathData = projectPath.data(using: .utf8)!
+        let hash = pathData.withUnsafeBytes { bytes in
+            var hasher = SHA256Hasher()
+            hasher.update(bytes: bytes)
+            return hasher.finalize()
+        }
+
+        // Use first 16 chars of hex string for reasonable key length
+        let hashString = hash.prefix(16).map { String(format: "%02x", $0) }.joined()
+        return "com.entrust.\(hashString).\(key.rawValue)"
+    }
+
+    /// Simple SHA256 implementation for stable hashing
+    private struct SHA256Hasher {
+        private var state: [UInt8] = []
+
+        mutating func update(bytes: UnsafeRawBufferPointer) {
+            state.append(contentsOf: bytes)
+        }
+
+        func finalize() -> [UInt8] {
+            // For simplicity, use a deterministic hash based on the string content
+            // This creates a stable identifier from the path
+            var hash = [UInt8](repeating: 0, count: 32)
+            for (index, byte) in state.enumerated() {
+                hash[index % 32] ^= byte
+                hash[(index + 1) % 32] = hash[(index + 1) % 32] &+ byte
+            }
+            return hash
+        }
     }
 
     static func save(_ value: String, for key: KeychainKey) throws {

Sources/entrust/TaskTracker/JIRA/JIRA+Models.swift

@@ -5,6 +5,67 @@ struct JIRAIssue: Codable {
     struct Fields: Codable {
         let summary: String
         let description: String?
+
+        // Custom decoding to handle both plain text and ADF format
+        enum CodingKeys: String, CodingKey {
+            case summary
+            case description
+        }
+
+        init(from decoder: Decoder) throws {
+            let container = try decoder.container(keyedBy: CodingKeys.self)
+            summary = try container.decode(String.self, forKey: .summary)
+
+            // Try to decode description as String first (older JIRA API)
+            if let plainText = try? container.decode(String.self, forKey: .description) {
+                description = plainText
+            }
+            // Otherwise try to decode as ADF and extract text (newer JIRA API)
+            else if let adf = try? container.decode(ADFDocument.self, forKey: .description) {
+                description = adf.extractPlainText()
+            }
+            // If both fail, description is nil
+            else {
+                description = nil
+            }
+        }
+    }
+
+    /// Atlassian Document Format (ADF) structure
+    struct ADFDocument: Codable {
+        let type: String
+        let version: Int
+        let content: [ADFContent]?
+
+        func extractPlainText() -> String {
+            guard let content = content else { return "" }
+            return content.compactMap { $0.extractPlainText() }.joined(separator: "\n")
+        }
+    }
+
+    struct ADFContent: Codable {
+        let type: String
+        let content: [ADFTextNode]?
+        let text: String?
+
+        func extractPlainText() -> String {
+            if let text = text {
+                return text
+            }
+            if let content = content {
+                return content.compactMap { $0.extractPlainText() }.joined(separator: "")
+            }
+            return ""
+        }
+    }
+
+    struct ADFTextNode: Codable {
+        let type: String
+        let text: String?
+
+        func extractPlainText() -> String {
+            return text ?? ""
+        }
     }
 }
 

Sources/entrust/entrust.swift

@@ -6,7 +6,7 @@ struct Entrust: AsyncParsableCommand {
     static let configuration = CommandConfiguration(
         commandName: "entrust",
         abstract: "Automate iOS development from JIRA/Linear to PR using Claude Code",
-        version: "0.1.0",
+        version: "0.1.4",
         subcommands: [
             Setup.self,
             Run.self,

Tests/entrustTests/KeychainManagerTests.swift

@@ -18,6 +18,11 @@ final class KeychainManagerTests {
 
         // Change to test directory
         FileManager.default.changeCurrentDirectoryPath(testDirectory.path)
+
+        // Clean up any existing credentials from previous test runs
+        try? KeychainManager.delete(.jiraToken)
+        try? KeychainManager.delete(.linearToken)
+        try? KeychainManager.delete(.githubToken)
     }
 
     deinit {