@lattices/cli 0.3.0 → 0.4.0

package/app/Sources/PiWorkspaceView.swift

@@ -0,0 +1,364 @@
+import SwiftUI
+
+struct PiWorkspaceView: View {
+    @StateObject private var session = PiChatSession.shared
+    @FocusState private var composerFocused: Bool
+    @FocusState private var authFieldFocused: Bool
+
+    private static let timeFormatter: DateFormatter = {
+        let formatter = DateFormatter()
+        formatter.dateFormat = "HH:mm"
+        return formatter
+    }()
+
+    var body: some View {
+        VStack(spacing: 0) {
+            header
+
+            Rectangle()
+                .fill(Palette.border)
+                .frame(height: 0.5)
+
+            if session.isAuthPanelVisible {
+                authPanel
+
+                Rectangle()
+                    .fill(Palette.border)
+                    .frame(height: 0.5)
+            }
+
+            transcript
+
+            Rectangle()
+                .fill(Palette.border)
+                .frame(height: 0.5)
+
+            composer
+        }
+        .background(Palette.bg)
+        .onAppear {
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
+                composerFocused = true
+            }
+        }
+    }
+
+    private var header: some View {
+        HStack(spacing: 10) {
+            VStack(alignment: .leading, spacing: 6) {
+                HStack(spacing: 8) {
+                    Circle()
+                        .fill(session.hasPiBinary ? Palette.running : Palette.kill)
+                        .frame(width: 7, height: 7)
+
+                    Text("PI WORKSPACE")
+                        .font(Typo.geistMonoBold(11))
+                        .foregroundColor(Palette.text)
+
+                    capsuleLabel(session.statusText.uppercased(), tint: session.isSending ? Palette.detach : Palette.running)
+                }
+
+                Text("Full conversation surface for longer prompts, auth, and provider switching.")
+                    .font(Typo.mono(10))
+                    .foregroundColor(Palette.textDim)
+            }
+
+            Spacer()
+
+            HStack(spacing: 6) {
+                capsuleLabel(session.currentProvider.name.uppercased(), tint: Palette.textDim)
+
+                actionChip(session.isAuthPanelVisible ? "AUTH -" : "AUTH +") {
+                    session.toggleAuthPanel()
+                }
+
+                actionChip("RESET") {
+                    session.clearConversation()
+                }
+            }
+        }
+        .padding(.horizontal, 16)
+        .padding(.vertical, 14)
+    }
+
+    private var authPanel: some View {
+        VStack(alignment: .leading, spacing: 12) {
+            HStack(spacing: 8) {
+                Text("provider")
+                    .font(Typo.geistMonoBold(9))
+                    .foregroundColor(Palette.textMuted)
+
+                Picker("Provider", selection: $session.authProviderID) {
+                    ForEach(session.providerOptions) { provider in
+                        Text(provider.name).tag(provider.id)
+                    }
+                }
+                .labelsHidden()
+                .pickerStyle(.menu)
+                .font(Typo.mono(10))
+
+                Spacer()
+
+                capsuleLabel(
+                    session.currentProvider.authMode == .oauth ? "OAUTH" : "TOKEN",
+                    tint: session.currentProvider.authMode == .oauth ? Palette.detach : Palette.running
+                )
+            }
+
+            Text(session.currentProvider.helpText)
+                .font(Typo.mono(10))
+                .foregroundColor(Palette.textDim)
+                .fixedSize(horizontal: false, vertical: true)
+
+            if session.currentProvider.authMode == .apiKey {
+                HStack(spacing: 8) {
+                    SecureField(session.currentProvider.tokenPlaceholder, text: $session.authToken)
+                        .textFieldStyle(.plain)
+                        .font(Typo.mono(11))
+                        .foregroundColor(Palette.text)
+                        .focused($authFieldFocused)
+                        .onSubmit {
+                            session.saveSelectedToken()
+                        }
+
+                    actionChip("SAVE") {
+                        session.saveSelectedToken()
+                    }
+
+                    if session.hasSelectedCredential {
+                        actionChip("CLEAR") {
+                            session.removeSelectedCredential()
+                        }
+                    }
+                }
+                .padding(.horizontal, 12)
+                .padding(.vertical, 10)
+                .background(authCardBackground(tint: Palette.running))
+            } else {
+                HStack(spacing: 8) {
+                    actionChip(session.isAuthenticating ? "CANCEL" : "LOGIN") {
+                        if session.isAuthenticating {
+                            session.cancelAuthFlow()
+                        } else {
+                            session.startSelectedAuthFlow()
+                        }
+                    }
+
+                    if session.hasSelectedCredential {
+                        actionChip("CLEAR") {
+                            session.removeSelectedCredential()
+                        }
+                    }
+                }
+                .padding(.horizontal, 12)
+                .padding(.vertical, 10)
+                .background(authCardBackground(tint: session.isAuthenticating ? Palette.detach : Palette.running))
+
+                if let prompt = session.pendingAuthPrompt {
+                    HStack(spacing: 8) {
+                        TextField(prompt.placeholder ?? prompt.message, text: $session.authPromptInput)
+                            .textFieldStyle(.plain)
+                            .font(Typo.mono(11))
+                            .foregroundColor(Palette.text)
+                            .focused($authFieldFocused)
+                            .onSubmit {
+                                session.submitAuthPrompt()
+                            }
+
+                        actionChip("CONTINUE") {
+                            session.submitAuthPrompt()
+                        }
+                    }
+                    .padding(.horizontal, 12)
+                    .padding(.vertical, 10)
+                    .background(authCardBackground(tint: Palette.detach))
+                }
+            }
+
+            if let notice = session.authNoticeText, !notice.isEmpty {
+                Text(notice)
+                    .font(Typo.mono(9))
+                    .foregroundColor(Palette.textDim)
+                    .fixedSize(horizontal: false, vertical: true)
+            }
+
+            if let error = session.authErrorText, !error.isEmpty {
+                Text(error)
+                    .font(Typo.mono(9))
+                    .foregroundColor(Palette.kill)
+                    .fixedSize(horizontal: false, vertical: true)
+            }
+        }
+        .padding(.horizontal, 16)
+        .padding(.vertical, 14)
+        .background(Palette.surface.opacity(0.35))
+    }
+
+    private var transcript: some View {
+        ScrollViewReader { proxy in
+            ScrollView(.vertical, showsIndicators: true) {
+                LazyVStack(alignment: .leading, spacing: 10) {
+                    ForEach(session.messages) { message in
+                        row(message)
+                            .id(message.id)
+                    }
+                }
+                .padding(.horizontal, 16)
+                .padding(.vertical, 16)
+            }
+            .onAppear {
+                if let last = session.messages.last?.id {
+                    proxy.scrollTo(last, anchor: .bottom)
+                }
+            }
+            .onChange(of: session.messages.count) { _ in
+                if let last = session.messages.last?.id {
+                    withAnimation(.easeOut(duration: 0.15)) {
+                        proxy.scrollTo(last, anchor: .bottom)
+                    }
+                }
+            }
+        }
+    }
+
+    private func row(_ message: PiChatMessage) -> some View {
+        HStack(alignment: .top, spacing: 12) {
+            VStack(alignment: .leading, spacing: 4) {
+                capsuleLabel(roleLabel(for: message.role).uppercased(), tint: roleColor(for: message.role))
+                Text(Self.timeFormatter.string(from: message.timestamp))
+                    .font(Typo.mono(8))
+                    .foregroundColor(Palette.textMuted)
+            }
+            .frame(width: 62, alignment: .leading)
+
+            Text(message.text)
+                .font(Typo.mono(12))
+                .foregroundColor(Palette.text)
+                .textSelection(.enabled)
+                .frame(maxWidth: .infinity, alignment: .leading)
+        }
+        .padding(.horizontal, 12)
+        .padding(.vertical, 10)
+        .background(
+            RoundedRectangle(cornerRadius: 8)
+                .fill(roleColor(for: message.role).opacity(message.role == .assistant ? 0.10 : 0.06))
+                .overlay(
+                    RoundedRectangle(cornerRadius: 8)
+                        .strokeBorder(roleColor(for: message.role).opacity(0.22), lineWidth: 0.5)
+                )
+        )
+    }
+
+    private var composer: some View {
+        VStack(spacing: 10) {
+            HStack(spacing: 10) {
+                Text(">")
+                    .font(Typo.geistMonoBold(12))
+                    .foregroundColor(Palette.running)
+
+                TextField("Ask Pi something heavier...", text: $session.draft, axis: .vertical)
+                    .textFieldStyle(.plain)
+                    .font(Typo.mono(12))
+                    .foregroundColor(Palette.text)
+                    .lineLimit(1...6)
+                    .focused($composerFocused)
+                    .onSubmit {
+                        session.sendDraft()
+                    }
+
+                actionChip(session.isSending ? "..." : "SEND") {
+                    session.sendDraft()
+                }
+            }
+            .padding(.horizontal, 12)
+            .padding(.vertical, 10)
+            .background(
+                RoundedRectangle(cornerRadius: 8)
+                    .fill(Color.black.opacity(0.28))
+                    .overlay(
+                        RoundedRectangle(cornerRadius: 8)
+                            .strokeBorder(Palette.running.opacity(0.18), lineWidth: 0.5)
+                    )
+            )
+
+            HStack {
+                HStack(spacing: 6) {
+                    Circle()
+                        .fill(session.hasPiBinary ? Palette.running : Palette.kill)
+                        .frame(width: 6, height: 6)
+
+                    Text(session.currentProvider.name)
+                        .font(Typo.mono(10))
+                        .foregroundColor(Palette.textMuted)
+                }
+
+                Spacer()
+
+                Text("Return to send")
+                    .font(Typo.mono(9))
+                    .foregroundColor(Palette.textMuted)
+            }
+        }
+        .padding(.horizontal, 16)
+        .padding(.vertical, 14)
+        .background(Palette.surface.opacity(0.22))
+    }
+
+    private func roleLabel(for role: PiChatMessage.Role) -> String {
+        switch role {
+        case .system: return "system"
+        case .user: return "you"
+        case .assistant: return "pi"
+        }
+    }
+
+    private func roleColor(for role: PiChatMessage.Role) -> Color {
+        switch role {
+        case .system: return Palette.detach
+        case .user: return Palette.textDim
+        case .assistant: return Palette.running
+        }
+    }
+
+    private func capsuleLabel(_ text: String, tint: Color) -> some View {
+        Text(text)
+            .font(Typo.geistMonoBold(9))
+            .foregroundColor(tint.opacity(0.95))
+            .padding(.horizontal, 7)
+            .padding(.vertical, 4)
+            .background(
+                Capsule()
+                    .fill(tint.opacity(0.10))
+                    .overlay(
+                        Capsule()
+                            .strokeBorder(tint.opacity(0.28), lineWidth: 0.5)
+                    )
+            )
+    }
+
+    private func actionChip(_ label: String, action: @escaping () -> Void) -> some View {
+        Button(label, action: action)
+            .buttonStyle(.plain)
+            .font(Typo.geistMonoBold(9))
+            .foregroundColor(Palette.textMuted)
+            .padding(.horizontal, 8)
+            .padding(.vertical, 5)
+            .background(
+                Capsule()
+                    .fill(Color.white.opacity(0.03))
+                    .overlay(
+                        Capsule()
+                            .strokeBorder(Palette.border, lineWidth: 0.5)
+                    )
+            )
+    }
+
+    private func authCardBackground(tint: Color) -> some View {
+        RoundedRectangle(cornerRadius: 8)
+            .fill(tint.opacity(0.06))
+            .overlay(
+                RoundedRectangle(cornerRadius: 8)
+                    .strokeBorder(tint.opacity(0.22), lineWidth: 0.5)
+            )
+    }
+}

