Add Tool/Workspace

Author: intitni

Core/Package.swift

@@ -15,7 +15,6 @@ let package = Package(
                 "FileChangeChecker",
                 "LaunchAgentManager",
                 "UpdateChecker",
-                "UserDefaultsObserver",
             ]
         ),
         .library(
@@ -78,8 +77,8 @@ let package = Package(
                 "ChatService",
                 "PromptToCodeService",
                 "ServiceUpdateMigration",
-                "UserDefaultsObserver",
                 "ChatGPTChatTab",
+                .product(name: "UserDefaultsObserver", package: "Tool"),
                 .product(name: "AppMonitoring", package: "Tool"),
                 .product(name: "Environment", package: "Tool"),
                 .product(name: "SuggestionModel", package: "Tool"),
@@ -149,7 +148,7 @@ let package = Package(
         .target(name: "SuggestionService", dependencies: [
             "GitHubCopilotService",
             "CodeiumService",
-            "UserDefaultsObserver",
+            .product(name: "UserDefaultsObserver", package: "Tool"),
         ]),
 
         // MARK: - Prompt To Code
@@ -226,7 +225,7 @@ let package = Package(
             name: "SuggestionWidget",
             dependencies: [
                 "ChatGPTChatTab",
-                "UserDefaultsObserver",
+                .product(name: "UserDefaultsObserver", package: "Tool"),
                 .product(name: "SharedUIComponents", package: "Tool"),
                 .product(name: "AppMonitoring", package: "Tool"),
                 .product(name: "Environment", package: "Tool"),
@@ -264,7 +263,6 @@ let package = Package(
                 .product(name: "Preferences", package: "Tool"),
             ]
         ),
-        .target(name: "UserDefaultsObserver"),
         .target(
             name: "PlusFeatureFlag",
             dependencies: [

Tool/Package.swift

@@ -20,6 +20,8 @@ let package = Package(
         .library(name: "Toast", targets: ["Toast"]),
         .library(name: "Keychain", targets: ["Keychain"]),
         .library(name: "SharedUIComponents", targets: ["SharedUIComponents"]),
+        .library(name: "UserDefaultsObserver", targets: ["UserDefaultsObserver"]),
+        .library(name: "Workspace", targets: ["Workspace"]),
         .library(
             name: "AppMonitoring",
             targets: [
@@ -142,7 +144,9 @@ let package = Package(
                 .product(name: "AsyncAlgorithms", package: "swift-async-algorithms"),
             ]
         ),
-        
+
+        .target(name: "UserDefaultsObserver"),
+
         .target(
             name: "SharedUIComponents",
             dependencies: [
@@ -161,6 +165,17 @@ let package = Package(
 
         .testTarget(name: "ASTParserTests", dependencies: ["ASTParser"]),
 
+        .target(
+            name: "Workspace",
+            dependencies: [
+                "UserDefaultsObserver",
+                "SuggestionModel",
+                "Environment",
+                "Logger",
+                "Preferences",
+            ]
+        ),
+
         // MARK: - Services
 
         .target(

Tool/Sources/UserDefaultsObserver/UserDefaultsObserver.swift

@@ -0,0 +1,36 @@
+import Foundation
+
+public final class UserDefaultsObserver: NSObject {
+    public var onChange: (() -> Void)?
+    private weak var object: NSObject?
+    private let keyPaths: [String]
+
+    public init(
+        object: NSObject,
+        forKeyPaths keyPaths: [String],
+        context: UnsafeMutableRawPointer?
+    ) {
+        self.object = object
+        self.keyPaths = keyPaths
+        super.init()
+        for keyPath in keyPaths {
+            object.addObserver(self, forKeyPath: keyPath, options: .new, context: context)
+        }
+    }
+
+    deinit {
+        for keyPath in keyPaths {
+            object?.removeObserver(self, forKeyPath: keyPath)
+        }
+    }
+
+    public override func observeValue(
+        forKeyPath keyPath: String?,
+        of object: Any?,
+        change: [NSKeyValueChangeKey: Any]?,
+        context: UnsafeMutableRawPointer?
+    ) {
+        onChange?()
+    }
+}
+

Tool/Sources/Workspace/FileSaveWatcher.swift

@@ -0,0 +1,39 @@
+import Foundation
+
+final class FileSaveWatcher {
+    let url: URL
+    var fileHandle: FileHandle?
+    var source: DispatchSourceFileSystemObject?
+    var changeHandler: () -> Void = {}
+
+    init(fileURL: URL) {
+        url = fileURL
+        startup()
+    }
+
+    deinit {
+        source?.cancel()
+    }
+
+    func startup() {
+        if let source = source {
+            source.cancel()
+        }
+
+        fileHandle = try? FileHandle(forReadingFrom: url)
+        if let fileHandle = fileHandle {
+            source = DispatchSource.makeFileSystemObjectSource(
+                fileDescriptor: fileHandle.fileDescriptor,
+                eventMask: .link,
+                queue: .main
+            )
+
+            source?.setEventHandler { [weak self] in
+                self?.changeHandler()
+                self?.startup()
+            }
+
+            source?.resume()
+        }
+    }
+}

Tool/Sources/Workspace/Filespace.swift

@@ -0,0 +1,139 @@
+import Environment
+import Foundation
+import SuggestionModel
+
+public protocol FilespacePropertyKey {
+    associatedtype Value
+}
+
+public struct FilespacePropertyValues {
+    var storage: [ObjectIdentifier: Any] = [:]
+
+    public subscript<K: WorkspacePropertyKey>(key: K.Type) -> K.Value? {
+        get {
+            storage[ObjectIdentifier(key)] as? K.Value
+        }
+        set {
+            storage[ObjectIdentifier(key)] = newValue
+        }
+    }
+}
+
+public final class Filespace {
+    public struct Snapshot: Equatable {
+        public var linesHash: Int
+        public var cursorPosition: CursorPosition
+    }
+    
+    public struct CodeMetadata: Equatable {
+        public var uti: String?
+        public var tabSize: Int?
+        public var indentSize: Int?
+        public var usesTabsForIndentation: Bool?
+    }
+
+    public let fileURL: URL
+    public private(set) lazy var language: String = languageIdentifierFromFileURL(fileURL).rawValue
+    public var suggestions: [CodeSuggestion] = [] {
+        didSet { refreshUpdateTime() }
+    }
+
+    /// stored for pseudo command handler
+    public var codeMetadata: CodeMetadata = .init()
+    public var suggestionIndex: Int = 0
+    public var suggestionSourceSnapshot: Snapshot = .init(linesHash: -1, cursorPosition: .outOfScope)
+    public var presentingSuggestion: CodeSuggestion? {
+        guard suggestions.endIndex > suggestionIndex, suggestionIndex >= 0 else { return nil }
+        return suggestions[suggestionIndex]
+    }
+
+    private(set) var lastSuggestionUpdateTime: Date = Environment.now()
+    public var isExpired: Bool {
+        Environment.now().timeIntervalSince(lastSuggestionUpdateTime) > 60 * 3
+    }
+
+    let fileSaveWatcher: FileSaveWatcher
+    let onClose: (URL) -> Void
+
+    deinit {
+        onClose(fileURL)
+    }
+
+    init(
+        fileURL: URL,
+        onSave: @escaping (Filespace) -> Void,
+        onClose: @escaping (URL) -> Void
+    ) {
+        self.fileURL = fileURL
+        self.onClose = onClose
+        fileSaveWatcher = .init(fileURL: fileURL)
+        fileSaveWatcher.changeHandler = { [weak self] in
+            guard let self else { return }
+            onSave(self)
+        }
+    }
+
+    public func reset(resetSnapshot: Bool = true) {
+        suggestions = []
+        suggestionIndex = 0
+        if resetSnapshot {
+            suggestionSourceSnapshot = .init(linesHash: -1, cursorPosition: .outOfScope)
+        }
+    }
+
+    public func refreshUpdateTime() {
+        lastSuggestionUpdateTime = Environment.now()
+    }
+
+    /// Validate the suggestion is still valid.
+    /// - Parameters:
+    ///    - lines: lines of the file
+    ///    - cursorPosition: cursor position
+    /// - Returns: `true` if the suggestion is still valid
+    public func validateSuggestions(lines: [String], cursorPosition: CursorPosition) -> Bool {
+        guard let presentingSuggestion else { return false }
+
+        // cursor has moved to another line
+        if cursorPosition.line != presentingSuggestion.position.line {
+            reset()
+            return false
+        }
+
+        // the cursor position is valid
+        guard cursorPosition.line >= 0, cursorPosition.line < lines.count else {
+            reset()
+            return false
+        }
+
+        let editingLine = lines[cursorPosition.line].dropLast(1) // dropping \n
+        let suggestionLines = presentingSuggestion.text.split(separator: "\n")
+        let suggestionFirstLine = suggestionLines.first ?? ""
+
+        // the line content doesn't match the suggestion
+        if cursorPosition.character > 0,
+           !suggestionFirstLine.hasPrefix(editingLine[..<(editingLine.index(
+               editingLine.startIndex,
+               offsetBy: cursorPosition.character,
+               limitedBy: editingLine.endIndex
+           ) ?? editingLine.endIndex)])
+        {
+            reset()
+            return false
+        }
+
+        // finished typing the whole suggestion when the suggestion has only one line
+        if editingLine.hasPrefix(suggestionFirstLine), suggestionLines.count <= 1 {
+            reset()
+            return false
+        }
+
+        // undo to a state before the suggestion was generated
+        if editingLine.count < presentingSuggestion.position.character {
+            reset()
+            return false
+        }
+
+        return true
+    }
+}
+

Tool/Sources/Workspace/OpenedFileRocoverableStorage.swift

@@ -0,0 +1,36 @@
+import Foundation
+import Preferences
+
+@ServiceActor
+final class OpenedFileRecoverableStorage {
+    let projectRootURL: URL
+    let userDefault = UserDefaults.shared
+    let key = "OpenedFileRecoverableStorage"
+
+    init(projectRootURL: URL) {
+        self.projectRootURL = projectRootURL
+    }
+
+    func openFile(fileURL: URL) {
+        var dict = userDefault.dictionary(forKey: key) ?? [:]
+        var openedFiles = Set(dict[projectRootURL.path] as? [String] ?? [])
+        openedFiles.insert(fileURL.path)
+        dict[projectRootURL.path] = Array(openedFiles)
+        userDefault.set(dict, forKey: key)
+    }
+
+    func closeFile(fileURL: URL) {
+        var dict = userDefault.dictionary(forKey: key) ?? [:]
+        var openedFiles = dict[projectRootURL.path] as? [String] ?? []
+        openedFiles.removeAll(where: { $0 == fileURL.path })
+        dict[projectRootURL.path] = openedFiles
+        userDefault.set(dict, forKey: key)
+    }
+
+    var openedFiles: [URL] {
+        let dict = userDefault.dictionary(forKey: key) ?? [:]
+        let openedFiles = dict[projectRootURL.path] as? [String] ?? []
+        return openedFiles.map { URL(fileURLWithPath: $0) }
+    }
+}
+