pi-minimal 0.4.0 → 0.6.0

package/src/edit-diff.ts

@@ -0,0 +1,73 @@
+import type { Theme } from "@earendil-works/pi-coding-agent"
+import { diffWords } from "diff"
+import type { ToolResultLike } from "./tool-rows.js"
+
+/** The edit tool's `details.diff`, when present and non-empty. */
+export function editDiffText(result: ToolResultLike | undefined): string | undefined {
+  const details = result?.details as { diff?: unknown } | undefined
+  return typeof details?.diff === "string" && details.diff.trim() ? details.diff : undefined
+}
+
+type DiffLine = { prefix: "+" | "-" | " "; lineNum: string; content: string }
+
+/** pi's edit diff lines: "+123 content", "-123 content", " 123 context"; anything else (e.g. "...") is a separator. */
+function parseDiffLine(line: string): DiffLine | undefined {
+  const match = /^([+\- ])(\s*\d*) (.*)$/.exec(line)
+  if (!match) return undefined
+  return { prefix: match[1] as DiffLine["prefix"], lineNum: match[2]!, content: match[3]!.replace(/\t/g, "   ") }
+}
+
+/** Word-level diff of a 1:1 replacement; changed tokens are inverted, leading indentation is left alone, as in pi. */
+function highlightPair(removed: string, added: string, theme: Theme): { removed: string; added: string } {
+  let out = { removed: "", added: "" }
+  let firstRemoved = true
+  let firstAdded = true
+  for (const part of diffWords(removed, added)) {
+    if (part.removed || part.added) {
+      const key = part.removed ? "removed" : "added"
+      let value = part.value
+      if (part.removed ? firstRemoved : firstAdded) {
+        const ws = /^(\s*)/.exec(value)?.[1] ?? ""
+        value = value.slice(ws.length)
+        out = { ...out, [key]: out[key] + ws }
+        if (part.removed) firstRemoved = false
+        else firstAdded = false
+      }
+      if (value) out = { ...out, [key]: out[key] + theme.inverse(value) }
+    } else {
+      out = { removed: out.removed + part.value, added: out.added + part.value }
+    }
+  }
+  return out
+}
+
+/** Colours pi's edit diff like pi does: theme diff colours per line, inverse on changed tokens of single-line replacements. */
+export function colorDiffLines(lines: string[], theme: Theme): string[] {
+  const out: string[] = []
+  for (let i = 0; i < lines.length; ) {
+    const parsed = parseDiffLine(lines[i]!)
+    if (!parsed) {
+      out.push(theme.fg("toolDiffContext", lines[i]!))
+      i++
+      continue
+    }
+    if (parsed.prefix === " ") {
+      out.push(theme.fg("toolDiffContext", ` ${parsed.lineNum} ${parsed.content}`))
+      i++
+      continue
+    }
+    const removed: DiffLine[] = []
+    const added: DiffLine[] = []
+    for (let p = parseDiffLine(lines[i] ?? ""); p?.prefix === "-"; p = parseDiffLine(lines[++i] ?? "")) removed.push(p)
+    for (let p = parseDiffLine(lines[i] ?? ""); p?.prefix === "+"; p = parseDiffLine(lines[++i] ?? "")) added.push(p)
+    if (removed.length === 1 && added.length === 1) {
+      const pair = highlightPair(removed[0]!.content, added[0]!.content, theme)
+      out.push(theme.fg("toolDiffRemoved", `-${removed[0]!.lineNum} ${pair.removed}`))
+      out.push(theme.fg("toolDiffAdded", `+${added[0]!.lineNum} ${pair.added}`))
+      continue
+    }
+    for (const line of removed) out.push(theme.fg("toolDiffRemoved", `-${line.lineNum} ${line.content}`))
+    for (const line of added) out.push(theme.fg("toolDiffAdded", `+${line.lineNum} ${line.content}`))
+  }
+  return out
+}

package/src/footer-contribution-events.ts

@@ -5,8 +5,11 @@ export const FOOTER_EVENTS = {
   ready: "pi-minimal:footer:v1:ready",
   unavailable: "pi-minimal:footer:v1:unavailable",
 } as const