package/app/Sources/PlacementSpec.swift

@@ -0,0 +1,195 @@
+import CoreGraphics
+import Foundation
+
+struct GridPlacement: Equatable {
+    let columns: Int
+    let rows: Int
+    let column: Int
+    let row: Int
+
+    init?(columns: Int, rows: Int, column: Int, row: Int) {
+        guard columns > 0, rows > 0,
+              column >= 0, column < columns,
+              row >= 0, row < rows else { return nil }
+        self.columns = columns
+        self.rows = rows
+        self.column = column
+        self.row = row
+    }
+
+    static func parse(_ str: String) -> GridPlacement? {
+        let parts = str.split(separator: ":")
+        guard parts.count == 3, parts[0] == "grid" else { return nil }
+        let dims = parts[1].split(separator: "x")
+        let coords = parts[2].split(separator: ",")
+        guard dims.count == 2, coords.count == 2,
+              let columns = Int(dims[0]), let rows = Int(dims[1]),
+              let column = Int(coords[0]), let row = Int(coords[1]) else {
+            return nil
+        }
+        return GridPlacement(columns: columns, rows: rows, column: column, row: row)
+    }
+
+    var fractions: (CGFloat, CGFloat, CGFloat, CGFloat) {
+        let w = 1.0 / CGFloat(columns)
+        let h = 1.0 / CGFloat(rows)
+        return (CGFloat(column) * w, CGFloat(row) * h, w, h)
+    }
+
+    var wireValue: String {
+        "grid:\(columns)x\(rows):\(column),\(row)"
+    }
+}
+
+struct FractionalPlacement: Equatable {
+    let x: CGFloat
+    let y: CGFloat
+    let w: CGFloat
+    let h: CGFloat
+
+    init?(x: CGFloat, y: CGFloat, w: CGFloat, h: CGFloat) {
+        guard x >= 0, y >= 0, w > 0, h > 0,
+              x + w <= 1.0001, y + h <= 1.0001 else { return nil }
+        self.x = x
+        self.y = y
+        self.w = w
+        self.h = h
+    }
+
+    var fractions: (CGFloat, CGFloat, CGFloat, CGFloat) {
+        (x, y, w, h)
+    }
+}
+
+enum PlacementSpec: Equatable {
+    case tile(TilePosition)
+    case grid(GridPlacement)
+    case fractions(FractionalPlacement)
+
+    init?(string: String) {
+        let normalized = PlacementSpec.normalize(string)
+        if let position = TilePosition(rawValue: normalized) {
+            self = .tile(position)
+            return
+        }
+        if let alias = PlacementSpec.aliases[normalized], let position = TilePosition(rawValue: alias) {
+            self = .tile(position)
+            return
+        }
+        if let grid = GridPlacement.parse(normalized) {
+            self = .grid(grid)
+            return
+        }
+        return nil
+    }
+
+    init?(json: JSON?) {
+        guard let json else { return nil }
+
+        if let string = json.stringValue {
+            self.init(string: string)
+            return
+        }
+
+        guard case .object(let obj) = json,
+              let kind = obj["kind"]?.stringValue?.lowercased() else {
+            return nil
+        }
+
+        switch kind {
+        case "tile", "named", "position":
+            guard let value = obj["value"]?.stringValue else { return nil }
+            self.init(string: value)
+        case "grid":
+            guard let columns = obj["columns"]?.intValue,
+                  let rows = obj["rows"]?.intValue,
+                  let column = obj["column"]?.intValue,
+                  let row = obj["row"]?.intValue,
+                  let grid = GridPlacement(columns: columns, rows: rows, column: column, row: row) else {
+                return nil
+            }
+            self = .grid(grid)
+        case "fractions":
+            guard let x = obj["x"]?.numericDouble,
+                  let y = obj["y"]?.numericDouble,
+                  let w = obj["w"]?.numericDouble,
+                  let h = obj["h"]?.numericDouble,
+                  let placement = FractionalPlacement(
+                    x: CGFloat(x),
+                    y: CGFloat(y),
+                    w: CGFloat(w),
+                    h: CGFloat(h)
+                  ) else {
+                return nil
+            }
+            self = .fractions(placement)
+        default:
+            return nil
+        }
+    }
+
+    var fractions: (CGFloat, CGFloat, CGFloat, CGFloat) {
+        switch self {
+        case .tile(let position):
+            return position.rect
+        case .grid(let grid):
+            return grid.fractions
+        case .fractions(let placement):
+            return placement.fractions
+        }
+    }
+
+    var wireValue: String {
+        switch self {
+        case .tile(let position):
+            return position.rawValue
+        case .grid(let grid):
+            return grid.wireValue
+        case .fractions(let placement):
+            return "fractions:\(placement.x),\(placement.y),\(placement.w),\(placement.h)"
+        }
+    }
+
+    var jsonValue: JSON {
+        switch self {
+        case .tile(let position):
+            return .object([
+                "kind": .string("tile"),
+                "value": .string(position.rawValue),
+            ])
+        case .grid(let grid):
+            return .object([
+                "kind": .string("grid"),
+                "columns": .int(grid.columns),
+                "rows": .int(grid.rows),
+                "column": .int(grid.column),
+                "row": .int(grid.row),
+            ])
+        case .fractions(let placement):
+            return .object([
+                "kind": .string("fractions"),
+                "x": .double(Double(placement.x)),
+                "y": .double(Double(placement.y)),
+                "w": .double(Double(placement.w)),
+                "h": .double(Double(placement.h)),
+            ])
+        }
+    }
+
+    private static func normalize(_ string: String) -> String {
+        string
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+            .lowercased()
+            .replacingOccurrences(of: "_", with: "-")
+            .replacingOccurrences(of: " ", with: "-")
+    }
+
+    private static let aliases: [String: String] = [
+        "upper-third": "top-third",
+        "lower-third": "bottom-third",
+        "left-quarter": "left-quarter",
+        "right-quarter": "right-quarter",
+        "top-quarter": "top-quarter",
+        "bottom-quarter": "bottom-quarter",
+    ]
+}

