pi-minimal 0.1.0 → 0.2.2

package/src/tool-rows.ts

@@ -1,3 +1,5 @@
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui"
+
 export type ToolKind = "read" | "edit" | "write" | "bash" | "grep" | "find" | "ls"
 
 export type ToolArgs = {
@@ -6,24 +8,22 @@ export type ToolArgs = {
   file_path?: unknown
   pattern?: unknown
   target_directory?: unknown
+  content?: unknown
 }
 
-export type GroupedRow = {
-  header?: string
-  item: string
+export type ToolResultLike = {
+  content?: Array<{ type?: string; text?: string }>
+  details?: unknown
 }
 
-type ActivityGroup = {
-  verb: string
-  leadId: string
-  seen: Set<string>
-}
+export type RowStatus = "running" | "ok" | "error"
 
-let activityGroup: ActivityGroup | undefined
+export type RowGlyph = "◐" | "◓" | "✓" | "✗"
 
-export function resetActivityGroup(): void {
-  activityGroup = undefined
-}
+/** Width of the verb column so items align across rows. */
+export const VERB_WIDTH = 5
+
+const BASH_STATUS = /^Command (?:exited with code (\d+)|terminated without an exit code)$/
 
 export function shortName(path: string): string {
   const parts = path.split("/").filter(Boolean)
@@ -47,12 +47,163 @@ export function toolItem(kind: ToolKind, args: ToolArgs | undefined): string {
   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 }
+export function resultText(result: ToolResultLike | 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")
+}
+
+export function rowGlyph(status: RowStatus, frame: 0 | 1): RowGlyph {
+  if (status === "running") return frame === 1 ? "◓" : "◐"
+  return status === "error" ? "✗" : "✓"
+}
+
+export function formatDuration(ms: number | undefined): string {
+  if (ms === undefined || !Number.isFinite(ms)) return ""
+  if (ms < 1000) return `${Math.round(ms / 100) / 10}s`
+  if (ms < 60_000) return `${Math.round(ms / 100) / 10}s`
+  const minutes = Math.floor(ms / 60_000)
+  const seconds = Math.round((ms % 60_000) / 1000)
+  return `${minutes}m ${seconds}s`
+}
+
+function plural(n: number, word: string, pluralWord = `${word}s`): string {
+  return `${n} ${n === 1 ? word : pluralWord}`
+}
+
+function countLines(text: string): number {
+  if (!text) return 0
+  return text.split("\n").filter((line) => line.length > 0).length
+}
+
+/** Strip pi's bash status trailer and truncation note from output text. */
+export function bashBody(text: string): { body: string; exitCode: number | undefined } {
+  const lines = text.split("\n")
+  let exitCode: number | undefined
+  while (lines.length > 0) {
+    const last = lines[lines.length - 1].trim()
+    const match = BASH_STATUS.exec(last)
+    if (match) {
+      exitCode = match[1] !== undefined ? Number(match[1]) : undefined
+      lines.pop()
+      continue
+    }
+    if (last.startsWith("[Showing ") && last.endsWith("]")) {
+      lines.pop()
+      continue
+    }
+    if (last === "") {
+      lines.pop()
+      continue
+    }
+    break
+  }
+  return { body: lines.join("\n"), exitCode }
+}
+
+export function diffStats(diff: string): { added: number; removed: number } {
+  let added = 0
+  let removed = 0
+  for (const line of diff.split("\n")) {
+    if (line.startsWith("+++") || line.startsWith("---")) continue
+    if (line.startsWith("+")) added += 1
+    else if (line.startsWith("-")) removed += 1
+  }
+  return { added, removed }
+}
+
+export type Outcome = {
+  /** Short right-aligned summary, e.g. "34 lines · 1.0s". */
+  text: string
+  /** Optional +N / −N pair rendered in success/error colours. */
+  diff?: { added: number; removed: number }
+  /** First meaningful line of an error, shown under the row. */
+  errorLine?: string
+}
+
+export function formatOutcome(
+  kind: ToolKind,
+  args: ToolArgs | undefined,
+  result: ToolResultLike | undefined,
+  isError: boolean,
+  durationMs: number | undefined,
+): Outcome {
+  const text = resultText(result)
+  const dur = formatDuration(durationMs)
+  const join = (...parts: string[]) => parts.filter(Boolean).join(" · ")
+
+  if (kind === "bash") {
+    const { body, exitCode } = bashBody(text)
+    if (isError || (exitCode !== undefined && exitCode !== 0)) {
+      const code = exitCode !== undefined ? `exit ${exitCode}` : "failed"
+      return { text: join(code, dur), errorLine: firstLine(body) }
+    }
+    const lines = countLines(body)
+    const summary = lines === 0 || body === "(no output)" ? "ok" : plural(lines, "line")
+    return { text: join(summary, dur) }
+  }
+
+  if (isError) return { text: join("failed", dur), errorLine: firstLine(text) }
+
+  if (kind === "edit") {
+    const details = result?.details as { diff?: unknown } | undefined
+    const diff = typeof details?.diff === "string" ? diffStats(details.diff) : undefined
+    return diff ? { text: dur, diff } : { text: join("edited", dur) }
+  }
+  if (kind === "write") {
+    const bytes = typeof args?.content === "string" ? Buffer.byteLength(args.content, "utf8") : undefined
+    return { text: join(bytes === undefined ? "written" : formatBytes(bytes), dur) }
+  }
+  if (kind === "read") {
+    return { text: join(plural(countLines(text), "line"), dur) }
+  }
+  if (kind === "grep") {
+    if (/^No matches found/m.test(text)) return { text: join("0 matches", dur) }
+    return { text: join(plural(countLines(text), "match"), dur) }
+  }
+  // find / ls
+  return { text: join(plural(countLines(text), "entry", "entries"), dur) }
+}
+
+export function firstLine(text: string): string | undefined {
+  for (const line of text.split("\n")) {
+    const trimmed = line.trim()
+    if (trimmed && trimmed !== "(no output)") return trimmed
+  }
+  return undefined
+}
+
+export function formatBytes(n: number): string {
+  if (n < 1024) return `${n} B`
+  if (n < 1024 * 1024) return `${Math.round(n / 102.4) / 10} KB`
+  return `${Math.round(n / (1024 * 102.4)) / 10} MB`
+}
+
+/**
+ * Lay out one row: `<glyph> <verb> <item> ... <outcome>`. The item is truncated so the outcome
+ * stays visible; the outcome is dropped only when the row is too narrow to show both.
+ */
+export function layoutRow(
+  width: number,
+  verb: string,
+  item: string,
+  outcome: string,
+): { verb: string; item: string; gap: number; outcome: string } {
+  const verbCol = verb.padEnd(VERB_WIDTH)
+  // glyph + space + verb column + space
+  const prefixWidth = 2 + VERB_WIDTH + 1
+  const outcomeWidth = visibleWidth(outcome)
+  const minGap = 2
+  let shownOutcome = outcome
+  let itemRoom = width - prefixWidth - (outcomeWidth ? outcomeWidth + minGap : 0)
+  if (itemRoom < 12 && outcomeWidth) {
+    shownOutcome = ""
+    itemRoom = width - prefixWidth
   }
-  activityGroup = { verb, leadId: id, seen: new Set([id]) }
-  return { header: verb, item }
+  const shownItem = truncateToWidth(item, Math.max(0, itemRoom), "…")
+  const used = prefixWidth + visibleWidth(shownItem) + visibleWidth(shownOutcome)
+  const gap = shownOutcome ? Math.max(minGap, width - used) : 0
+  return { verb: verbCol, item: shownItem, gap, outcome: shownOutcome }
 }

package/src/tools.ts

@@ -1,30 +1,26 @@
-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 type { ExtensionAPI, Theme, ToolRenderers } from "@earendil-works/pi-coding-agent"
+import { Container, truncateToWidth } from "@earendil-works/pi-tui"
+import { rowIsRunning } from "./activity.js"
+import * as chrome from "./chrome.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
-}
+import {
 
-type ToolResult = {
-  content?: Array<{ type?: string; text?: string }>
-}
+  bashBody,
+  formatDuration,
+  formatOutcome,
+  layoutRow,
+  resultText,
+  rowGlyph,
+  toolItem,
+  type Outcome,
+  type RowStatus,
+  type ToolArgs,
+  type ToolKind,
+  type ToolResultLike,
+} from "./tool-rows.js"
+
+/** 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))
 
 type RenderOptions = {
   expanded?: boolean
@@ -33,6 +29,8 @@ type RenderOptions = {
 type RowState = {
   done?: boolean
   running?: boolean
+  startedAt?: number
+  outcome?: Outcome
 }
 
 type RenderContext = {
@@ -43,10 +41,17 @@ type RenderContext = {
   args?: ToolArgs
   toolCallId?: string
   expanded?: boolean
+  durationMs?: number
+  outputPad?: number
 }
 
 const live = createLiveWatch(400)
 
+/** Left indent of every tool row: chrome margin plus one cell so rows sit inside message text. */
+const rowIndent = () => margin() + 1
+/** Max lines of output shown when a row is expanded. */
+const EXPANDED_MAX_LINES = 400
+
 export function stopLiveWatch(): void {
   live.stop()
 }
@@ -55,107 +60,157 @@ 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 rowStatus(context: RenderContext): RowStatus {
+  if (context.isError) return "error"
+  if (context.state.outcome?.errorLine) return "error"
+  return rowIsRunning(context) ? "running" : "ok"
+}
+
+function statusColor(status: RowStatus): "error" | "warning" | "success" {
+  if (status === "error") return "error"
+  if (status === "running") return "warning"
+  return "success"
 }
 
-function collapsedResult() {
-  return new Container()
+function expandedLines(kind: ToolKind, result: ToolResultLike | undefined): string[] {
+  let text = resultText(result)
+  if (kind === "bash") text = bashBody(text).body
+  if (!text) return []
+  const lines = text.split("\n")
+  if (lines.length > EXPANDED_MAX_LINES) {
+    const hidden = lines.length - EXPANDED_MAX_LINES
+    return [...lines.slice(0, EXPANDED_MAX_LINES), `… ${hidden} more lines`]
+  }
+  return lines
+}
+
+function outputBlock(kind: ToolKind, result: ToolResultLike | undefined, theme: Theme) {
+  const lines = expandedLines(kind, result)
+  if (lines.length === 0) return new Container()
+  const indent = " ".repeat(rowIndent() + 2)
+  const rule = theme.fg("borderMuted", "│")
+  return {
+    render(width: number): string[] {
+      const inner = Math.max(0, width - indent.length - 2)
+      return lines.map((line) => `${indent}${rule} ${theme.fg("dim", truncateToWidth(line, inner))}`)
+    },
+    invalidate() {},
+  }
 }
 
-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 errorLineBlock(line: string | undefined, theme: Theme) {
+  if (!line) return undefined
+  const indent = " ".repeat(rowIndent() + 2)
+  const rule = theme.fg("error", "│")
+  return {
+    render(width: number): string[] {
+      const inner = Math.max(0, width - indent.length - 2)
+      return [`${indent}${rule} ${theme.fg("error", truncateToWidth(line, inner))}`]
+    },
+    invalidate() {},
+  }
 }
 
-function activityBlock(
-  kind: ToolKind,
-  args: ToolArgs | undefined,
-  theme: Theme,
-  context: RenderContext,
-) {
+function activityRow(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"
+  if (running) {
+    context.state.startedAt ??= Date.now()
+    live.watch(id, context.invalidate)
+  } else {
+    live.unwatch(id)
+  }
   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)))
+      const status = rowStatus(context)
+      const blink = status === "running" && live.has(id)
+      const glyph = rowGlyph(status, blink ? live.frame : 0)
+      const outcome = context.state.outcome
+      const diff = status !== "running" ? outcome?.diff : undefined
+      let right = ""
+      if (status === "running") {
+        const started = context.state.startedAt
+        right = started ? formatDuration(Date.now() - started) : ""
+      } else if (outcome) {
+        right = outcome.text
+        if (diff) {
+          const stats = `+${diff.added} −${diff.removed}`
+          right = right ? `${stats} · ${right}` : stats
+        }
       }
-      lines.push(" ".repeat(pad) + "  " + theme.fg(color, truncateToWidth(row.item, Math.max(0, inner - 2))))
-      return lines
+      const inner = Math.max(8, width - rowIndent())
+      const row = layoutRow(inner, kind, item, right)
+
+      let coloredRight: string
+      if (status === "running") coloredRight = theme.fg("warning", row.outcome)
+      else if (status === "error") coloredRight = theme.fg("error", row.outcome)
+      else if (diff && row.outcome) {
+        const rest = row.outcome.slice(`+${diff.added} −${diff.removed}`.length)
+        coloredRight =
+          theme.fg("success", `+${diff.added}`) + " " + theme.fg("error", `−${diff.removed}`) + theme.fg("dim", rest)
+      } else coloredRight = theme.fg("dim", row.outcome)
+
+      const line =
+        " ".repeat(rowIndent()) +
+        theme.fg(statusColor(status), glyph) +
+        " " +
+        theme.fg("dim", row.verb) +
+        " " +
+        theme.fg(status === "error" ? "text" : "muted", row.item) +
+        " ".repeat(row.gap) +
+        coloredRight
+      return [line]
     },
     invalidate() {},
   }
 }
 