+/** Slot names on the wire. `summary` is the legacy name of the plan slot and stays accepted. */
+export const FOOTER_SLOTS = ["activity", "plan", "summary"] as const
+export type FooterSlot = typeof FOOTER_SLOTS[number]
 export type RegisterRequest = {
-  version: 1; sessionId: string; owner: string; slot: "activity" | "summary"
+  version: 1; sessionId: string; owner: string; slot: FooterSlot
   result?: RegistrationResult | { ok: false; code: "not-tui" }
 }
 type Events = {
@@ -22,11 +25,11 @@ export function bindFooterContributionEvents(events: Events, registry: FooterCon
     const request = value as Partial<RegisterRequest>
     // A different host may have answered first. Never overwrite its result.
     if (request.result !== undefined) return
-    if (request.version !== 1 || (request.slot !== "activity" && request.slot !== "summary")) request.result = { ok: false, code: "invalid" }
+    if (request.version !== 1 || !FOOTER_SLOTS.includes(request.slot as FooterSlot)) request.result = { ok: false, code: "invalid" }
     else if (mode !== "tui") request.result = { ok: false, code: "not-tui" }
-    else request.result = request.slot === "summary" ? registry.registerPlan(request) : registry.register(request)
+    else request.result = request.slot === "activity" ? registry.register(request) : registry.registerPlan(request)
   })