package/app/Sources/Preferences.swift

@@ -20,6 +20,59 @@ class Preferences: ObservableObject {
         didSet { UserDefaults.standard.set(mode.rawValue, forKey: "mode") }
     }
 
+    // MARK: - AI / Claude
+
+    @Published var claudePath: String {
+        didSet { UserDefaults.standard.set(claudePath, forKey: "claude.path") }
+    }
+
+    @Published var advisorModel: String {
+        didSet { UserDefaults.standard.set(advisorModel, forKey: "claude.advisorModel") }
+    }
+
+    @Published var advisorBudgetUSD: Double {
+        didSet { UserDefaults.standard.set(advisorBudgetUSD, forKey: "claude.advisorBudget") }
+    }
+
+    /// Resolve claude CLI path: saved preference → well-known locations → `which`
+    static func resolveClaudePath() -> String? {
+        let saved = shared.claudePath
+        if !saved.isEmpty, FileManager.default.isExecutableFile(atPath: saved) {
+            return saved
+        }
+
+        let candidates = [
+            "\(NSHomeDirectory())/.local/bin/claude",
+            "/usr/local/bin/claude",
+            "/opt/homebrew/bin/claude",
+        ]
+        for path in candidates {
+            if FileManager.default.isExecutableFile(atPath: path) {
+                // Save for next time
+                DispatchQueue.main.async { shared.claudePath = path }
+                return path
+            }
+        }
+
+        // Last resort: `which claude`
+        let proc = Process()
+        proc.executableURL = URL(fileURLWithPath: "/bin/sh")
+        proc.arguments = ["-c", "which claude 2>/dev/null"]
+        let pipe = Pipe()
+        proc.standardOutput = pipe
+        proc.standardError = FileHandle.nullDevice
+        try? proc.run()
+        proc.waitUntilExit()
+        let output = String(data: pipe.fileHandleForReading.readDataToEndOfFile(), encoding: .utf8)?
+            .trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
+        if !output.isEmpty, FileManager.default.isExecutableFile(atPath: output) {
+            DispatchQueue.main.async { shared.claudePath = output }
+            return output
+        }
+
+        return nil
+    }
+
     // MARK: - Search & OCR
 
     @Published var ocrEnabled: Bool {
@@ -75,6 +128,12 @@ class Preferences: ObservableObject {
             self.mode = .learning
         }
 
+        // AI / Claude
+        self.claudePath = UserDefaults.standard.string(forKey: "claude.path") ?? ""
+        self.advisorModel = UserDefaults.standard.string(forKey: "claude.advisorModel") ?? "haiku"
+        let savedBudgetUSD = UserDefaults.standard.double(forKey: "claude.advisorBudget")
+        self.advisorBudgetUSD = savedBudgetUSD > 0 ? savedBudgetUSD : 0.50
+
         // Search & OCR
         self.ocrEnabled = !UserDefaults.standard.bool(forKey: "ocr.disabled")
 

package/app/Sources/ProjectScanner.swift

@@ -113,7 +113,7 @@ class ProjectScanner: ObservableObject {
         return (panes.count, labels, labels.joined(separator: " · "))
     }
 
-    private static let tmuxPath = "/opt/homebrew/bin/tmux"
+    private static var tmuxPath: String { TmuxQuery.resolvedPath ?? "/opt/homebrew/bin/tmux" }
 
     private func isSessionRunning(_ name: String) -> Bool {
         let task = Process()