@lattices/cli 0.3.0 → 0.4.1

package/app/Sources/DiagnosticLog.swift

@@ -12,7 +12,7 @@ final class DiagnosticLog: ObservableObject {
         let message: String
         let level: Level
 
-        enum Level { case info, success, warning, error }
+        enum Level: String { case info, success, warning, error }
 
         var icon: String {
             switch level {
@@ -27,14 +27,68 @@ final class DiagnosticLog: ObservableObject {
     @Published var entries: [Entry] = []
     private let maxEntries = 80
 
+    // Disk persistence
+    private let logFile: URL
+    private let fileHandle: FileHandle?
+    private let diskQueue = DispatchQueue(label: "com.lattices.log-writer")
+    private static let timeFmt: DateFormatter = {
+        let f = DateFormatter()
+        f.dateFormat = "HH:mm:ss.SSS"
+        return f
+    }()
+
+    private init() {
+        let dir = FileManager.default.homeDirectoryForCurrentUser
+            .appendingPathComponent(".lattices")
+        try? FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
+
+        logFile = dir.appendingPathComponent("lattices.log")
+
+        // Rotate if > 1MB
+        if let attrs = try? FileManager.default.attributesOfItem(atPath: logFile.path),
+           let size = attrs[.size] as? UInt64, size > 1_000_000 {
+            let prev = dir.appendingPathComponent("lattices.log.1")
+            try? FileManager.default.removeItem(at: prev)
+            try? FileManager.default.moveItem(at: logFile, to: prev)
+        }
+
+        // Create file if needed and open for appending
+        if !FileManager.default.fileExists(atPath: logFile.path) {
+            FileManager.default.createFile(atPath: logFile.path, contents: nil)
+        }
+        fileHandle = try? FileHandle(forWritingTo: logFile)
+        fileHandle?.seekToEndOfFile()
+
+        // Write session header
+        let header = "\n──── Lattices launched \(ISO8601DateFormatter().string(from: Date())) ────\n"
+        if let data = header.data(using: .utf8) {
+            fileHandle?.write(data)
+        }
+    }
+
+    deinit {
+        fileHandle?.closeFile()
+    }
+
     func log(_ message: String, level: Entry.Level = .info) {
         let entry = Entry(time: Date(), message: message, level: level)
+
+        // In-memory for UI
         DispatchQueue.main.async {
             self.entries.append(entry)
             if self.entries.count > self.maxEntries {
                 self.entries.removeFirst(self.entries.count - self.maxEntries)
             }
         }
+
+        // Disk
+        diskQueue.async { [weak self] in
+            let ts = Self.timeFmt.string(from: entry.time)
+            let line = "\(ts) \(entry.icon) [\(level.rawValue)] \(message)\n"
+            if let data = line.data(using: .utf8) {
+                self?.fileHandle?.write(data)
+            }
+        }
     }
 
     func info(_ msg: String)    { log(msg, level: .info) }
@@ -61,6 +115,54 @@ final class DiagnosticLog: ObservableObject {
     }
 }
 
+// MARK: - Interaction Feedback
+
+final class AppFeedback {
+    static let shared = AppFeedback()
+
+    private lazy var tapSound: NSSound? = {
+        guard let url = Bundle.main.url(forResource: "tap", withExtension: "wav") else { return nil }
+        return NSSound(contentsOf: url, byReference: true)
+    }()
+
+    private init() {}
+
+    @discardableResult
+    func beginTimed(_ label: String, state: HUDState? = nil, feedback: String? = nil, playSound: Bool = true) -> DiagnosticLog.TimedAction {
+        if playSound {
+            playTap()
+        }
+        if let feedback, let state {
+            state.showFeedback(feedback)
+        }
+        return DiagnosticLog.shared.startTimed(label)
+    }
+
+    func finish(_ action: DiagnosticLog.TimedAction, state: HUDState? = nil, feedback: String? = nil) {
+        if let feedback, let state {
+            state.showFeedback(feedback)
+        }
+        DiagnosticLog.shared.finish(action)
+    }
+
+    func acknowledge(_ label: String, state: HUDState? = nil, feedback: String? = nil, playSound: Bool = true) {
+        if playSound {
+            playTap()
+        }
+        if let feedback, let state {
+            state.showFeedback(feedback)
+        }
+        DiagnosticLog.shared.info(label)
+    }
+
+    private func playTap() {
+        DispatchQueue.main.async {
+            self.tapSound?.stop()
+            self.tapSound?.play()
+        }
+    }
+}
+
 // MARK: - Diagnostic Window
 
 final class DiagnosticWindow {
@@ -145,7 +247,7 @@ final class DiagnosticWindow {
 
         // Show running sessions
         let task = Process()
-        task.executableURL = URL(fileURLWithPath: "/opt/homebrew/bin/tmux")
+        task.executableURL = URL(fileURLWithPath: TmuxQuery.resolvedPath ?? "/opt/homebrew/bin/tmux")
         task.arguments = ["list-sessions", "-F", "#{session_name}"]
         let pipe = Pipe()
         task.standardOutput = pipe

package/app/Sources/EventBus.swift

@@ -6,6 +6,7 @@ enum ModelEvent {
     case layerSwitched(index: Int)
     case processesChanged(interesting: [Int])
     case ocrScanComplete(windowCount: Int, totalBlocks: Int)
+    case voiceCommand(text: String, confidence: Double)
 }
 
 final class EventBus {

package/app/Sources/HUDBottomBar.swift

@@ -0,0 +1,279 @@
+import SwiftUI
+
+// MARK: - HUDBottomBar (action playback tray)
+
+struct HUDBottomBar: View {
+    @ObservedObject var state: HUDState
+    @ObservedObject private var handsOff = HandsOffSession.shared
+    var onDismiss: () -> Void
+
+    var body: some View {
+        HStack(spacing: 0) {
+            if state.tileMode {
+                tileModeView
+            } else if !handsOff.recentActions.isEmpty {
+                actionPlayback
+            } else if let feedback = state.feedbackMessage {
+                feedbackView(feedback)
+            } else if state.voiceActive {
+                voiceStatusView
+            } else {
+                shortcutsView
+            }
+        }
+        .frame(maxWidth: .infinity)
+        .frame(height: 48)
+        .background(Palette.bg)
+    }
+
+    // MARK: - Action playback (what just happened)
+
+    private var actionPlayback: some View {
+        HStack(spacing: 8) {
+            // Flash indicator
+            Image(systemName: "checkmark.circle.fill")
+                .font(.system(size: 12))
+                .foregroundColor(Palette.running)
+
+            // Action chips showing what was executed
+            ScrollView(.horizontal, showsIndicators: false) {
+                HStack(spacing: 6) {
+                    ForEach(Array(handsOff.recentActions.enumerated()), id: \.offset) { _, action in
+                        executedChip(action)
+                    }
+                }
+            }
+
+            Spacer()
+
+            // Dismiss playback
+            Button {
+                handsOff.recentActions = []
+            } label: {
+                Image(systemName: "xmark")
+                    .font(.system(size: 9, weight: .bold))
+                    .foregroundColor(Palette.textMuted)
+                    .frame(width: 20, height: 20)
+            }
+            .buttonStyle(.plain)
+        }
+        .padding(.horizontal, 16)
+    }
+
+    // MARK: - Executed action chip
+
+    private func executedChip(_ action: [String: Any]) -> some View {
+        let intent = action["intent"] as? String ?? "action"
+        let slots = action["slots"] as? [String: Any] ?? [:]
+        let summary = actionSummary(intent: intent, slots: slots)
+
+        return HStack(spacing: 5) {
+            Image(systemName: iconForIntent(intent))
+                .font(.system(size: 9))
+                .foregroundColor(Palette.running)
+            Text(summary)
+                .font(Typo.mono(10))
+                .foregroundColor(Palette.text)
+                .lineLimit(1)
+            Image(systemName: "checkmark")
+                .font(.system(size: 7, weight: .bold))
+                .foregroundColor(Palette.running)
+        }
+        .padding(.horizontal, 10)
+        .padding(.vertical, 5)
+        .background(
+            RoundedRectangle(cornerRadius: 5)
+                .fill(Palette.running.opacity(0.06))
+                .overlay(
+                    RoundedRectangle(cornerRadius: 5)
+                        .strokeBorder(Palette.running.opacity(0.2), lineWidth: 0.5)
+                )
+        )
+    }
+
+    // MARK: - Voice active status
+
+    private var voiceStatusView: some View {
+        HStack(spacing: 8) {
+            // Pulsing mic
+            Image(systemName: "waveform")
+                .font(.system(size: 11))
+                .foregroundColor(voiceColor)
+
+            Text(voiceLabel)
+                .font(Typo.monoBold(10))
+                .foregroundColor(voiceColor)
+
+            if let transcript = handsOff.lastTranscript {
+                Rectangle().fill(Palette.border).frame(width: 0.5, height: 20)
+                Text(transcript)
+                    .font(Typo.mono(10))
+                    .foregroundColor(Palette.textMuted)
+                    .lineLimit(1)
+            }
+
+            Spacer()
+
+            if let response = handsOff.lastResponse {
+                Text(response)
+                    .font(Typo.mono(9))
+                    .foregroundColor(Palette.textDim)
+                    .lineLimit(1)
+                    .frame(maxWidth: 250, alignment: .trailing)
+            }
+        }
+        .padding(.horizontal, 16)
+    }
+
+    private var voiceColor: Color {
+        switch handsOff.state {
+        case .idle:       return Palette.running
+        case .connecting: return Palette.detach
+        case .listening:  return Palette.running
+        case .thinking:   return Palette.detach
+        }
+    }
+
+    private var voiceLabel: String {
+        switch handsOff.state {
+        case .idle:       return "ready"
+        case .connecting: return "connecting..."
+        case .listening:  return "listening..."
+        case .thinking:   return "thinking..."
+        }
+    }
+
+    // MARK: - Interaction feedback
+
+    private func feedbackView(_ message: String) -> some View {
+        HStack(spacing: 8) {
+            Image(systemName: "cursorarrow.click.2")
+                .font(.system(size: 11, weight: .medium))
+                .foregroundColor(Palette.running)
+            Text(message)
+                .font(Typo.monoBold(10))
+                .foregroundColor(Palette.text)
+                .lineLimit(1)
+            Spacer()
+            Text("working")
+                .font(Typo.mono(9))
+                .foregroundColor(Palette.textDim)
+        }
+        .padding(.horizontal, 16)
+    }
+
+    // MARK: - Tile mode
+
+    private var tileModeView: some View {
+        HStack(spacing: 8) {
+            // Mode indicator
+            HStack(spacing: 4) {
+                Image(systemName: "rectangle.split.2x2")
+                    .font(.system(size: 11))
+                    .foregroundColor(Palette.running)
+                Text("TILE")
+                    .font(Typo.monoBold(10))
+                    .foregroundColor(Palette.running)
+            }
+
+            Rectangle().fill(Palette.border).frame(width: 0.5, height: 20)
+
+            // Key hints
+            HStack(spacing: 6) {
+                tileKey("H", "←")
+                tileKey("J", "↓")
+                tileKey("K", "↑")
+                tileKey("L", "→")
+                tileKey("F", "max")
+            }
+
+            Rectangle().fill(Palette.border).frame(width: 0.5, height: 20)
+
+            HStack(spacing: 6) {
+                tileKey("Y", "◸")
+                tileKey("U", "◹")
+                tileKey("B", "◺")
+                tileKey("N", "◿")
+            }
+
+            Spacer()
+
+            Text("⎋ done")
+                .font(Typo.mono(9))
+                .foregroundColor(Palette.textMuted)
+        }
+        .padding(.horizontal, 16)
+    }
+
+    private func tileKey(_ key: String, _ hint: String) -> some View {
+        HStack(spacing: 2) {
+            Text(key)
+                .font(Typo.geistMonoBold(9))
+                .foregroundColor(Palette.text)
+                .frame(width: 16, height: 16)
+                .background(
+                    RoundedRectangle(cornerRadius: 3)
+                        .fill(Palette.surface)
+                        .overlay(
+                            RoundedRectangle(cornerRadius: 3)
+                                .strokeBorder(Palette.border, lineWidth: 0.5)
+                        )
+                )
+            Text(hint)
+                .font(Typo.mono(8))
+                .foregroundColor(Palette.textDim)
+        }
+    }
+
+    // MARK: - Shortcuts hint (default state)
+
+    private var shortcutsView: some View {
+        HStack(spacing: 8) {
+            Image(systemName: "keyboard")
+                .font(.system(size: 10))
+                .foregroundColor(Palette.textMuted.opacity(0.4))
+            Text("V voice  / search  1-4 jump  ⇥ tab  ↵ go  ⎋ close")
+                .font(Typo.mono(9))
+                .foregroundColor(Palette.textMuted.opacity(0.5))
+            Spacer()
+        }
+        .padding(.horizontal, 16)
+    }
+
+    // MARK: - Helpers
+
+    private func actionSummary(intent: String, slots: [String: Any]) -> String {
+        let target = slots["target"] as? String
+            ?? slots["app"] as? String
+            ?? slots["query"] as? String
+            ?? ""
+        let position = slots["position"] as? String ?? ""
+
+        switch intent {
+        case "tile_window":
+            let parts = [target, position].filter { !$0.isEmpty }
+            return "Tile \(parts.joined(separator: " "))"
+        case "focus", "focus_app":
+            return "Focus \(target)"
+        case "launch", "launch_project":
+            return "Launch \(target)"
+        case "close_window":
+            return "Close \(target)"
+        case "maximize":
+            return "Maximize \(target)"
+        default:
+            return target.isEmpty ? intent : "\(intent) \(target)"
+        }
+    }
+
+    private func iconForIntent(_ intent: String) -> String {
+        switch intent {
+        case "tile_window":             return "rectangle.split.2x1"
+        case "focus", "focus_app":      return "eye"
+        case "launch", "launch_project": return "play.fill"
+        case "close_window":            return "xmark.circle"
+        case "maximize":               return "arrow.up.left.and.arrow.down.right"
+        default:                        return "bolt"
+        }
+    }
+}