-type WrappableTool = {
-  name: string
-  label: string
-  description: string
-  parameters: Parameters<ExtensionAPI["registerTool"]>[0]["parameters"]
-  execute: Parameters<ExtensionAPI["registerTool"]>[0]["execute"]
-}
+const TOOL_KINDS: ReadonlySet<string> = new Set<ToolKind>(["bash", "read", "edit", "write", "grep", "find", "ls"])
 
-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 isToolKind(name: string): name is ToolKind {
+  return TOOL_KINDS.has(name)
 }
 
-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.
+export function compactRenderers(kind: ToolKind): ToolRenderers {
+  return {
+    renderShell: "self",
+    renderCall(args, theme, context) {
+      return activityRow(kind, args as ToolArgs, theme, context as RenderContext)
+    },
+    renderResult(result, options, theme, context) {
+      const renderContext = context as RenderContext
+      const typedResult = result as ToolResultLike
+      if (!renderContext.isPartial) {
+        renderContext.state.done = true
+        renderContext.state.running = false
+        renderContext.state.outcome = formatOutcome(
+          kind,
+          renderContext.args,
+          typedResult,
+          Boolean(renderContext.isError),
+          renderContext.durationMs,
+        )
+        live.unwatch(liveId(renderContext, toolItem(kind, renderContext.args)))
+      }
+      const container = new Container()
+      const errorLine = errorLineBlock(renderContext.state.outcome?.errorLine, theme)
+      if (errorLine && !(options as RenderOptions).expanded) container.addChild(errorLine)
+      if ((options as RenderOptions).expanded) container.addChild(outputBlock(kind, typedResult, theme))
+      return container
+    },
   }
+}
 
