pi-minimal 0.4.0 → 0.6.0

package/test/rex.test.ts

@@ -0,0 +1,249 @@
+import assert from "node:assert/strict"
+import { EventEmitter } from "node:events"
+import { PassThrough } from "node:stream"
+import test from "node:test"
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
+import {
+	applyRexEvent,
+	createRexSiblings,
+	createRexState,
+	listRexSiblings,
+	parseProgramStatus,
+	parseWindowList,
+	type RexSpawn,
+} from "../src/rex.js"
+
+const SELF = "block:self"
+const OTHER = "block:other"
+const WIN_SELF = "window:self"
+const WIN_OTHER = "window:other"
+
+// Shapes captured from `rex window ls --json`, `rex block call … program_status` and `rex events --json`.
+const windowList = JSON.stringify({
+	revision: 14,
+	session_id: "session:s",
+	label: "pi-dev",
+	active_window_id: WIN_SELF,
+	windows: [
+		{
+			window_id: WIN_SELF,
+			label: "Window 395a96cb",
+			focused_block_id: SELF,
+			layers: [{ kind: "tiled", blocks: [{ block_id: SELF, label: "shell", creator_name: "com.superlogical.terminal" }] }],
+		},
+		{
+			window_id: WIN_OTHER,
+			label: "ry-fix-login",
+			focused_block_id: OTHER,
+			layers: [
+				{
+					kind: "tiled",
+					blocks: [
+						{ block_id: OTHER, label: "shell", creator_name: "com.superlogical.terminal" },
+						{ block_id: "block:browser", label: "web", creator_name: "com.superlogical.browser" },
+					],
+				},
+			],
+		},
+	],
+})
+
+function sessionEvent(event: unknown): string {
+	return JSON.stringify({ type: "session_event", payload: { session_id: "session:s", event } })
+}
+
+function statusChanged(blockId: string, record: Record<string, unknown>, id = ""): string {
+	return sessionEvent({
+		type: "block_event",
+		payload: { block_id: blockId, creator_name: "com.superlogical.terminal", name: "program_status_changed", payload: { id, record, reason: "report" } },
+	})
+}
+
+function statusRemoved(blockId: string, ids: string[], reason = "child_exited"): string {
+	return sessionEvent({
+		type: "block_event",
+		payload: { block_id: blockId, creator_name: "com.superlogical.terminal", name: "program_status_removed", payload: { ids, reason } },
+	})
+}
+
+test.describe("rex parsing", () => {
+	test("parseWindowList maps terminal blocks to tabs and skips non-terminal blocks", () => {
+		const layout = parseWindowList(windowList)
+		assert.deepEqual([...layout.tabs], [[WIN_SELF, "Window 395a96cb"], [WIN_OTHER, "ry-fix-login"]])
+		assert.deepEqual([...layout.blocks], [[SELF, WIN_SELF], [OTHER, WIN_OTHER]])
+	})
+
+	test("parseWindowList rejects output without windows", () => {
+		assert.throws(() => parseWindowList("{}"))
+	})
+
+	test("parseProgramStatus returns the root record and prefers effective_app", () => {
+		const out = JSON.stringify({
+			records: [
+				{ state: "working", app: "pi", effective_app: "pi", updated_at: "2026-10-28T12:58:11Z", owner: { pid: 1, name: "node" } },
+				{ id: "build", state: "blocked", updated_at: "2026-10-28T12:58:11Z" },
+			],
+		})
+		assert.deepEqual(parseProgramStatus(out), { state: "working", app: "pi" })
+		assert.equal(parseProgramStatus(JSON.stringify({ records: [] })), undefined)
+		assert.equal(parseProgramStatus(JSON.stringify({ records: [{ id: "child", state: "working", updated_at: "x" }] })), undefined)
+	})
+})
+
+test.describe("rex events", () => {
+	test("root status reports create, replace and remove records", () => {
+		const state = createRexState()
+		state.layout = parseWindowList(windowList)
+
+		assert.equal(applyRexEvent(state, statusChanged(OTHER, { state: "working", app: "pi", effective_app: "pi", updated_at: "x" })), "status")
+		assert.deepEqual(listRexSiblings(state, SELF), [{ name: "ry-fix-login", status: "working" }])
+
+		assert.equal(applyRexEvent(state, statusChanged(OTHER, { state: "blocked", kind: "question", app: "pi", msg: "Approve edit?", updated_at: "x" })), "status")
+		assert.deepEqual(listRexSiblings(state, SELF), [{ name: "ry-fix-login", status: "blocked" }])
+
+		assert.equal(applyRexEvent(state, statusRemoved(OTHER, [""])), "status")
+		assert.equal(listRexSiblings(state, SELF), undefined)
+	})
+
+	test("child records, other ids and non-session lines are ignored", () => {
+		const state = createRexState()
+		assert.equal(applyRexEvent(state, statusChanged(OTHER, { state: "working", updated_at: "x" }, "build/test")), undefined)
+		assert.equal(applyRexEvent(state, statusRemoved(OTHER, ["build"])), undefined)
+		assert.equal(applyRexEvent(state, sessionEvent({ type: "session_view_changed", payload: { revision: 3 } })), undefined)
+		assert.equal(applyRexEvent(state, JSON.stringify({ type: "server_event" })), undefined)
+		assert.equal(applyRexEvent(state, "not json"), undefined)
+		assert.equal(state.status.size, 0)
+	})
+
+	test("block_closed drops the record; label and block changes request a layout refresh", () => {
+		const state = createRexState()
+		state.layout = parseWindowList(windowList)
+		applyRexEvent(state, statusChanged(OTHER, { state: "working", app: "pi", updated_at: "x" }))
+		assert.equal(applyRexEvent(state, sessionEvent({ type: "block_closed", payload: { block_id: OTHER } })), "layout")
+		assert.equal(state.status.has(OTHER), false)
+		assert.equal(state.layout.blocks.has(OTHER), false)
+		assert.equal(applyRexEvent(state, sessionEvent({ type: "window_label_changed", payload: { window_id: WIN_OTHER, label: "x" } })), "layout")
+		assert.equal(applyRexEvent(state, sessionEvent({ type: "block_created", payload: { block_id: "block:new" } })), "layout")
+	})
+})
+
+test.describe("listRexSiblings", () => {
+	test("excludes self, falls back from auto labels to the app, and needs a self block", () => {
+		const state = createRexState()
+		state.layout = parseWindowList(windowList)
+		state.status.set(SELF, { state: "working", app: "pi" })
+		state.status.set(OTHER, { state: "idle", app: "pi" })
+		assert.deepEqual(listRexSiblings(state, SELF), [{ name: "ry-fix-login", status: "idle" }])
+		// From the other pane's point of view, our auto-labelled tab is named after the program.
+		assert.deepEqual(listRexSiblings(state, OTHER), [{ name: "pi", status: "working" }])
+		assert.equal(listRexSiblings(state, undefined), undefined)
+	})
+
+	test("a pane in the same tab as self is named after its program, not the shared tab", () => {
+		const state = createRexState()
+		state.layout = parseWindowList(windowList)
+		state.layout.blocks.set("block:split", WIN_OTHER)
+		state.status.set("block:split", { state: "blocked", app: "terraform" })
+		state.status.set(SELF, { state: "working", app: "pi" })
+		assert.deepEqual(listRexSiblings(state, OTHER), [
+			{ name: "terraform", status: "blocked" },
+			{ name: "pi", status: "working" },
+		])
+	})
+
+	test("a record with neither a real label nor an app is skipped", () => {
+		const state = createRexState()
+		state.layout = parseWindowList(windowList)
+		state.status.set(SELF, { state: "working" })
+		assert.equal(listRexSiblings(state, OTHER), undefined)
+	})
+})
+
+type FakeChild = EventEmitter & { stdout: PassThrough; stderr: PassThrough; kill: () => boolean; killed: boolean }
+
+function fakeSpawn() {
+	const children: FakeChild[] = []
+	const calls: string[][] = []
+	const spawn: RexSpawn = (command, args) => {
+		calls.push([command, ...args])
+		const child = new EventEmitter() as FakeChild
+		child.stdout = new PassThrough()
+		child.stderr = new PassThrough()
+		child.killed = false
+		child.kill = () => { child.killed = true; return true }
+		children.push(child)
+		return child as unknown as ReturnType<RexSpawn>
+	}
+	return { spawn, children, calls }
+}
+
+function fakePi(statusByBlock: Record<string, string>) {
+	const execCalls: string[][] = []
+	const pi = {
+		async exec(command: string, args: string[]) {
+			execCalls.push([command, ...args])
+			if (command === "rex" && args[0] === "window") return { stdout: windowList, stderr: "", code: 0, killed: false }
+			if (command === "rex" && args[0] === "block") {
+				const block = args[args.indexOf("-b") + 1]
+				const stdout = statusByBlock[block] ?? JSON.stringify({ records: [] })
+				return { stdout, stderr: "", code: 0, killed: false }
+			}
+			return { stdout: "", stderr: "", code: 1, killed: false }
+		},
+	} as unknown as ExtensionAPI
+	return { pi, execCalls }
+}
+
+const tick = () => new Promise((resolve) => setImmediate(resolve))
+
+test.describe("createRexSiblings", () => {
+	test("seeds from window ls + program_status (skipping self), then follows the event stream", async () => {
+		const { spawn, children, calls } = fakeSpawn()
+		const { pi, execCalls } = fakePi({
+			[OTHER]: JSON.stringify({ records: [{ state: "working", app: "pi", effective_app: "pi", updated_at: "x" }] }),
+		})
+		const source = createRexSiblings({ pi, spawn, env: { REX_SESSION: "session:s", REX_BLOCK: SELF } })
+		let changes = 0
+		source.onChange(() => { changes += 1 })
+
+		assert.deepEqual(calls, [["rex", "events", "-s", "session:s", "--json"]])
+		for (let i = 0; i < 5; i++) await tick()
+		assert.deepEqual(source.get(), [{ name: "ry-fix-login", status: "working" }])
+		assert.equal(changes, 1)
+		assert.ok(execCalls.some((c) => c[1] === "window"))
+		assert.ok(execCalls.some((c) => c[1] === "block" && c.includes(OTHER)))
+		assert.equal(execCalls.some((c) => c[1] === "block" && c.includes(SELF)), false, "self is not probed")
+
+		children[0].stdout.write(statusChanged(OTHER, { state: "blocked", kind: "permission", app: "pi", updated_at: "y" }) + "\n")
+		for (let i = 0; i < 3; i++) await tick()
+		assert.deepEqual(source.get(), [{ name: "ry-fix-login", status: "blocked" }])
+		assert.equal(changes, 2)
+
+		// Same state again: no spurious notification.
+		children[0].stdout.write(statusChanged(OTHER, { state: "blocked", kind: "permission", app: "pi", updated_at: "z" }) + "\n")
+		for (let i = 0; i < 3; i++) await tick()
+		assert.equal(changes, 2)
+
+		source.dispose()
+		assert.equal(children[0].killed, true)
+		assert.equal(source.get(), undefined)
+	})
+
+	test("a stream exit clears siblings and a disposed source ignores late events", async () => {
+		const { spawn, children } = fakeSpawn()
+		const { pi } = fakePi({})
+		const source = createRexSiblings({ pi, spawn, env: { REX_SESSION: "session:s", REX_BLOCK: SELF } })
+		for (let i = 0; i < 5; i++) await tick()
+		children[0].stdout.write(statusChanged(OTHER, { state: "working", app: "pi", updated_at: "x" }) + "\n")
+		for (let i = 0; i < 3; i++) await tick()
+		assert.deepEqual(source.get(), [{ name: "ry-fix-login", status: "working" }])
+
+		children[0].emit("exit", 1)
+		assert.equal(source.get(), undefined)
+
+		source.dispose()
+		children[0].stdout.write(statusChanged(OTHER, { state: "working", app: "pi", updated_at: "x" }) + "\n")
+		for (let i = 0; i < 3; i++) await tick()
+		assert.equal(source.get(), undefined)
+	})
+})