-  if (mode === "tui") events.emit(FOOTER_EVENTS.ready, { version: 1, sessionId, slots: ["activity", "summary"] })
+  if (mode === "tui") events.emit(FOOTER_EVENTS.ready, { version: 1, sessionId, slots: [...FOOTER_SLOTS] })
   let disposed = false
   return () => {
     if (disposed) return

package/src/footer-contributions.ts

@@ -77,7 +77,8 @@ function normalizeSnapshot(input: unknown): ActivitySnapshot | undefined {
 
 function createFooterSlot<T extends { revision: number }>(normalize: (input: unknown) => T | undefined, initialSessionId: string | null) {
   let sessionId = initialSessionId
-  let owner: symbol | undefined
+  // The registrant's `owner` string is a display identity; this symbol is the actual authority to publish.
+  let ownerToken: symbol | undefined
   let snapshot: T | undefined
   const observers = new Set<() => void>()
   const notify = () => {
@@ -89,17 +90,17 @@ function createFooterSlot<T extends { revision: number }>(normalize: (input: unk
     read: () => snapshot,
     subscribe(observer: () => void) { observers.add(observer); return () => { observers.delete(observer) } },
     reset(nextSessionId: string | null) {
-      sessionId = nextSessionId; owner = undefined; snapshot = undefined; notify()
+      sessionId = nextSessionId; ownerToken = undefined; snapshot = undefined; notify()
     },
     register(input: unknown): RegistrationResult {
       if (!record(input) || !identity(input.owner) || typeof input.sessionId !== "string" || !input.sessionId) return { ok: false, code: "invalid" }
       if (sessionId === null || input.sessionId !== sessionId) return { ok: false, code: "wrong-session" }
-      if (owner) return { ok: false, code: "occupied" }
+      if (ownerToken) return { ok: false, code: "occupied" }
       const token = Symbol(input.owner)
-      owner = token
+      ownerToken = token
       return { ok: true, registration: {
         publish(input: unknown) {
-          if (owner !== token) return { ok: false, code: "disposed" }
+          if (ownerToken !== token) return { ok: false, code: "disposed" }
           const next = normalize(input)
           if (!next) return { ok: false, code: "invalid" }
           if (snapshot && next.revision <= snapshot.revision) return { ok: false, code: "stale" }
@@ -107,8 +108,8 @@ function createFooterSlot<T extends { revision: number }>(normalize: (input: unk
           return { ok: true }
         },
         dispose() {
-          if (owner !== token) return
-          owner = undefined; snapshot = undefined; notify()
+          if (ownerToken !== token) return
+          ownerToken = undefined; snapshot = undefined; notify()
         },
       } }
     },
@@ -116,17 +117,18 @@ function createFooterSlot<T extends { revision: number }>(normalize: (input: unk
 }
 export function createFooterContributions(initialSessionId: string | null = null) {
   const activity = createFooterSlot(normalizeSnapshot, initialSessionId)
-  const summary = createFooterSlot(normalizePlanSnapshot, initialSessionId)
+  // The plan slot; "summary" is its legacy wire name.
+  const plan = createFooterSlot(normalizePlanSnapshot, initialSessionId)
   return {
     read: activity.read,
-    readPlan: summary.read,
+    readPlan: plan.read,
     register: activity.register,
-    registerPlan: summary.register,
+    registerPlan: plan.register,
     subscribe(observer: () => void) {
-      const offActivity = activity.subscribe(observer), offSummary = summary.subscribe(observer)
-      return () => { offActivity(); offSummary() }
+      const offActivity = activity.subscribe(observer), offPlan = plan.subscribe(observer)
+      return () => { offActivity(); offPlan() }
     },
-    reset(sessionId: string | null) { activity.reset(sessionId); summary.reset(sessionId) },
+    reset(sessionId: string | null) { activity.reset(sessionId); plan.reset(sessionId) },
   }
 }
 export type FooterContributions = ReturnType<typeof createFooterContributions>

package/src/footer.ts

@@ -2,6 +2,7 @@ import type { ExtensionContext } from "@earendil-works/pi-coding-agent"
 import { keyHint } from "@earendil-works/pi-coding-agent"
 import { truncateToWidth } from "@earendil-works/pi-tui"
 import * as chrome from "./chrome.js"
+import { splitRow } from "./cwd.js"
 import { formatTrackerLines } from "./tracker.js"
 import type { FooterContributions } from "./footer-contributions.js"
 import { activityNeedsAnimation, renderFooterActivity } from "./footer-activity.js"
@@ -19,6 +20,14 @@ export type FooterSources = {
   editorText: () => string
   /** Context usage percentage, when known. */
   contextPct: () => number | undefined
+  /** Open PR chips (`#1675 #1670 +3`), themed and linked, shown right-aligned on the hints line. */
+  prs?: (theme: { fg(color: string, text: string): string }) => string | undefined
+  /** Fires when the PR chips may have changed. */
+  onPrsChange?: (listener: () => void) => () => void
+  /** `⚙ 2 bg` while bash-tool processes run in the background; shown after the hints. */
+  background?: () => string | undefined
+  /** Fires when the background count may have changed. */
+  onBackgroundChange?: (listener: () => void) => () => void
 }
 
 /**
@@ -52,11 +61,15 @@ export function installFooter(ctx: ExtensionContext, sources: FooterSources, con
     const update = () => { syncAnimation(); redraw() }
     const unsub = footerData.onBranchChange(redraw)
     const unsubscribeActivity = contributions?.subscribe(update)
+    const unsubscribePrs = sources.onPrsChange?.(redraw)
+    const unsubscribeBackground = sources.onBackgroundChange?.(redraw)
     stopMount = () => {
       if (disposed) return
       disposed = true
       unsub()
       unsubscribeActivity?.()
+      unsubscribePrs?.()
+      unsubscribeBackground?.()
       live.stop()
     }
     update()
@@ -71,9 +84,16 @@ export function installFooter(ctx: ExtensionContext, sources: FooterSources, con
           keyHint("app.thinking.cycle", "thinking"),
           keyHint("app.tools.expand", "expand tools"),
         ].filter(Boolean))
-        if (hints.length > 0) {
-          const line = theme.fg("dim", hints.join("  ·  "))
-          out.push(`${" ".repeat(margin())}${truncateToWidth(line, inner, "")}`)
+        // Left: hints (idle only) then the background count (always). Right: PR chips whenever
+        // there are any. The chips are dropped before the left side when the line is too narrow.
+        const background = sources.background?.()
+        const left = [hints.length > 0 ? theme.fg("dim", hints.join("  ·  ")) : "", background ? theme.fg("warning", background) : ""]
+          .filter(Boolean)
+          .join(theme.fg("dim", "  ·  "))
+        const prs = sources.prs?.(theme)
+        if (left || prs) {
+          const line = prs ? splitRow(left, [prs], inner) : truncateToWidth(left, inner, "")
+          out.push(`${" ".repeat(margin())}${line}`)
         }
         const activityWidth = Math.max(0, width - margin() * 2)
         const plan = renderFooterPlan(contributions?.readPlan(), activityWidth, theme)

package/src/git-state.ts

@@ -30,30 +30,45 @@ export function createGitState(pi: ExtensionAPI, cwd: () => string, minIntervalM
   let state: GitState | undefined
   let lastRun = 0
   let inFlight: Promise<void> | undefined
+  let disposed = false
   const listeners = new Set<() => void>()
 
+  const notify = () => {
+    for (const listener of listeners) {
+      try {
+        listener()
+      } catch {
+        // One listener's failure must not starve the others.
+      }
+    }
+  }
+
   const refresh = (force = false): Promise<void> => {
+    if (disposed) return Promise.resolve()
     const now = Date.now()
     if (inFlight) return inFlight
     if (!force && now - lastRun < minIntervalMs) return Promise.resolve()
     lastRun = now
+    // Read the directory once so both commands describe the same tree even if cwd changes mid-refresh.
+    const dir = cwd()
     inFlight = (async () => {
+      let next: GitState | undefined
       try {
-        const branchRun = await pi.exec("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: cwd(), timeout: 2000 })
-        if (branchRun.code !== 0) {
-          state = undefined
-          return
+        const branchRun = await pi.exec("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: dir, timeout: 2000 })
+        if (branchRun.code === 0) {
+          const branch = parseBranch(branchRun.stdout)
+          const statusRun = await pi.exec("git", ["status", "--porcelain"], { cwd: dir, timeout: 3000 })
+          next = { branch, dirty: statusRun.code === 0 ? parsePorcelain(statusRun.stdout) : undefined }
         }
-        const branch = parseBranch(branchRun.stdout)
-        const statusRun = await pi.exec("git", ["status", "--porcelain"], { cwd: cwd(), timeout: 3000 })
-        const dirty = statusRun.code === 0 ? parsePorcelain(statusRun.stdout) : undefined
-        state = { branch, dirty }
       } catch {
-        state = undefined
+        next = undefined
       } finally {
         inFlight = undefined
-        for (const listener of listeners) listener()
       }
+      // A result that lands after dispose belongs to a session that no longer exists.
+      if (disposed) return
+      state = next
+      notify()
     })()
     return inFlight
   }
@@ -65,6 +80,10 @@ export function createGitState(pi: ExtensionAPI, cwd: () => string, minIntervalM
       listeners.add(listener)
       return () => listeners.delete(listener)
     },
+    dispose() {
+      disposed = true
+      listeners.clear()
+    },
   }
 }
 

package/src/herdr.ts

@@ -1,3 +1,9 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
+import { createListeners } from "./listeners.js"
+import type { Sibling, SiblingSource } from "./siblings.js"
+
+export type { Sibling } from "./siblings.js"
+
 export type HerdrAgent = {
   agent: string
   agent_status: string
@@ -40,11 +46,6 @@ export function parseTabList(stdout: string): HerdrTab[] {
   }))
 }
 
-export type Sibling = {
-  name: string
-  status: string
-}
-
 export function listSiblings(
   agents: HerdrAgent[],
   tabs: HerdrTab[],
@@ -64,3 +65,75 @@ export function listSiblings(
   if (parts.length === 0) return undefined
   return parts
 }
+
+const HERDR_FAST_MS = 2000
+const HERDR_SLOW_MS = 10000
+const HERDR_EXEC_TIMEOUT_MS = 3000
+
+/**
+ * Polls `herdr agent list` + `herdr tab list`: every 2 s while siblings are visible, every 10 s
+ * otherwise or after a failure. Probes once immediately.
+ */
+export function createHerdrSiblings(pi: ExtensionAPI, env: NodeJS.ProcessEnv = process.env): SiblingSource {
+  let alive = true
+  let siblings: Sibling[] | undefined
+  let timer: ReturnType<typeof setInterval> | undefined
+  let period = 0
+  let inFlight: AbortController | undefined
+  const listeners = createListeners()
+
+  const set = (next: Sibling[] | undefined) => {
+    const changed = JSON.stringify(next) !== JSON.stringify(siblings)
+    siblings = next
+    if (changed) listeners.notify()
+  }
+
+  const schedule = (periodMs: number) => {
+    if (!alive || period === periodMs) return
+    if (timer) clearInterval(timer)
+    period = periodMs
+    timer = setInterval(() => { void probe() }, periodMs)
+  }
+
+  const probe = async () => {
+    if (!alive || inFlight) return
+    const ac = new AbortController()
+    inFlight = ac
+    try {
+      const agentRun = await pi.exec("herdr", ["agent", "list"], { timeout: HERDR_EXEC_TIMEOUT_MS, signal: ac.signal })
+      if (!alive) return
+      const tabRun = await pi.exec("herdr", ["tab", "list"], { timeout: HERDR_EXEC_TIMEOUT_MS, signal: ac.signal })
+      if (!alive) return
+      if (agentRun.code !== 0 || tabRun.code !== 0 || agentRun.killed || tabRun.killed) {
+        set(undefined)
+        schedule(HERDR_SLOW_MS)
+        return
+      }
+      set(listSiblings(parseAgentList(agentRun.stdout), parseTabList(tabRun.stdout), env.HERDR_PANE_ID, env.HERDR_TAB_ID))
+      schedule(siblings ? HERDR_FAST_MS : HERDR_SLOW_MS)
+    } catch {
+      if (!alive) return
+      set(undefined)
+      schedule(HERDR_SLOW_MS)
+    } finally {
+      if (inFlight === ac) inFlight = undefined
+    }
+  }
+
+  void probe()
+
+  return {
+    get: () => siblings,
+    onChange: listeners.add,
+    dispose() {
+      if (!alive) return
+      alive = false
+      if (timer) clearInterval(timer)
+      timer = undefined
+      inFlight?.abort()
+      inFlight = undefined
+      siblings = undefined
+      listeners.clear()
+    },
+  }
+}