path: root/menubar/main.swift

// dingger menu bar: live agent states from tmux pane user options
// (@agent / @agent_state), written by the dingger daemon.
//
// Visual language is herdr's agent panel, verbatim: five statuses
// (working ◐ yellow, blocked × red, done ✓ teal, idle ○ green,
// unknown · gray), priority order blocked > done > working > idle,
// and the number in the title is herdr's actionable set (done + blocked).

import AppKit

struct PaneRow {
    let paneId: String
    let target: String
    let agent: String
    let state: String
}

let red = NSColor.systemRed
let yellow = NSColor.systemYellow
let teal = NSColor.systemTeal
let green = NSColor.systemGreen
let gray = NSColor.systemGray

/// Tint a symbol image (non-template, so it keeps its color in menus).
func tinted(_ image: NSImage?, _ color: NSColor) -> NSImage? {
    guard let image = image else { return nil }
    let img = NSImage(size: image.size, flipped: false) { rect in
        image.draw(in: rect)
        color.set()
        rect.fill(using: .sourceAtop)
        return true
    }
    img.isTemplate = false
    return img
}

func symbol(_ name: String, _ color: NSColor? = nil) -> NSImage? {
    let image = NSImage(systemSymbolName: name, accessibilityDescription: nil)?
        .withSymbolConfiguration(.init(pointSize: 13, weight: .regular))
    return color.map { tinted(image, $0) } ?? image
}

/// Herdr's status_color + Symbols style, as SF Symbols.
func statusSymbol(_ status: String) -> NSImage? {
    switch status {
    case "working": return symbol("circle.dotted", yellow)
    case "blocked": return symbol("exclamationmark.circle.fill", red)
    case "done": return symbol("checkmark.circle.fill", teal)
    case "idle": return symbol("checkmark.circle", green)
    default: return symbol("questionmark.circle", gray)
    }
}

func statusPriority(_ status: String) -> Int {
    switch status {
    case "blocked": return 4
    case "done": return 3
    case "working": return 2
    case "idle": return 1
    default: return 0
    }
}

final class Menubar: NSObject, NSApplicationDelegate, NSMenuDelegate {
    private let item = NSStatusBar.system.statusItem(withLength: NSStatusItem.variableLength)
    private let menu = NSMenu()
    private var panes: [PaneRow] = []
    private var queue: [String] = [] // pane ids, oldest waiting first

    func applicationDidFinishLaunching(_: Notification) {
        NSApp.setActivationPolicy(.accessory) // no Dock icon
        item.button?.image = symbol("bell", gray)
        item.button?.font = NSFont.monospacedDigitSystemFont(ofSize: 13, weight: .regular)
        item.menu = menu
        menu.delegate = self
        let timer = Timer(timeInterval: 2.0, repeats: true) { [weak self] _ in
            self?.refreshTitle()
        }
        RunLoop.main.add(timer, forMode: .common)
        refreshTitle()
    }

    // MARK: data

    private func runTmux(_ args: [String]) -> String? {
        let process = Process()
        process.executableURL = URL(fileURLWithPath: "/opt/homebrew/bin/tmux")
        process.arguments = args
        let pipe = Pipe()
        process.standardOutput = pipe
        process.standardError = FileHandle.nullDevice
        do {
            try process.run()
        } catch {
            return nil
        }
        let data = pipe.fileHandleForReading.readDataToEndOfFile()
        process.waitUntilExit()
        guard process.terminationStatus == 0 else { return nil }
        return String(data: data, encoding: .utf8)
    }

    private func fetchPanes() -> [PaneRow] {
        let fmt = "#{pane_id}\t#{@agent}\t#{@agent_state}\t#{@dingger_ack}\t#{session_name}:#{window_name}\t#{window_panes}\t#{pane_index}"
        guard let out = runTmux(["-u", "list-panes", "-a", "-F", fmt]) else { return [] }
        return out.split(separator: "\n").compactMap { line in
            let fields = line.split(separator: "\t", omittingEmptySubsequences: false)
            guard fields.count >= 7 else { return nil }
            let agent = String(fields[1])
            let state = fields[2].isEmpty ? "unknown" : String(fields[2])
            guard !agent.isEmpty, ["working", "blocked", "done", "idle"].contains(state) else {
                return nil
            }
            // fields[4] is already `session:window-name`; add the pane index
            // only when the window is split.
            var target = String(fields[4])
            if Int(fields[5]) ?? 1 > 1 {
                target += ".\(fields[6])"
            }
            return PaneRow(paneId: String(fields[0]), target: target, agent: agent, state: state)
        }
    }

    private func fetchQueue() -> [String] {
        guard let out = runTmux(["-u", "show-option", "-gv", "@dingger_queue"]) else { return [] }
        return out.trimmingCharacters(in: .whitespacesAndNewlines)
            .split(separator: ",").map { $0.split(separator: ":").first.map(String.init) ?? "" }
    }

    private func orderedPanes() -> [PaneRow] {
        // herdr's priority: blocked > done > working > idle; FIFO within the
        // queue (oldest waiting first), target order for the rest.
        let priority = { (row: PaneRow) -> Int in statusPriority(row.state) }
        var rows = panes
        rows.sort {
            let (pa, pb) = (priority($0), priority($1))
            if pa != pb { return pa > pb }
            let (qa, qb) = (queue.firstIndex(of: $0.paneId), queue.firstIndex(of: $1.paneId))
            if let qa, let qb { return qa < qb }
            if qa != nil { return true }
            if qb != nil { return false }
            return $0.target < $1.target
        }
        return rows
    }