package/test/tools.test.ts

@@ -192,10 +192,15 @@ function editRows(expanded: boolean, result: unknown = editResult, isError = fal
 	return block.render(80).map((line) => line.trimEnd())
 }
 
-test("editDiff=expanded (default) shows the diff only behind ctrl+o, in the theme's diff colours", (t) => {
+const longDiff = (n: number) => ({ content: [{ type: "text", text: "ok" }], details: { diff: Array.from({ length: n }, (_, i) => `+${i + 1} line ${i}`).join("\n") } })
+
+test("editDiff=expanded (default) shows small diffs inline and larger ones only behind ctrl+o", (t) => {
 	t.after(() => setEditDiffMode("expanded"))
 	setEditDiffMode("expanded")
-	assert.deepEqual(editRows(false), [])
+	assert.equal(editRows(false).length, 4, "a 4-line diff is shown without ctrl+o")
+	assert.equal(editRows(false, longDiff(8)).length, 8, "8 lines is still small")
+	assert.deepEqual(editRows(false, longDiff(9)), [], "9 lines waits for ctrl+o")
+	assert.equal(editRows(true, longDiff(9)).length, 9)
 	const rows = editRows(true)
 	assert.equal(rows.length, 4)
 	assert.match(rows[0]!, /│ <context> 1 context$/)
@@ -227,7 +232,7 @@ test("editDiff=always shows the diff inline and editDiff=never only on request f
 test("editDiff=always truncates a long inline diff and leaves the full diff to ctrl+o", (t) => {
 	t.after(() => setEditDiffMode("expanded"))
 	setEditDiffMode("always")
-	const long = { content: [{ type: "text", text: "ok" }], details: { diff: Array.from({ length: 60 }, (_, i) => `+${i + 1} line ${i}`).join("\n") } }
+	const long = longDiff(60)
 	const inline = editRows(false, long)
 	assert.equal(inline.length, 41)
 	assert.match(inline[40]!, /… 20 more lines \(ctrl\+o\)$/)
@@ -241,3 +246,31 @@ test("edit failures and results without a diff never render a diff block", (t) =
 	const failed = editRows(false, { content: [{ type: "text", text: "oldText not found" }] }, true)
 	assert.ok(failed.every((row) => !row.includes("<removed>")))
 })
+
+test("write rows show the written content on ctrl+o and nothing when collapsed", () => {
+	const renderers = compactRenderers("write")
+	const content = Array.from({ length: 450 }, (_, i) => `line ${i}`).join("\n")
+	const context = { args: { path: "a.ts", content }, toolCallId: "w1", invalidate() {}, state: {}, isPartial: false, isError: false, durationMs: 100 } as never
+	const result = { content: [{ type: "text", text: "Successfully wrote to a.ts" }] } as never
+	const collapsed = renderers.renderResult!(result, { expanded: false } as never, plainTheme, context).render(80)
+	assert.deepEqual(collapsed, [])
+	const expanded = renderers.renderResult!(result, { expanded: true } as never, plainTheme, context).render(80).map((l) => l.trimEnd())
+	assert.equal(expanded.length, 401)
+	assert.match(expanded[0]!, /│ line 0$/)
+	assert.match(expanded[400]!, /… 50 more lines$/)
+	const failed = { args: { path: "a.ts", content }, toolCallId: "w2", invalidate() {}, state: {}, isPartial: false, isError: true, durationMs: 100 } as never
+	const err = renderers.renderResult!({ content: [{ type: "text", text: "EACCES" }] } as never, { expanded: true } as never, plainTheme, failed).render(80)
+	assert.ok(err.every((l) => !l.includes("line 0")), "a failed write shows its error, not the content")
+})
+
+test("createRowRenderers keeps one live key per row across call and result", () => {
+	const renderers = compactRenderers("bash")
+	const state: Record<string, unknown> = {}
+	const call = { args: { command: "sleep 1" }, invalidate() {}, state, isPartial: true }
+	renderers.renderCall!({ command: "sleep 1" } as never, plainTheme, call as never)
+	assert.equal(state.liveId, "bash:sleep 1")
+	renderers.renderResult!({ content: [{ type: "text", text: "" }] } as never, { expanded: false } as never, plainTheme, { ...call, isPartial: false } as never)
+	assert.equal(state.liveId, "bash:sleep 1")
+	assert.equal((state as { running?: boolean }).running, false)
+	stopLiveWatch()
+})

package/test/working-status.test.ts

@@ -0,0 +1,53 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent"
+import { installWorkingStatus } from "../src/working-status.js"
+
+function fixture() {
+	const handlers = new Map<string, (event: unknown, ctx: ExtensionContext) => void>()
+	const messages: Array<string | undefined> = []
+	const ctx = { mode: "tui", ui: { setWorkingMessage: (text?: string) => { messages.push(text) } } } as unknown as ExtensionContext
+	const pi = { on: (name: string, handler: (event: unknown, ctx: ExtensionContext) => void) => { handlers.set(name, handler) } } as unknown as ExtensionAPI
+	const stop = installWorkingStatus(pi)
+	const emit = (name: string, event: unknown = {}) => handlers.get(name)!(event, ctx)
+	return { emit, messages, stop }
+}
+
+test("working status walks thinking → tool → thinking → writing and clears when the agent settles", (t) => {
+	t.mock.timers.enable({ apis: ["setInterval", "Date"] })
+	const f = fixture()
+	f.emit("session_start")
+	f.emit("agent_start")
+	assert.match(f.messages.at(-1)!, /^Thinking · /)
+	f.emit("tool_execution_start", { toolCallId: "t1", toolName: "bash", args: { command: "ls -la" } })
+	assert.match(f.messages.at(-1)!, /^Running ls -la/)
+	f.emit("tool_execution_end", { toolCallId: "t1" })
+	assert.match(f.messages.at(-1)!, /^Thinking · /)
+	f.emit("message_update", { message: { role: "assistant", content: [] }, assistantMessageEvent: { type: "text_delta" } })
+	assert.match(f.messages.at(-1)!, /^Writing/)
+	f.emit("agent_settled")
+	assert.equal(f.messages.at(-1), undefined, "settling clears the message")
+	f.stop()
+})
+
+test("events before session_start or after settle are ignored", () => {
+	const f = fixture()
+	f.emit("agent_start")
+	assert.deepEqual(f.messages, [])
+	f.emit("session_start")
+	f.emit("tool_execution_start", { toolCallId: "x", toolName: "read" })
+	assert.deepEqual(f.messages, [], "a tool without an active run does not paint")
+	f.stop()
+})
+
+test("session_shutdown clears the working message while the context is still known", (t) => {
+	t.mock.timers.enable({ apis: ["setInterval", "Date"] })
+	const f = fixture()
+	f.emit("session_start")
+	f.emit("agent_start")
+	assert.ok(f.messages.at(-1))
+	f.emit("session_shutdown")
+	assert.equal(f.messages.at(-1), undefined, "shutdown must call setWorkingMessage() to clear")
+	f.emit("agent_start")
+	assert.equal(f.messages.at(-1), undefined, "no painting after shutdown dropped the context")
+})