-  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)
+/**
+ * Attach the compact renderers to the built-in tools without re-registering them. Registered at
+ * extension load so a resumed transcript draws its earlier tool calls the same way as new ones.
+ */
+export function installToolRenderers(pi: ExtensionAPI): void {
+  if (typeof pi.registerToolRenderer !== "function") return
+  pi.registerToolRenderer((toolName, next) => {
+    if (!isToolKind(toolName)) return next()
+    return compactRenderers(toolName)
+  })
 }

package/src/transcript.ts

@@ -0,0 +1,51 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
+
+export const THINKING_GUTTER = "┊ "
+
+const FENCE = /^\s*(```|~~~)/
+const BLOCK_START = /^\s*(#{1,6}\s|[-*+]\s|\d+[.)]\s|>|\||```|~~~|---\s*$|\*\*\*\s*$|___\s*$)/
+
+/**
+ * Prefix the first line of every plain paragraph in thinking Markdown with a gutter glyph.
+ * Lines that start a Markdown block (heading, list, quote, table, fence, rule) are left alone so
+ * they keep parsing, and nothing inside a fenced code block is touched.
+ */
+export function gutterThinking(markdown: string): string {
+  if (!markdown) return markdown
+  const lines = markdown.split("\n")
+  const out: string[] = []
+  let inFence = false
+  let atParagraphStart = true
+  for (const line of lines) {
+    if (FENCE.test(line)) {
+      inFence = !inFence
+      out.push(line)
+      atParagraphStart = !inFence
+      continue
+    }
+    if (inFence) {
+      out.push(line)
+      continue
+    }
+    if (line.trim() === "") {
+      out.push(line)
+      atParagraphStart = true
+      continue
+    }
+    if (atParagraphStart && !BLOCK_START.test(line) && !line.startsWith(THINKING_GUTTER)) {
+      out.push(`${THINKING_GUTTER}${line}`)
+    } else {
+      out.push(line)
+    }
+    atParagraphStart = false
+  }
+  return out.join("\n")
+}
+
+export function installTranscript(pi: ExtensionAPI): void {
+  if (typeof pi.registerMarkdownTransformer !== "function") return
+  pi.registerMarkdownTransformer((markdown, context) => {
+    if (context.messageType !== "assistant-thinking") return markdown
+    return gutterThinking(markdown)
+  })
+}