    // MARK: title (timer-driven; never touches the open menu)

    private func refreshTitle() {
        panes = fetchPanes()
        queue = fetchQueue()
        FileHandle.standardError.write(Data(
            "\(Date()) menubar: panes=\(panes.count) queue=\(queue.count)\n".utf8))
        redrawTitle()
    }

    private func redrawTitle() {
        let blocked = panes.filter { $0.state == "blocked" }.count
        let done = panes.filter { $0.state == "done" }.count
        let working = panes.filter { $0.state == "working" }.count

        let (image, count): (NSImage?, String)
        if blocked > 0 {
            (image, count) = (symbol("bell.fill", red), String(blocked))
        } else if done > 0 {
            (image, count) = (symbol("bell.fill", teal), String(done))
        } else if working > 0 {
            (image, count) = (symbol("bell", yellow), "")
        } else {
            (image, count) = (symbol("bell", gray), "")
        }
        item.button?.image = image
        item.button?.title = count

        var tip: [String] = []
        if blocked > 0 { tip.append("\(blocked) blocked") }
        if done > 0 { tip.append("\(done) done") }
        if working > 0 { tip.append("\(working) working") }
        let tipText = tip.isEmpty ? "No agents" : tip.joined(separator: " · ")
        item.button?.toolTip = tipText
        item.button?.setAccessibilityLabel("dingger, " + tipText)
    }

    // MARK: menu (rebuilt when opened, so rows don't reshuffle under the cursor)

    func menuNeedsUpdate(_ menu: NSMenu) {
        rebuildMenu()
    }

    private func rebuildMenu() {
        menu.removeAllItems()

        let rows = orderedPanes()
        if rows.isEmpty {
            let none = NSMenuItem(title: "No agents", action: nil, keyEquivalent: "")
            none.isEnabled = false
            menu.addItem(none)
        }

        var previousPriority: Int?
        for pane in rows {
            let priority = statusPriority(pane.state)
            if let previous = previousPriority, previous != priority {
                menu.addItem(.separator())
            }
            previousPriority = priority

            let row = NSMenuItem(title: "\(pane.agent)\t\(pane.target)",
                                 action: #selector(paneClicked(_:)), keyEquivalent: "")
            row.target = self
            row.image = statusSymbol(pane.state)
            row.attributedTitle = attributedRow(agent: pane.agent, target: pane.target)
            row.toolTip = "\(pane.state) — \(pane.target)"
            row.representedObject = pane.paneId
            menu.addItem(row)
        }

        menu.addItem(.separator())
        let quit = NSMenuItem(title: "Quit dingger", action: #selector(NSApplication.terminate(_:)), keyEquivalent: "q")
        menu.addItem(quit)
    }

    /// Agent left, tmux target right-aligned at a computed tab stop — like a
    /// native menu's key-equivalent column.
    private func attributedRow(agent: String, target: String) -> NSAttributedString {
        let menuFont = NSFont.menuFont(ofSize: 0)
        let monoFont = NSFont.monospacedSystemFont(
            ofSize: menuFont.pointSize - 1, weight: .regular)
        let agentWidth = (agent as NSString).size(withAttributes: [.font: menuFont]).width
        let targetWidth = (target as NSString).size(withAttributes: [.font: monoFont]).width
        let tabStop = ceil(agentWidth + 40 + targetWidth)

        let paragraph = NSMutableParagraphStyle()
        paragraph.tabStops = [NSTextTab(textAlignment: .right, location: tabStop)]

        let text = NSMutableAttributedString()
        text.append(NSAttributedString(
            string: agent,
            attributes: [.font: menuFont, .paragraphStyle: paragraph]))
        text.append(NSAttributedString(string: "\t"))
        text.append(NSAttributedString(
            string: target,
            attributes: [.font: monoFont, .paragraphStyle: paragraph]))
        return text
    }

    // MARK: actions

    func printPanesForDebug() {
        panes = fetchPanes()
        queue = fetchQueue()
        let rows = orderedPanes()
        if rows.isEmpty { print("(no agents)") }
        for pane in rows {
            print("\(pane.state)  \(pane.agent)  \(pane.target)")
        }
    }

    @objc private func paneClicked(_ sender: NSMenuItem) {
        guard let paneId = sender.representedObject as? String else { return }
        // Ack like `dingger focus` does, so both counts drop together.
        _ = runTmux(["-u", "set-option", "-p", "-t", paneId, "@dingger_ack", "1"])
        let target = panes.first { $0.paneId == paneId }?.target ?? ""
        guard !target.isEmpty else { return }
        _ = runTmux(["-u", "switch-client", "-t", target])
        for bundle in ["com.mitchellh.ghostty", "org.alacritty", "com.apple.Terminal"] {
            if let app = NSRunningApplication.runningApplications(withBundleIdentifier: bundle).first {
                app.activate()
                break
            }
        }
    }
}

let app = NSApplication.shared
let delegate = Menubar()
app.delegate = delegate
app.setActivationPolicy(.accessory)

// Debug: print the rows the menu would show and exit.
if CommandLine.arguments.contains("--print") {
    delegate.printPanesForDebug()
    exit(0)
}

app.run()