pi-minimal 0.1.0

package/src/footer.ts

@@ -0,0 +1,54 @@
+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 { 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"
+}
+
+export function installFooter(
+  ctx: ExtensionContext,
+  getSiblings: () => Sibling[] | undefined,
+): 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 - 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, "")}`)
+        }
+        return out
+      },
+    }
+  })
+}

package/src/header.ts

@@ -0,0 +1,16 @@
+import { Text } from "@earendil-works/pi-tui"
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent"
+
+export function installHeader(ctx: ExtensionContext): void {
+  ctx.ui.setHeader(() => {
+    const text = new Text("", 0, 0)
+    return {
+      render(): string[] {
+        return text.render(1)
+      },
+      invalidate() {
+        text.invalidate()
+      },
+    }
+  })
+}

package/src/herdr.ts

@@ -0,0 +1,66 @@
+export type HerdrAgent = {
+  agent: string
+  agent_status: string
+  pane_id: string
+  tab_id: string
+}
+
+export type HerdrTab = {
+  label: string
+  tab_id: string
+}
+
+function parseJson(stdout: string): unknown {
+  return JSON.parse(stdout)
+}
+
+export function parseAgentList(stdout: string): HerdrAgent[] {
+  const data = parseJson(stdout) as {
+    result?: { agents?: Array<Record<string, unknown>> }
+  }
+  const rows = data.result?.agents
+  if (!Array.isArray(rows)) throw new Error("invalid herdr agent list")
+  return rows.map((row) => ({
+    agent: String(row.agent ?? ""),
+    agent_status: String(row.agent_status ?? ""),
+    pane_id: String(row.pane_id ?? ""),
+    tab_id: String(row.tab_id ?? ""),
+  }))
+}
+
+export function parseTabList(stdout: string): HerdrTab[] {
+  const data = parseJson(stdout) as {
+    result?: { tabs?: Array<Record<string, unknown>> }
+  }
+  const rows = data.result?.tabs
+  if (!Array.isArray(rows)) throw new Error("invalid herdr tab list")
+  return rows.map((row) => ({
+    label: String(row.label ?? ""),
+    tab_id: String(row.tab_id ?? ""),
+  }))
+}
+
+export type Sibling = {
+  name: string
+  status: string
+}
+
+export function listSiblings(
+  agents: HerdrAgent[],
+  tabs: HerdrTab[],
+  selfPane?: string,
+  selfTab?: string,
+): Sibling[] | undefined {
+  if (!selfPane && !selfTab) return undefined
+  const labels = new Map(tabs.map((t) => [t.tab_id, t.label]))
+  const parts: Sibling[] = []
+  for (const agent of agents) {
+    if (selfPane && agent.pane_id === selfPane) continue
+    if (!selfPane && selfTab && agent.tab_id === selfTab) continue
+    const name = labels.get(agent.tab_id) || agent.agent
+    if (!name) continue
+    parts.push({ name, status: agent.agent_status })
+  }
+  if (parts.length === 0) return undefined
+  return parts
+}

package/src/index.ts

@@ -0,0 +1,152 @@
+import { getAgentDir, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent"
+import { loadPiMinimalConfig } from "./config.js"
+import { installHeader } from "./header.js"
+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 { applyReclaim, reclaimPolicy, type ReclaimReason } from "./reclaim.js"
+import { installWorkingStatus } from "./working-status.js"
+
+export default function piMinimalExtension(pi: ExtensionAPI): void {
+  const stopWorkingStatus = installWorkingStatus(pi)
+  let fastTimer: ReturnType<typeof setInterval> | undefined
+  let slowTimer: ReturnType<typeof setInterval> | undefined
+  let stealTimer: ReturnType<typeof setInterval> | undefined
+  let inFlight: AbortController | undefined
+  let siblings: Sibling[] | undefined
+  let generation = 0
+  let hideWidgets = true
+  const stopTimers = () => {
+    if (fastTimer) clearInterval(fastTimer)
+    if (slowTimer) clearInterval(slowTimer)
+    if (stealTimer) clearInterval(stealTimer)
+    fastTimer = undefined
+    slowTimer = undefined
+    stealTimer = undefined
+    inFlight?.abort()
+    inFlight = undefined
+  }
+
+  const scheduleFast = (ctx: ExtensionContext) => {
+    if (fastTimer) return
+    if (slowTimer) clearInterval(slowTimer)
+    slowTimer = undefined
+    fastTimer = setInterval(() => {
+      void probe(ctx)
+    }, 2000)
+  }
+
+  const scheduleSlow = (ctx: ExtensionContext) => {
+    if (slowTimer) return
+    if (fastTimer) clearInterval(fastTimer)
+    fastTimer = undefined
+    slowTimer = setInterval(() => {
+      void probe(ctx)
+    }, 10000)
+  }
+
+  const probe = async (ctx: ExtensionContext) => {
+    if (process.env.HERDR_ENV !== "1") return
+    if (inFlight) return
+    const ac = new AbortController()
+    const gen = generation
+    inFlight = ac
+    try {
+      const agentRun = await pi.exec("herdr", ["agent", "list"], {
+        timeout: 3000,
+        signal: ac.signal,
+      })
+      if (generation !== gen) return
+      const tabRun = await pi.exec("herdr", ["tab", "list"], {
+        timeout: 3000,
+        signal: ac.signal,
+      })
+      if (generation !== gen) return
+      if (agentRun.code !== 0 || tabRun.code !== 0 || agentRun.killed || tabRun.killed) {
+        siblings = undefined
+        scheduleSlow(ctx)
+        return
+      }
+      siblings = listSiblings(
+        parseAgentList(agentRun.stdout),
+        parseTabList(tabRun.stdout),
+        process.env.HERDR_PANE_ID,
+        process.env.HERDR_TAB_ID,
+      )
+      if (siblings) scheduleFast(ctx)
+      else scheduleSlow(ctx)
+    } catch {
+      if (generation !== gen) return
+      siblings = undefined
+      scheduleSlow(ctx)
+    } finally {
+      if (inFlight === ac) inFlight = undefined
+    }
+  }
+
+  const hideForeignChrome = (ctx: ExtensionContext, reason: ReclaimReason) => {
+    if (ctx.mode !== "tui") return
+    applyReclaim(
+      reason,
+      ctx.ui,
+      {
+        widgets: () => {
+          if (hideWidgets) hideGauntletWidgets(ctx)
+        },
+        chrome: () => {
+          installHeader(ctx)
+          installFooter(ctx, () => siblings)
+        },
+      },
+    )
+  }
+
+  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)
+  }
+
+  pi.on("session_start", async (_event, ctx) => {
+    if (ctx.mode !== "tui") return
+    const config = loadPiMinimalConfig({
+      agentDir: getAgentDir(),
+      cwd: ctx.cwd,
+      projectTrusted: ctx.isProjectTrusted(),
+    })
+    hideWidgets = config.hideGauntletWidgets
+    installHeader(ctx)
+    installFooter(ctx, () => siblings)
+    installCwd(ctx)
+    wrapBuiltinTools(pi, ctx)
+    pinChrome(ctx, "session_start")
+    ctx.ui.setHiddenThinkingLabel("◆ Thought")
+    ctx.ui.setWorkingIndicator()
+    setTimeout(() => pinChrome(ctx, "session_settle"), 0)
+    setTimeout(() => pinChrome(ctx, "session_settle"), 50)
+    if (!stealTimer) {
+      stealTimer = setInterval(() => hideForeignChrome(ctx, "interval"), 200)
+    }
+    if (process.env.HERDR_ENV === "1") {
+      await probe(ctx)
+    }
+  })
+
+  pi.on("turn_end", (_event, ctx) => {
+    pinChrome(ctx, "turn_end")
+  })
+  pi.on("tool_execution_end", (_event, ctx) => {
+    pinChrome(ctx, "tool_execution_end")
+  })
+
+  pi.on("session_shutdown", async () => {
+    stopTimers()
+    stopWorkingStatus()
+    stopLiveWatch()
+    generation += 1
+    siblings = undefined
+  })
+}

package/src/live-watch.ts

@@ -0,0 +1,59 @@
+export type LiveWatch = {
+  watch: (id: string, invalidate: () => void) => void
+  unwatch: (id: string) => void
+  has: (id: string) => boolean
+  stop: () => void
+  tick: () => void
+  readonly frame: 0 | 1
+  readonly size: number
+}
+
+export function createLiveWatch(intervalMs = 400): LiveWatch {
+  let frame: 0 | 1 = 0
+  let timer: ReturnType<typeof setInterval> | undefined
+  const invalidators = new Map<string, () => void>()
+
+  const tick = () => {
+    frame = frame === 0 ? 1 : 0
+    const snapshot = [...invalidators.values()]
+    for (const invalidate of snapshot) {
+      try {
+        invalidate()
+      } catch {
+        // A single renderer failure must not stop the shared activity frame.
+      }
+    }
+  }
+
+  return {
+    watch(id, invalidate) {
+      if (!id) return
+      invalidators.set(id, invalidate)
+      if (!timer) timer = setInterval(tick, intervalMs)
+    },
+    unwatch(id) {
+      if (!id) return
+      invalidators.delete(id)
+      if (invalidators.size === 0 && timer) {
+        clearInterval(timer)
+        timer = undefined
+      }
+    },
+    has(id) {
+      return Boolean(id) && invalidators.has(id)
+    },
+    stop() {
+      if (timer) clearInterval(timer)
+      timer = undefined
+      invalidators.clear()
+      frame = 0
+    },
+    tick,
+    get frame() {
+      return frame
+    },
+    get size() {
+      return invalidators.size
+    },
+  }
+}

package/src/reclaim.ts

@@ -0,0 +1,34 @@
+export type ReclaimReason =
+  | "session_start"
+  | "session_settle"
+  | "interval"
+  | "turn_end"
+  | "tool_execution_end"
+
+export type ReclaimPolicy = {
+  resetEditor: boolean
+  reinstallChrome: boolean
+}
+
+export function reclaimPolicy(reason: ReclaimReason): ReclaimPolicy {
+  if (reason === "session_start") {
+    return { resetEditor: true, reinstallChrome: true }
+  }
+  if (reason === "interval") {
+    return { resetEditor: false, reinstallChrome: false }
+  }
+  // session_settle / turn_end / tool_execution_end: restore chrome, keep editor
+  return { resetEditor: false, reinstallChrome: true }
+}
+
+export function applyReclaim(
+  reason: ReclaimReason,
+  ui: { setEditorComponent: (factory: undefined) => void },
+  install: { widgets: () => void; chrome: () => void },
+): ReclaimPolicy {
+  const policy = reclaimPolicy(reason)
+  install.widgets()
+  if (policy.resetEditor) ui.setEditorComponent(undefined)
+  if (policy.reinstallChrome) install.chrome()
+  return policy
+}

package/src/tool-rows.ts

@@ -0,0 +1,58 @@
+export type ToolKind = "read" | "edit" | "write" | "bash" | "grep" | "find" | "ls"
+
+export type ToolArgs = {
+  command?: unknown
+  path?: unknown
+  file_path?: unknown
+  pattern?: unknown
+  target_directory?: unknown
+}
+
+export type GroupedRow = {
+  header?: string
+  item: string
+}
+
+type ActivityGroup = {
+  verb: string
+  leadId: string
+  seen: Set<string>
+}
+
+let activityGroup: ActivityGroup | undefined
+
+export function resetActivityGroup(): void {
+  activityGroup = undefined
+}
+
+export function shortName(path: string): string {
+  const parts = path.split("/").filter(Boolean)
+  if (parts.length <= 1) return path || ""
+  return parts.slice(-2).join("/")
+}
+
+export function toolItem(kind: ToolKind, args: ToolArgs | undefined): string {
+  if (kind === "bash") {
+    const command = typeof args?.command === "string" ? args.command.split("\n")[0]?.trim() ?? "" : ""
+    return command || "bash"
+  }
+  if (kind === "grep" || kind === "find") {
+    return typeof args?.pattern === "string" && args.pattern ? args.pattern : kind
+  }
+  const path =
+    (typeof args?.path === "string" && args.path) ||
+    (typeof args?.file_path === "string" && args.file_path) ||
+    (typeof args?.target_directory === "string" && args.target_directory) ||
+    ""
+  return path ? shortName(path) : kind
+}
+
+export function nextGroupedRow(verb: string, item: string, id: string): GroupedRow {
+  if (activityGroup && activityGroup.verb === verb) {
+    activityGroup.seen.add(id)
+    if (id === activityGroup.leadId) return { header: verb, item }
+    return { header: undefined, item }
+  }
+  activityGroup = { verb, leadId: id, seen: new Set([id]) }
+  return { header: verb, item }
+}

package/src/tools.ts

@@ -0,0 +1,161 @@
+import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent"
+import {
+  createBashToolDefinition,
+  createEditToolDefinition,
+  createFindToolDefinition,
+  createGrepToolDefinition,
+  createLsToolDefinition,
+  createReadToolDefinition,
+  createWriteToolDefinition,
+  SettingsManager,
+} from "@earendil-works/pi-coding-agent"
+import { Container, Text, truncateToWidth } from "@earendil-works/pi-tui"
+import { activityBullet, rowIsRunning } from "./activity.js"
+import { createLiveWatch } from "./live-watch.js"
+import { nextGroupedRow, toolItem, type ToolKind } from "./tool-rows.js"
+
+type ToolArgs = {
+  command?: unknown
+  path?: unknown
+  file_path?: unknown
+  pattern?: unknown
+  target_directory?: unknown
+}
+
+type ToolResult = {
+  content?: Array<{ type?: string; text?: string }>
+}
+
+type RenderOptions = {
+  expanded?: boolean
+}
+
+type RowState = {
+  done?: boolean
+  running?: boolean
+}
+
+type RenderContext = {
+  isPartial?: boolean
+  isError?: boolean
+  invalidate: () => void
+  state: RowState
+  args?: ToolArgs
+  toolCallId?: string
+  expanded?: boolean
+}
+
+const live = createLiveWatch(400)
+
+export function stopLiveWatch(): void {
+  live.stop()
+}
+
+function liveId(context: RenderContext, item: string): string {
+  return context.toolCallId || item
+}
+
+function contentText(result: ToolResult | undefined): string {
+  if (!result?.content) return ""
+  return result.content
+    .filter((part) => part.type === "text" && typeof part.text === "string")
+    .map((part) => part.text as string)
+    .join("\n")
+}
+
+function collapsedResult() {
+  return new Container()
+}
+
+function expandedContent(result: ToolResult | undefined, options: RenderOptions) {
+  if (!options.expanded) return collapsedResult()
+  const text = contentText(result)
+  return text ? new Text(text, 0, 0) : collapsedResult()
+}
+
+function activityBlock(
+  kind: ToolKind,
+  args: ToolArgs | undefined,
+  theme: Theme,
+  context: RenderContext,
+) {
+  const item = toolItem(kind, args)
+  const id = liveId(context, item)
+  const row = nextGroupedRow(kind, item, id)
+  const running = rowIsRunning(context)
+  context.state.running = running
+  if (running) live.watch(id, context.invalidate)
+  else live.unwatch(id)
+  const color = context.isError ? "error" : running ? "warning" : "dim"
+  return {
+    render(width: number): string[] {
+      const pad = 1
+      const inner = Math.max(0, width - pad)
+      const lines: string[] = []
+      if (row.header) {
+        const blink = Boolean(context.state.running) && live.has(id)
+        const bullet = activityBullet(blink, live.frame)
+        lines.push(" ".repeat(pad) + theme.fg(color, truncateToWidth(`${bullet} ${row.header}`, inner)))
+      }
+      lines.push(" ".repeat(pad) + "  " + theme.fg(color, truncateToWidth(row.item, Math.max(0, inner - 2))))
+      return lines
+    },
+    invalidate() {},
+  }
+}
+
+type WrappableTool = {
+  name: string
+  label: string
+  description: string
+  parameters: Parameters<ExtensionAPI["registerTool"]>[0]["parameters"]
+  execute: Parameters<ExtensionAPI["registerTool"]>[0]["execute"]
+}
+
+function wrapOne(pi: ExtensionAPI, kind: ToolKind, factory: () => WrappableTool) {
+  try {
+    const tool = factory()
+    pi.registerTool({
+      ...tool,
+      renderShell: "self",
+      renderCall(args, theme, context) {
+        return activityBlock(kind, args as ToolArgs, theme, context as RenderContext)
+      },
+      renderResult(result, options, _theme, context) {
+        const renderContext = context as RenderContext
+        if (!renderContext.isPartial) {
+          renderContext.state.done = true
+          renderContext.state.running = false
+          live.unwatch(liveId(renderContext, toolItem(kind, renderContext.args)))
+        }
+        return expandedContent(result as ToolResult, options)
+      },
+    })
+  } catch {
+    // A missing built-in tool leaves the rest of the compact renderers available.
+  }
+}
+
+export function wrapBuiltinTools(pi: ExtensionAPI, ctx: ExtensionContext): void {
+  let commandPrefix: string | undefined
+  let shellPath: string | undefined
+  let autoResizeImages: boolean | undefined
+  try {
+    const settings = SettingsManager.create(ctx.cwd, undefined, {
+      projectTrusted: ctx.isProjectTrusted(),
+    })
+    commandPrefix = settings.getShellCommandPrefix()
+    shellPath = settings.getShellPath()
+    autoResizeImages = settings.getImageAutoResize()
+  } catch {
+    // Tool wrapping still works when optional shell or image settings are unavailable.
+  }
+
+  wrapOne(pi, "bash", () => createBashToolDefinition(ctx.cwd, { commandPrefix, shellPath }) as WrappableTool)
+  wrapOne(pi, "read", () => createReadToolDefinition(ctx.cwd, { autoResizeImages }) as WrappableTool)
+  wrapOne(pi, "edit", () => createEditToolDefinition(ctx.cwd) as WrappableTool)
+  wrapOne(pi, "write", () => createWriteToolDefinition(ctx.cwd) as WrappableTool)
+  wrapOne(pi, "grep", () => createGrepToolDefinition(ctx.cwd) as WrappableTool)
+  wrapOne(pi, "find", () => createFindToolDefinition(ctx.cwd) as WrappableTool)
+  wrapOne(pi, "ls", () => createLsToolDefinition(ctx.cwd) as WrappableTool)
+}

package/src/tracker.ts

@@ -0,0 +1,91 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent"
+
+const PHASES = ["brainstorm", "plan", "implement", "verify", "ship"] as const
+type PhaseName = (typeof PHASES)[number]
+type PhaseStatus = "pending" | "in_progress" | "complete" | "skipped"
+type TaskStatus = "pending" | "in_progress" | "complete" | "failed"
+
+type PhaseMap = Record<PhaseName, { status: PhaseStatus; substep?: string | null }>
+
+type Task = { name: string; status: TaskStatus }
+
+export type TrackerSnapshot = {
+  phases?: PhaseMap
+  tasks?: Task[]
+}
+
+function readSnapshot(ctx: ExtensionContext): TrackerSnapshot {
+  let phases: PhaseMap | undefined
+  let tasks: Task[] | undefined
+  for (const entry of ctx.sessionManager.getBranch()) {
+    if (entry.type !== "message") continue
+    const msg = entry.message as {
+      role?: string
+      toolName?: string
+      details?: {
+        error?: string
+        phases?: PhaseMap
+        tasks?: Task[]
+      }
+    }
+    if (msg.role !== "toolResult" || !msg.details || msg.details.error) continue
+    if (msg.toolName === "phase_tracker" && msg.details.phases) {
+      phases = msg.details.phases
+    }
+    if (msg.toolName === "plan_tracker" && msg.details.tasks) {
+      tasks = msg.details.tasks
+    }
+  }
+  return { phases, tasks }
+}
+
+function phaseActive(phases: PhaseMap): boolean {
+  return PHASES.some((p) => phases[p]?.status && phases[p].status !== "pending")
+}
+
+export function formatTrackerLines(
+  ctx: ExtensionContext,
+  theme: { fg: (name: string, s: string) => string },
+): string[] {
+  const { phases, tasks } = readSnapshot(ctx)
+  const lines: string[] = []
+  if (phases && phaseActive(phases)) {
+    const parts = PHASES.map((p) => {
+      const st = phases[p]?.status || "pending"
+      const icon =
+        st === "complete"
+          ? theme.fg("success", "✓")
+          : st === "in_progress"
+            ? theme.fg("warning", "→")
+            : st === "skipped"
+              ? theme.fg("dim", "⊘")
+              : theme.fg("dim", "○")
+      const label = st === "skipped" ? theme.fg("dim", p) : p
+      return `${icon} ${label}`
+    })
+    lines.push(`${theme.fg("muted", "Phases")} ${parts.join(theme.fg("dim", " → "))}`)
+  }
+  if (tasks && tasks.length > 0) {
+    const done = tasks.filter((t) => t.status === "complete").length
+    const icons = tasks
+      .map((t) => {
+        if (t.status === "complete") return theme.fg("success", "✓")
+        if (t.status === "in_progress") return theme.fg("warning", "→")
+        if (t.status === "failed") return theme.fg("error", "✗")
+        return theme.fg("dim", "○")
+      })
+      .join("")
+    const current =
+      tasks.find((t) => t.status === "in_progress") ?? tasks.find((t) => t.status === "pending")
+    const name = current ? theme.fg("text", ` ${current.name}`) : ""
+    lines.push(
+      `${theme.fg("muted", "Tasks")} ${icons} ${theme.fg("dim", `(${done}/${tasks.length})`)}${name}`,
+    )
+  }
+  return lines
+}
+
+export function hideGauntletWidgets(ctx: ExtensionContext): void {
+  ctx.ui.setWidget("phase_tracker", undefined)
+  ctx.ui.setWidget("plan_tracker", undefined)
+}