agentix-cli 0.58.0 → 0.59.0

package/apps/mac-voice/Sources/AgentXVoice/HistoryClient.swift

@@ -0,0 +1,55 @@
+import Foundation
+
+/// The daemon's voice history (src/daemon/voice-history-api.ts).
+///
+/// The list is summaries only; an answer in full is fetched when one is
+/// opened. A replay is queued by the daemon in the agent's voice, at the
+/// back of the speaking queue, so it never talks over what is playing.
+/// Loopback needs no token, as for the rest of AgentClient.
+enum HistoryClient {
+    /// One page, newest first; `before` is the previous page's `next`.
+    static func page(agent: String?, limit: Int, before: String? = nil) async -> Result<VoiceHistoryPage, HistoryFailure> {
+        let q = HistoryLogic.query(agent: agent, limit: limit, before: before)
+        guard let url = URL(string: "\(Config.daemonURL)/voice/history?\(q)") else { return .failure(.init(message: "Bad daemon address.")) }
+        var req = URLRequest(url: url)
+        req.timeoutInterval = 5
+        do {
+            let (data, response) = try await URLSession.shared.data(for: req)
+            let status = (response as? HTTPURLResponse)?.statusCode ?? 0
+            if status == 200, let page = try? JSONDecoder().decode(VoiceHistoryPage.self, from: data) { return .success(page) }
+            return .failure(.init(message: errorText(data) ?? "The daemon answered \(status)."))
+        } catch {
+            return .failure(.init(message: "The AgentX daemon isn't reachable."))
+        }
+    }
+
+    /// One exchange in full, or nil when it cannot be loaded.
+    static func detail(_ id: String) async -> VoiceExchangeDetail? {
+        guard let url = URL(string: "\(Config.daemonURL)/voice/history/\(id)") else { return nil }
+        var req = URLRequest(url: url)
+        req.timeoutInterval = 5
+        guard let (data, response) = try? await URLSession.shared.data(for: req),
+              (response as? HTTPURLResponse)?.statusCode == 200 else { return nil }
+        return try? JSONDecoder().decode(VoiceExchangeDetail.self, from: data)
+    }
+
+    /// Say the answer again. Nil when queued, else why not.
+    static func replay(_ id: String) async -> String? {
+        guard let url = URL(string: "\(Config.daemonURL)/voice/history/\(id)/replay") else { return "Bad daemon address." }
+        var req = URLRequest(url: url)
+        req.httpMethod = "POST"
+        req.timeoutInterval = 5
+        guard let (data, response) = try? await URLSession.shared.data(for: req) else {
+            return "The AgentX daemon isn't reachable."
+        }
+        if (response as? HTTPURLResponse)?.statusCode == 202 { return nil }
+        return errorText(data) ?? "The answer wasn't queued."
+    }
+
+    struct HistoryFailure: Error { let message: String }
+
+    private static func errorText(_ data: Data) -> String? {
+        struct Reply: Decodable { let error: String? }
+        return (try? JSONDecoder().decode(Reply.self, from: data))?.error
+    }
+}

package/apps/mac-voice/Sources/AgentXVoice/HistoryModel.swift

