pi-minimal 0.1.0 → 0.2.2

package/src/cwd.ts

@@ -1,9 +1,15 @@
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui"
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent"
 import path from "node:path"
-import { CHROME_MARGIN } from "./chrome.js"
+import * as chrome from "./chrome.js"
+import { formatGitState, type GitState } from "./git-state.js"
+import type { Sibling } from "./herdr.js"
 
-function formatCwd(cwd: string): string {
+/** Tolerates a stale chrome module after /reload, where only CHROME_MARGIN may exist. */
+const margin = (): number => (typeof chrome.chromeMargin === "function" ? chrome.chromeMargin() : (chrome.CHROME_MARGIN ?? 1))
+
+
+export function formatCwd(cwd: string): string {
   const home = process.env.HOME || process.env.USERPROFILE || ""
   if (!home) return cwd
   const resolved = path.resolve(cwd)
@@ -14,7 +20,7 @@ function formatCwd(cwd: string): string {
   return cwd
 }
 
-function formatTokens(n: number): string {
+export function formatTokens(n: number): string {
   if (n < 1000) return String(n)
   if (n < 10000) return `${(n / 1000).toFixed(1)}K`
   if (n < 1e6) return `${Math.round(n / 1000)}K`
@@ -22,7 +28,7 @@ function formatTokens(n: number): string {
   return `${Math.round(n / 1e6)}M`
 }
 
-function modelIcon(id: string): string {
+export function modelIcon(id: string): string {
   const s = id.toLowerCase()
   if (s.includes("grok")) return "✦"
   if (
@@ -38,7 +44,7 @@ function modelIcon(id: string): string {
   return "◆"
 }
 
-function shortModel(id: string): string {
+export function shortModel(id: string): string {
   return (id.split("/").pop() || id).replace(/^claude-/, "")
 }
 
@@ -48,61 +54,107 @@ function thinkingColor(level: string): "dim" | "accent" | "warning" {
   return "dim"
 }
 
-function meter(percent: number, fill: string, empty: string): string {
-  const n = 8
-  const filled = Math.max(0, Math.min(n, Math.round((percent / 100) * n)))
-  return fill.repeat(filled) + empty.repeat(n - filled)
+/** Context pressure band used for the meter and percentage colour. */
+export function contextBand(pct: number): "accent" | "warning" | "error" {
+  if (pct >= 90) return "error"
+  if (pct >= 70) return "warning"
+  return "accent"
 }
 
-function splitRow(left: string, right: string, width: number): string {
-  let L = left
-  let R = right
-  while (visibleWidth(L) + 1 + visibleWidth(R) > width && visibleWidth(R) > 0) {
-    R = truncateToWidth(R, Math.max(0, visibleWidth(R) - 1), "")
+export function meter(percent: number, fill: string, empty: string, cells = 8): string {
+  const filled = Math.max(0, Math.min(cells, Math.round((percent / 100) * cells)))
+  return fill.repeat(filled) + empty.repeat(cells - filled)
+}
+
+/**
+ * Fit `left` and `right` into `width`. Right-hand segments are dropped from the end first (they are
+ * the least important), then the left is truncated.
+ */
+export function splitRow(left: string, rightSegments: string[], width: number, sep = "  "): string {
+  const segments = [...rightSegments.filter((s) => visibleWidth(s) > 0)]
+  let right = segments.join(sep)
+  while (segments.length > 0 && visibleWidth(left) + 2 + visibleWidth(right) > width) {
+    segments.pop()
+    right = segments.join(sep)
   }
-  while (visibleWidth(L) + 1 + visibleWidth(R) > width && visibleWidth(L) > 0) {
-    L = truncateToWidth(L, Math.max(0, visibleWidth(L) - 1), "")
+  let L = left
+  if (visibleWidth(L) + (right ? 2 : 0) + visibleWidth(right) > width) {
+    L = truncateToWidth(L, Math.max(0, width - (right ? 2 : 0) - visibleWidth(right)), "")
   }
-  const gap = Math.max(1, width - visibleWidth(L) - visibleWidth(R))
-  return L + " ".repeat(gap) + R
+  const gap = right ? Math.max(2, width - visibleWidth(L) - visibleWidth(right)) : 0
+  return L + " ".repeat(gap) + right
 }
 
-export function installCwd(ctx: ExtensionContext): void {
+function siblingColor(status: string): "success" | "warning" | "error" | "accent" | "muted" {
+  if (status === "idle" || status === "done") return "success"
+  if (status === "working") return "accent"
+  if (status === "blocked") return "error"
+  return "muted"
+}
+
+export type StatusLineSources = {
+  gitState: () => GitState | undefined
+  siblings: () => Sibling[] | undefined
+  onGitChange: (listener: () => void) => () => void
+}
+
+export function installCwd(ctx: ExtensionContext, sources: StatusLineSources): void {
   ctx.ui.setWidget(
     "tw-cwd",
-    (_tui, theme) => ({
-      invalidate() {},
-      render(width: number): string[] {
-        const inner = Math.max(8, width - CHROME_MARGIN * 2)
-        const id = ctx.model?.id || "no-model"
-        const icon = theme.fg("accent", modelIcon(id))
-        const name = theme.fg("text", shortModel(id))
-        const usage = ctx.getContextUsage?.()
-        const window = usage?.contextWindow || ctx.model?.contextWindow
-        const used = usage?.tokens
-        let tokenStr = theme.fg("dim", "?/?")
-        let bar = theme.fg("dim", "░░░░░░░░")
-        let pctStr = theme.fg("dim", "?%")
-        if (typeof used === "number" && window) {
-          const pct = Math.max(0, Math.min(100, Math.round((used / window) * 100)))
-          tokenStr = theme.fg("dim", `${formatTokens(used)}/${formatTokens(window)}`)
-          const hot = pct >= 85
-          bar = meter(pct, theme.fg(hot ? "warning" : "accent", "█"), theme.fg("dim", "░"))
-          pctStr = theme.fg(hot ? "warning" : "muted", `${pct}%`)
-        } else if (used === null && window) {
-          tokenStr = theme.fg("dim", `?/${formatTokens(window)}`)
-        }
-        const thinking = ctx.thinkingLevel || ""
-        const think = thinking ? theme.fg(thinkingColor(thinking), thinking) : ""
-        const midot = theme.fg("dim", " · ")
-        const left = [`${icon} ${name}`, tokenStr, `${bar} ${pctStr}`, think]
-          .filter(Boolean)
-          .join(midot)
-        const right = ctx.cwd ? theme.fg("accent", formatCwd(ctx.cwd)) : ""
-        const row = splitRow(left, right, inner)
-        return [`${" ".repeat(CHROME_MARGIN)}${row}`]
-      },
-    }),
+    (tui, theme) => {
+      const unsub = sources.onGitChange(() => tui.requestRender())
+      return {
+        dispose: unsub,
+        invalidate() {},
+        render(width: number): string[] {
+          const inner = Math.max(8, width - margin() * 2)
+          const id = ctx.model?.id || "no-model"
+          const icon = theme.fg("accent", modelIcon(id))
+          const name = theme.fg("text", shortModel(id))
+          const thinking = ctx.thinkingLevel || ""
+          const think = thinking ? theme.fg(thinkingColor(thinking), thinking) : ""
+
+          const usage = ctx.getContextUsage?.()
+          const window = usage?.contextWindow || ctx.model?.contextWindow
+          const used = usage?.tokens
+          let bar = theme.fg("dim", "░░░░░░░░")
+          let pctStr = theme.fg("dim", "?%")
+          let tokenStr = theme.fg("dim", "?/?")
+          if (typeof used === "number" && window) {
+            const pct = Math.max(0, Math.min(100, Math.round((used / window) * 100)))
+            const band = contextBand(pct)
+            bar = meter(pct, theme.fg(band, "▓"), theme.fg("dim", "░"))
+            pctStr = theme.fg(band === "accent" ? "muted" : band, `${pct}%`)
+            tokenStr = theme.fg("dim", `${formatTokens(used)}/${formatTokens(window)}`)
+          } else if (used === null && window) {
+            tokenStr = theme.fg("dim", `?/${formatTokens(window)}`)
+          }
+
+          const midot = theme.fg("dim", " · ")
+          const model = [`${icon} ${name}`, think].filter(Boolean).join(midot)
+          const context = `${bar} ${pctStr} ${tokenStr}`
+          const left = `${model}   ${context}`
+
+          const right: string[] = []
+          if (ctx.cwd) right.push(theme.fg("muted", formatCwd(ctx.cwd)))
+          const git = formatGitState(sources.gitState())
+          if (git.branch) {
+            const dirty = git.dirty ? ` ${theme.fg("warning", git.dirty)}` : ""
+            right.push(`${theme.fg("dim", "⎇")} ${theme.fg("muted", git.branch)}${dirty}`)
+          }
+          const siblings = sources.siblings()
+          if (siblings && siblings.length > 0) {
+            right.push(
+              siblings
+                .map((s) => `${theme.fg("text", s.name)} ${theme.fg(siblingColor(s.status), s.status)}`)
+                .join(theme.fg("dim", " · ")),
+            )
+          }
+          const row = splitRow(left, right, inner)
+          return [`${" ".repeat(margin())}${row}`]
+        },
+      }
+    },
     { placement: "aboveEditor" },
   )
 }

package/src/footer.ts

@@ -1,51 +1,55 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent"
 import { keyHint } from "@earendil-works/pi-coding-agent"
-import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui"
-import { CHROME_MARGIN } from "./chrome.js"
-import type { Sibling } from "./herdr.js"
+import { truncateToWidth } from "@earendil-works/pi-tui"
+import * as chrome from "./chrome.js"
 import { formatTrackerLines } from "./tracker.js"
 
-function statusColor(
-  status: string,
-): "success" | "warning" | "error" | "accent" | "muted" {
-  if (status === "idle" || status === "done") return "success"
-  if (status === "working") return "accent"
-  if (status === "blocked") return "error"
-  return "muted"
+/** Tolerates a stale chrome module after /reload, where only CHROME_MARGIN may exist. */
+const margin = (): number => (typeof chrome.chromeMargin === "function" ? chrome.chromeMargin() : (chrome.CHROME_MARGIN ?? 1))
+
+
+export type FooterSources = {
+  /** True while an agent run is in progress. */
+  busy: () => boolean
+  /** Current editor text, when the host exposes it. */
+  editorText: () => string
+  /** Context usage percentage, when known. */
+  contextPct: () => number | undefined
+}
+
+/**
+ * Key hints are shown only when nothing else needs the line: idle agent, empty editor. Otherwise
+ * the footer collapses to zero lines (tracker lines excepted).
+ */
+export function footerHints(sources: FooterSources, hints: string[]): string[] {
+  if (sources.busy()) return []
+  if (sources.editorText().trim().length > 0) return []
+  const pct = sources.contextPct()
+  const out = [...hints]
+  if (pct !== undefined && pct >= 70) out.push("/compact")
+  return out
 }
 
-export function installFooter(
-  ctx: ExtensionContext,
-  getSiblings: () => Sibling[] | undefined,
-): void {
+export function installFooter(ctx: ExtensionContext, sources: FooterSources): void {
   ctx.ui.setFooter((tui, theme, footerData) => {
     const unsub = footerData.onBranchChange(() => tui.requestRender())
     return {
       dispose: unsub,
       invalidate() {},
       render(width: number): string[] {
-        const send = keyHint("tui.input.submit", "send")
-        const think = keyHint("app.thinking.cycle", "thinking")
-        const left = [send, think].filter(Boolean).join("  ·  ")
-
-        const siblings = getSiblings()
-        let right = ""
-        if (siblings && siblings.length > 0) {
-          right = siblings
-            .map((s) => {
-              const name = theme.fg("text", s.name)
-              const st = theme.fg(statusColor(s.status), s.status)
-              return `${name} ${st}`
-            })
-            .join(theme.fg("dim", "  ·  "))
+        const inner = Math.max(8, width - margin() * 2)
+        const out: string[] = []
+        const hints = footerHints(sources, [
+          keyHint("tui.input.submit", "send"),
+          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, "")}`)
         }
-
-        const inner = Math.max(8, width - CHROME_MARGIN * 2)
-        const pad = Math.max(1, inner - visibleWidth(left) - visibleWidth(right))
-        const line = truncateToWidth(left + " ".repeat(pad) + right, inner, "")
-        const out = [`${" ".repeat(CHROME_MARGIN)}${line}`]
         for (const extra of formatTrackerLines(ctx, theme as { fg: (name: string, s: string) => string })) {
-          out.push(`${" ".repeat(CHROME_MARGIN)}${truncateToWidth(extra, inner, "")}`)
+          out.push(`${" ".repeat(margin())}${truncateToWidth(extra, inner, "")}`)
         }
         return out
       },

package/src/git-state.ts

@@ -0,0 +1,71 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
+
+export type GitState = {
+  branch: string | undefined
+  /** Count of changed paths from `git status --porcelain`; undefined when unknown. */
+  dirty: number | undefined
+}
+
+export function parseBranch(stdout: string): string | undefined {
+  const line = stdout.trim().split("\n")[0]?.trim()
+  if (!line || line === "HEAD") return undefined
+  return line
+}
+
+export function parsePorcelain(stdout: string): number {
+  return stdout.split("\n").filter((line) => line.trim().length > 0).length
+}
+
+export function formatGitState(state: GitState | undefined): { branch: string; dirty: string } {
+  if (!state?.branch) return { branch: "", dirty: "" }
+  const dirty = state.dirty && state.dirty > 0 ? `±${state.dirty}` : ""
+  return { branch: state.branch, dirty }
+}
+
+/**
+ * Polls git for the current branch and dirty count. Call `refresh()` after events that may have
+ * changed the tree (tool results, turn end); `get()` is always synchronous.
+ */
+export function createGitState(pi: ExtensionAPI, cwd: () => string, minIntervalMs = 5000) {
+  let state: GitState | undefined
+  let lastRun = 0
+  let inFlight: Promise<void> | undefined
+  const listeners = new Set<() => void>()
+
+  const refresh = (force = false): Promise<void> => {
+    const now = Date.now()
+    if (inFlight) return inFlight
+    if (!force && now - lastRun < minIntervalMs) return Promise.resolve()
+    lastRun = now
+    inFlight = (async () => {
+      try {
+        const branchRun = await pi.exec("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: cwd(), timeout: 2000 })
+        if (branchRun.code !== 0) {
+          state = undefined
+          return
+        }
+        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
+      } finally {
+        inFlight = undefined
+        for (const listener of listeners) listener()
+      }
+    })()
+    return inFlight
+  }
+
+  return {
+    get: () => state,
+    refresh,
+    onChange(listener: () => void) {
+      listeners.add(listener)
+      return () => listeners.delete(listener)
+    },
+  }
+}
+
+export type GitStateHandle = ReturnType<typeof createGitState>

package/src/index.ts

@@ -5,12 +5,22 @@ import { installFooter } from "./footer.js"
 import { installCwd } from "./cwd.js"
 import { listSiblings, parseAgentList, parseTabList, type Sibling } from "./herdr.js"
 import { hideGauntletWidgets } from "./tracker.js"
-import { stopLiveWatch, wrapBuiltinTools } from "./tools.js"
+import { installToolRenderers, stopLiveWatch } from "./tools.js"
 import { applyReclaim, reclaimPolicy, type ReclaimReason } from "./reclaim.js"
 import { installWorkingStatus } from "./working-status.js"
+import { installTurnRule } from "./turn-rule.js"
+import { installTranscript } from "./transcript.js"
+import { createGitState } from "./git-state.js"
+import { installCodeBox } from "./code-box.js"
+import { setChromeMargin } from "./chrome.js"
+import { SettingsManager } from "@earendil-works/pi-coding-agent"
 
 export default function piMinimalExtension(pi: ExtensionAPI): void {
   const stopWorkingStatus = installWorkingStatus(pi)
+  const stopTurnRule = installTurnRule(pi)
+  installToolRenderers(pi)
+  installTranscript(pi)
+  installCodeBox()
   let fastTimer: ReturnType<typeof setInterval> | undefined
   let slowTimer: ReturnType<typeof setInterval> | undefined
   let stealTimer: ReturnType<typeof setInterval> | undefined
@@ -18,6 +28,9 @@ export default function piMinimalExtension(pi: ExtensionAPI): void {
   let siblings: Sibling[] | undefined
   let generation = 0
   let hideWidgets = true
+  let busy = false
+  let currentCwd = process.cwd()
+  const gitState = createGitState(pi, () => currentCwd)
   const stopTimers = () => {
     if (fastTimer) clearInterval(fastTimer)
     if (slowTimer) clearInterval(slowTimer)
@@ -97,17 +110,40 @@ export default function piMinimalExtension(pi: ExtensionAPI): void {
         },
         chrome: () => {
           installHeader(ctx)
-          installFooter(ctx, () => siblings)
+          installChromeFooter(ctx)
         },
       },
     )
   }
 
+  const contextPct = (ctx: ExtensionContext): number | undefined => {
+    const usage = ctx.getContextUsage?.()
+    const window = usage?.contextWindow || ctx.model?.contextWindow
+    if (typeof usage?.tokens !== "number" || !window) return undefined
+    return Math.max(0, Math.min(100, Math.round((usage.tokens / window) * 100)))
+  }
+
+  const installChromeFooter = (ctx: ExtensionContext) => {
+    installFooter(ctx, {
+      busy: () => busy,
+      editorText: () => (typeof ctx.ui.getEditorText === "function" ? ctx.ui.getEditorText() : ""),
+      contextPct: () => contextPct(ctx),
+    })
+  }
+
+  const installStatusLine = (ctx: ExtensionContext) => {
+    installCwd(ctx, {
+      gitState: gitState.get,
+      siblings: () => siblings,
+      onGitChange: gitState.onChange,
+    })
+  }
+
   const pinChrome = (ctx: ExtensionContext, reason: ReclaimReason) => {
     hideForeignChrome(ctx, reason)
     if (ctx.mode !== "tui" || !reclaimPolicy(reason).reinstallChrome) return
     ctx.ui.setWidget("tw-cwd", undefined)
-    installCwd(ctx)
+    installStatusLine(ctx)
   }
 
   pi.on("session_start", async (_event, ctx) => {
@@ -118,10 +154,17 @@ export default function piMinimalExtension(pi: ExtensionAPI): void {
       projectTrusted: ctx.isProjectTrusted(),
     })
     hideWidgets = config.hideGauntletWidgets
+    currentCwd = ctx.cwd
+    try {
+      const settings = SettingsManager.create(ctx.cwd, undefined, { projectTrusted: ctx.isProjectTrusted() })
+      setChromeMargin(settings.getOutputPad())
+    } catch {
+      // Keep the default margin when settings are unavailable.
+    }
     installHeader(ctx)
-    installFooter(ctx, () => siblings)
-    installCwd(ctx)
-    wrapBuiltinTools(pi, ctx)
+    installChromeFooter(ctx)
+    installStatusLine(ctx)
+    void gitState.refresh(true)
     pinChrome(ctx, "session_start")
     ctx.ui.setHiddenThinkingLabel("◆ Thought")
     ctx.ui.setWorkingIndicator()
@@ -135,16 +178,27 @@ export default function piMinimalExtension(pi: ExtensionAPI): void {
     }
   })
 
+  pi.on("agent_start", () => {
+    busy = true
+  })
+  pi.on("agent_end", () => {
+    busy = false
+    void gitState.refresh()
+  })
   pi.on("turn_end", (_event, ctx) => {
     pinChrome(ctx, "turn_end")
+    void gitState.refresh()
   })
   pi.on("tool_execution_end", (_event, ctx) => {
     pinChrome(ctx, "tool_execution_end")
+    void gitState.refresh()
   })
 
   pi.on("session_shutdown", async () => {
+    busy = false
     stopTimers()
     stopWorkingStatus()
+    stopTurnRule()
     stopLiveWatch()
     generation += 1
     siblings = undefined