@@ -0,0 +1,153 @@
+import Foundation
+
+/// Past voice exchanges as the daemon serves them (GET /voice/history),
+/// and the small decisions the History window and the menu make about
+/// them. Foundation only, so Tests/History can run it without a window.
+
+/// One row of the list: a bounded summary, never the whole answer.
+struct VoiceExchange: Decodable, Identifiable, Equatable {
+    let id: String
+    let agentId: String
+    /// When it was asked, ms since the epoch.
+    let at: Double
+    let durationMs: Int?
+    /// "ok", "error", "in-flight", "canceled" or "timeout".
+    let status: String
+    let question: String
+    let answerPreview: String
+    let answerChars: Int
+    let error: String?
+
+    var date: Date { Date(timeIntervalSince1970: at / 1000) }
+    var failed: Bool { status == "error" || status == "timeout" || status == "canceled" }
+    /// Something to say again.
+    var canReplay: Bool { answerChars > 0 && !failed }
+}
+
+struct VoiceHistoryPage: Decodable {
+    let exchanges: [VoiceExchange]
+    let next: String?
+}
+
+/// One exchange in full (GET /voice/history/:id), loaded when opened.
+struct VoiceExchangeDetail: Decodable {
+    struct Button: Decodable, Equatable { let label: String; let url: String }
+    struct Media: Decodable, Equatable { let type: String; let url: String; let caption: String? }
+    struct UI: Decodable, Equatable { let buttons: [Button]?; let media: Media? }
+
+    let id: String
+    let agentId: String
+    let at: Double
+    let durationMs: Int?
+    let status: String
+    let question: String
+    let answer: String?
+    let truncated: Bool
+    let ui: UI?
+    let error: String?
+    /// The task page, relative to the dashboard's address.
+    let taskPath: String
+
+    /// Buttons and a non-image media link, as (label, url).
+    var links: [(String, String)] {
+        var out = (ui?.buttons ?? []).map { ($0.label, $0.url) }
+        if let m = ui?.media { out.append((m.caption ?? m.type.capitalized, m.url)) }
+        return out
+    }
+}
+
+/// A day's exchanges under one heading.
+struct HistoryDay: Equatable {
+    let title: String
+    let exchanges: [VoiceExchange]
+}
+
+enum HistoryLogic {
+    /// Newest day first, each day newest first; "Today", "Yesterday", then
+    /// the date. Input order does not matter.
+    static func groupByDay(_ items: [VoiceExchange], now: Date = Date(),
+                           calendar: Calendar = .current, locale: Locale = .current) -> [HistoryDay] {
+        let sorted = items.sorted { $0.at != $1.at ? $0.at > $1.at : $0.id > $1.id }
+        var days: [HistoryDay] = []
+        var current: (Date, [VoiceExchange])?
+        for e in sorted {
+            let day = calendar.startOfDay(for: e.date)
+            if let c = current, c.0 == day {
+                current = (day, c.1 + [e])
+            } else {
+                if let c = current { days.append(HistoryDay(title: dayTitle(c.0, now: now, calendar: calendar, locale: locale), exchanges: c.1)) }
+                current = (day, [e])
+            }
+        }
+        if let c = current { days.append(HistoryDay(title: dayTitle(c.0, now: now, calendar: calendar, locale: locale), exchanges: c.1)) }
+        return days
+    }
+
+    static func dayTitle(_ day: Date, now: Date, calendar: Calendar = .current, locale: Locale = .current) -> String {
+        if calendar.isDate(day, inSameDayAs: now) { return "Today" }
+        if let y = calendar.date(byAdding: .day, value: -1, to: now), calendar.isDate(day, inSameDayAs: y) { return "Yesterday" }
+        let f = DateFormatter()
+        f.locale = locale
+        f.calendar = calendar
+        f.timeZone = calendar.timeZone
+        let sameYear = calendar.component(.year, from: day) == calendar.component(.year, from: now)
+        f.setLocalizedDateFormatFromTemplate(sameYear ? "EEEEdMMMM" : "EEEEdMMMMyyyy")
+        return f.string(from: day)
+    }
+
+    /// How long the answer took: "0.8 s", "12 s", "2 min 5 s"; "—" unknown.
+    static func duration(_ ms: Int?) -> String {
+        guard let ms, ms >= 0 else { return "—" }
+        if ms < 10_000 { return String(format: "%.1f s", Double(ms) / 1000) }
+        let s = Int((Double(ms) / 1000).rounded())
+        if s < 60 { return "\(s) s" }
+        let m = s / 60, r = s % 60
+        return r == 0 ? "\(m) min" : "\(m) min \(r) s"
+    }
+
+    /// A menu row: the question, clipped, and who answered.
+    static func menuTitle(_ e: VoiceExchange, agentName: String, max: Int = 44) -> String {
+        let q = e.question.split(whereSeparator: \.isWhitespace).joined(separator: " ")
+        let clipped = q.count > max ? String(q.prefix(max - 1)).trimmingCharacters(in: .whitespaces) + "…" : q
+        return "\u{201C}\(clipped)\u{201D} · \(agentName)"
+    }
+
+    /// Add a page to what is shown: no duplicates, newest first.
+    static func merge(_ shown: [VoiceExchange], _ page: [VoiceExchange]) -> [VoiceExchange] {
+        var seen = Set(shown.map(\.id))
+        var out = shown
+        for e in page where seen.insert(e.id).inserted { out.append(e) }
+        return out.sorted { $0.at != $1.at ? $0.at > $1.at : $0.id > $1.id }
+    }
+
+    /// Bare http(s) URLs as markdown links, so the written answer shows
+    /// them as links. URLs already inside a markdown link or <…> are left.
+    static func linkify(_ text: String) -> String {
+        guard let re = try? NSRegularExpression(pattern: #"(?<![\(\[<])\bhttps?://[^\s<>()\[\]]+"#) else { return text }
+        let ns = text as NSString
+        var out = ""
+        var last = 0
+        for m in re.matches(in: text, range: NSRange(location: 0, length: ns.length)) {
+            var url = ns.substring(with: m.range)
+            // A sentence's full stop or comma is not part of the link.
+            var tail = ""
+            while let c = url.last, ".,;:!?\"'".contains(c) { tail = String(c) + tail; url.removeLast() }
+            out += ns.substring(with: NSRange(location: last, length: m.range.location - last))
+            out += "[\(url)](\(url))"
+            out += tail
+            last = m.range.location + m.range.length
+        }
+        out += ns.substring(from: last)
+        return out
+    }
+
+    /// The query string for a page of history.
+    static func query(agent: String?, limit: Int, before: String?) -> String {
+        var items = [URLQueryItem(name: "limit", value: String(limit))]
+        if let agent, !agent.isEmpty { items.append(URLQueryItem(name: "agent", value: agent)) }
+        if let before, !before.isEmpty { items.append(URLQueryItem(name: "before", value: before)) }
+        var c = URLComponents()
+        c.queryItems = items
+        return c.percentEncodedQuery ?? ""
+    }
+}

package/apps/mac-voice/Sources/AgentXVoice/HistoryWindow.swift

@@ -0,0 +1,301 @@
+import AppKit
+import SwiftUI
+
+/// History: past voice exchanges by day, filterable by agent.
+///
+/// The daemon keeps the records (every /ask turn is a task trace on the
+/// voice channel); the window reads them and keeps no copy. The list holds
+/// summaries only, and an answer in full is fetched when it is selected.
+/// Replay goes through the daemon's speaking queue, like any answer.
+@MainActor
+final class HistoryStore: ObservableObject {
+    static let pageSize = 30
+
+    @Published var exchanges: [VoiceExchange] = []
+    @Published var next: String?
+    /// nil shows every agent.
+    @Published var agent: String? { didSet { if agent != oldValue { reload() } } }
+    @Published var agents: [AgentClient.AgentInfo] = []
+    @Published var selected: String? { didSet { if selected != oldValue { loadDetail() } } }
+    @Published var detail: VoiceExchangeDetail?
+    @Published var loading = false
+    @Published var error = ""
+    @Published var notice = ""
+
+    /// Swapped for fixed data when rendering screenshots.
+    var fetchPage: (String?, Int, String?) async -> Result<VoiceHistoryPage, HistoryClient.HistoryFailure> = HistoryClient.page
+    var fetchDetail: (String) async -> VoiceExchangeDetail? = HistoryClient.detail
+    var fetchAgents: () async -> [AgentClient.AgentInfo]? = AgentClient.agents
+
+    var days: [HistoryDay] { HistoryLogic.groupByDay(exchanges) }
+
+    func name(of id: String) -> String { agents.first { $0.id == id }?.label ?? id }
+
+    func color(of id: String) -> Color {
+        Color(hex: OrbMath.colorHex(agentID: id, configured: agents.first { $0.id == id }?.color))
+    }
+
+    func reload() {
+        loading = true
+        error = ""
+        Task {
+            if agents.isEmpty, let a = await fetchAgents() { agents = a }
+            let result = await fetchPage(agent, Self.pageSize, nil)
+            loading = false
+            switch result {
+            case .success(let page):
+                exchanges = page.exchanges
+                next = page.next
+                if selected == nil || !exchanges.contains(where: { $0.id == selected }) { selected = exchanges.first?.id }
+            case .failure(let f):
+                exchanges = []
+                next = nil
+                error = f.message
+            }
+        }
+    }
+
+    func loadOlder() {
+        guard let before = next, !loading else { return }
+        loading = true
+        Task {
+            let result = await fetchPage(agent, Self.pageSize, before)
+            loading = false
+            switch result {
+            case .success(let page):
+                exchanges = HistoryLogic.merge(exchanges, page.exchanges)
+                next = page.next
+            case .failure(let f):
+                error = f.message
+            }
+        }
+    }
+
+    private func loadDetail() {
+        detail = nil
+        guard let id = selected else { return }
+        Task {
+            let d = await fetchDetail(id)
+            if selected == id { detail = d }
+        }
+    }
+
+    func replay(_ id: String) {
+        notice = ""
+        error = ""
+        Task {
+            if let problem = await HistoryClient.replay(id) { error = problem }
+            else { notice = "Queued. It plays after anything already speaking." }
+        }
+    }
+
+    func copy(_ d: VoiceExchangeDetail) {
+        NSPasteboard.general.clearContents()
+        NSPasteboard.general.setString(d.answer ?? "", forType: .string)
+        notice = "Answer copied."
+    }
+
+    func openTask(_ d: VoiceExchangeDetail) {
+        guard let url = URL(string: Config.dashboardURL + d.taskPath) else { return }
+        NSWorkspace.shared.open(url)
+    }
+}
+
+struct HistoryView: View {
+    @ObservedObject var store: HistoryStore
+
+    var body: some View {
+        VStack(spacing: 0) {
+            toolbar
+            Divider()
+            HStack(spacing: 0) {
+                list.frame(width: 320)
+                Divider()
+                detailPane.frame(maxWidth: .infinity, maxHeight: .infinity)
+            }
+            if !store.error.isEmpty || !store.notice.isEmpty { footer }
+        }
+        .frame(minWidth: 760, minHeight: 480)
+        .background(Color(nsColor: .windowBackgroundColor))
+    }
+
+    private var toolbar: some View {
+        HStack(spacing: 10) {
+            Picker("Agent", selection: $store.agent) {
+                Text("All agents").tag(String?.none)
+                ForEach(store.agents, id: \.id) { a in Text(a.label).tag(String?.some(a.id)) }
+            }
+            .frame(width: 220)
+            Spacer()
+            if store.loading { ProgressView().controlSize(.small) }
+            Button("Refresh") { store.reload() }
+                .keyboardShortcut("r", modifiers: .command)
+        }
+        .padding(10)
+    }
+
+    @ViewBuilder private var list: some View {
+        if store.exchanges.isEmpty {
+            Text(store.loading ? "Loading…" : store.error.isEmpty ? "No voice exchanges yet." : "Nothing to show.")
+                .foregroundStyle(.secondary)
+                .frame(maxWidth: .infinity, maxHeight: .infinity)
+        } else {
+            List(selection: $store.selected) {
+                ForEach(store.days, id: \.title) { day in
+                    Section(day.title) {
+                        ForEach(day.exchanges) { e in row(e).tag(e.id) }
+                    }
+                }
+                if store.next != nil {
+                    Button("Load older") { store.loadOlder() }
+                        .frame(maxWidth: .infinity)
+                }
+            }
+            .listStyle(.inset)
+        }
+    }
+
+    private func row(_ e: VoiceExchange) -> some View {
+        VStack(alignment: .leading, spacing: 3) {
+            HStack(spacing: 6) {
+                Circle().fill(store.color(of: e.agentId)).frame(width: 8, height: 8)
+                Text(store.name(of: e.agentId)).font(.caption.weight(.semibold))
+                Spacer()
+                Text(e.date, style: .time).font(.caption).foregroundStyle(.secondary)
+                Text(HistoryLogic.duration(e.durationMs)).font(.caption.monospacedDigit()).foregroundStyle(.secondary)
+            }
+            Text(e.question).fontWeight(.medium).lineLimit(2)
+            Text(e.failed ? (e.error ?? "No answer") : e.answerPreview)
+                .font(.callout)
+                .foregroundStyle(e.failed ? Color(nsColor: Brand.alert) : .secondary)
+                .lineLimit(2)
+        }
+        .padding(.vertical, 3)
+        .accessibilityElement(children: .combine)
+    }
+
+    @ViewBuilder private var detailPane: some View {
+        if let d = store.detail {
+            ScrollView {
+                VStack(alignment: .leading, spacing: 14) {
+                    HStack(spacing: 6) {
+                        Circle().fill(store.color(of: d.agentId)).frame(width: 10, height: 10)
+                        Text(store.name(of: d.agentId)).font(.headline)
+                        Spacer()
+                        Text("Answered in \(HistoryLogic.duration(d.durationMs))")
+                            .font(.caption).foregroundStyle(.secondary)
+                    }
+                    VStack(alignment: .leading, spacing: 4) {
+                        Text("YOU SAID").font(.caption2.monospaced()).tracking(0.8).foregroundStyle(.secondary)
+                        Text(d.question).textSelection(.enabled)
+                    }
+                    VStack(alignment: .leading, spacing: 4) {
+                        Text("ANSWER").font(.caption2.monospaced()).tracking(0.8).foregroundStyle(.secondary)
+                        if let answer = d.answer, !answer.isEmpty {
+                            Text(written(answer)).textSelection(.enabled)
+                            if d.truncated { Text("The answer is longer; open the task for all of it.").font(.caption).foregroundStyle(.secondary) }
+                        } else {
+                            Text(d.error ?? "No answer was recorded.").foregroundStyle(Color(nsColor: Brand.alert))
+                        }
+                    }
+                    if !d.links.isEmpty {
+                        HStack(spacing: 8) {
+                            ForEach(d.links, id: \.1) { link in
+                                if let url = URL(string: link.1) { Link(link.0, destination: url) }
+                            }
+                        }
+                    }
+                    Divider()
+                    HStack(spacing: 8) {
+                        Button("Replay") { store.replay(d.id) }
+                            .disabled(!(d.answer?.isEmpty == false))
+                            .keyboardShortcut(.return, modifiers: .command)
+                        Button("Copy") { store.copy(d) }
+                            .disabled(!(d.answer?.isEmpty == false))
+                            .keyboardShortcut("c", modifiers: [.command, .shift])
+                        Button("Open task in dashboard") { store.openTask(d) }
+                    }
+                }
+                .padding(16)
+                .frame(maxWidth: .infinity, alignment: .leading)
+            }
+        } else {
+            Text(store.selected == nil ? "Select an exchange." : "Loading…")
+                .foregroundStyle(.secondary)
+        }
+    }
+
+    /// The answer as written: markdown links and bare URLs as links.
+    private func written(_ answer: String) -> AttributedString {
+        let md = HistoryLogic.linkify(answer)
+        return (try? AttributedString(markdown: md, options: .init(interpretedSyntax: .inlineOnlyPreservingWhitespace)))
+            ?? AttributedString(answer)
+    }
+
+    private var footer: some View {
+        HStack {
+            Text(store.error.isEmpty ? store.notice : store.error)
+                .foregroundStyle(store.error.isEmpty ? Color.secondary : Color(nsColor: .systemRed))
+                .font(.callout)
+            Spacer()
+        }
+        .padding(10)
+    }
+}
+
+@MainActor
+final class HistoryWindow: NSObject {
+    static let shared = HistoryWindow()
+    let store = HistoryStore()
+    private var window: NSWindow?
+
+    func show() {
+        if window == nil {
+            let w = NSWindow(contentRect: NSRect(x: 0, y: 0, width: 860, height: 560),
+                             styleMask: [.titled, .closable, .miniaturizable, .resizable],
+                             backing: .buffered, defer: false)
+            w.title = "AgentX Voice History"
+            w.isReleasedWhenClosed = false
+            w.contentView = NSHostingView(rootView: HistoryView(store: store))
+            w.center()
+            window = w
+        }
+        store.agents = []
+        store.reload()
+        NSApp.activate(ignoringOtherApps: true)
+        window?.makeKeyAndOrderFront(nil)
+    }
+}
+
+/// The menu's last three exchanges, for a quick replay.
+@MainActor
+final class RecentExchanges: NSObject {
+    private(set) var items: [VoiceExchange] = []
+
+    func refresh() async {
+        if case .success(let page) = await HistoryClient.page(agent: nil, limit: 3) { items = page.exchanges }
+    }
+
+    /// A "Recent" section, or nothing when there is no history.
+    func addItems(to menu: NSMenu, name: (String) -> String) {
+        guard !items.isEmpty else { return }
+        menu.addItem(.separator())
+        menu.addItem(NSMenuItem.sectionHeader(title: "Recent · click to replay"))
+        for e in items {
+            let row = NSMenuItem(title: HistoryLogic.menuTitle(e, agentName: name(e.agentId)),
+                                 action: #selector(replay(_:)), keyEquivalent: "")
+            row.target = self
+            row.representedObject = e.id
+            row.isEnabled = e.canReplay
+            row.toolTip = e.answerPreview.isEmpty ? nil : e.answerPreview
+            menu.addItem(row)
+        }
+    }
+
+    @objc private func replay(_ sender: NSMenuItem) {
+        guard let id = sender.representedObject as? String else { return }
+        Task {
+            if let problem = await HistoryClient.replay(id) { Log.warn("history replay: \(problem)") }
+        }
+    }
+}

package/apps/mac-voice/Sources/AgentXVoice/LocalSTT.swift

@@ -0,0 +1,79 @@
+import Foundation
+
+/// Parakeet as the app uses it: never makes a turn wait for a download or
+/// for the first model load, and answers nil whenever mlx-whisper should
+/// take this turn instead.
+///
+/// The first load of Parakeet on a Mac takes about half a minute (Core ML
+/// prepares the encoder for the Neural Engine and caches the result);
+/// later loads take about half a second. A turn waits a few seconds for
+/// the load at most, then falls back while the load carries on.
+enum LocalSTT {
+    /// How long a turn waits for Parakeet to finish loading.
+    static let loadPatience: TimeInterval = 4
+
+    private static let loader = ParakeetLoader()
+
+    static func parakeet(wav: Data) async -> String? {
+        guard ModelStore.parakeet.isInstalled else {
+            Log.warn("Parakeet is not downloaded yet; using mlx-whisper for now")
+            ModelStore.installInBackground(ModelStore.parakeet) { Log.info($0) }
+            return nil
+        }
+        guard let engine = await loader.engine(within: loadPatience) else {
+            Log.warn("Parakeet is still loading (the first load takes about 30 s); using mlx-whisper for this turn")
+            return nil
+        }
+        return await Task.detached(priority: .userInitiated) { () -> String? in
+            do {
+                let t = Date()
+                let text = try engine.transcribe(wav: wav)
+                Log.info(String(format: "parakeet: %.2f s", Date().timeIntervalSince(t)))
+                return text
+            } catch {
+                Log.warn("Parakeet failed (\(error.localizedDescription)); falling back to mlx-whisper")
+                return nil
+            }
+        }.value
+    }
+}
+
+/// Loads Parakeet once, in the background, and lets callers wait for it
+/// with a limit.
+private actor ParakeetLoader {
+    private var loading: Task<Parakeet?, Never>?
+
+    func engine(within seconds: TimeInterval) async -> Parakeet? {
+        let task = loading ?? start()
+        return await withTaskGroup(of: Parakeet?.self) { group in
+            group.addTask { await task.value }
+            group.addTask {
+                try? await Task.sleep(nanoseconds: UInt64(seconds * 1_000_000_000))
+                return nil
+            }
+            let first = await group.next() ?? nil
+            group.cancelAll()
+            return first
+        }
+    }
+
+    private func start() -> Task<Parakeet?, Never> {
+        let task = Task.detached(priority: .userInitiated) { () -> Parakeet? in
+            let t = Date()
+            do {
+                let p = try Parakeet.loaded()
+                Log.info(String(format: "parakeet: loaded in %.1f s", Date().timeIntervalSince(t)))
+                return p
+            } catch {
+                Log.warn("Parakeet would not load (\(error.localizedDescription))")
+                return nil
+            }
+        }
+        loading = task
+        Task { if await task.value == nil { self.forget() } }
+        return task
+    }
+
+    /// A failed load is tried again on the next turn.
+    private func forget() { loading = nil }
+}