pi-cockpit 0.3.0 → 0.5.0

package/src/quiet-tools.ts

@@ -0,0 +1,310 @@
+// Quiet mode tool rendering: compress each built-in tool call into a single
+// ✓/✗/⋯ line. Architecture adapted from pi-quiet (github.com/wing900/pi-quiet):
+// a config-driven SPECS table + shared render functions. Execution is delegated
+// to the original built-in tools — only the rendering is replaced.
+//
+// Scope boundary: only the seven built-in tools (read/bash/edit/write/grep/find/ls)
+// are compressed. Compression works by re-registering the tool name and delegating
+// execution back to pi's exported creators. MCP/extension tools (todo, teammate,
+// mcp, lsp, ...) cannot be compressed this way: registerTool is first-name-wins and
+// replaces the whole definition, and the public API exposes neither a render-only
+// hook nor a handle to the original execute — re-registering them would break their
+// execution, so they keep their default rendering.
+//
+// Registered at session_start when config.quietMode is true. Because tools cannot
+// be unregistered, toggling quiet mode off requires /reload or a new session.
+
+import type {
+	BashToolDetails,
+	EditToolDetails,
+	ExtensionAPI,
+	ExtensionContext,
+	ReadToolDetails,
+} from "@earendil-works/pi-coding-agent";
+import {
+	createBashTool,
+	createEditTool,
+	createFindTool,
+	createGrepTool,
+	createLsTool,
+	createReadTool,
+	createWriteTool,
+} from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import { homedir } from "node:os";
+import type { CockpitConfig } from "./types.ts";
+import { resolveGlyphs, type IconGlyphs } from "./icons.ts";
+
+// ---------- helpers ----------
+
+function shortenPath(p: string): string {
+	const home = homedir();
+	return p.startsWith(home) ? `~${p.slice(home.length)}` : p;
+}
+
+function truncate(s: string, max: number): string {
+	if (s.length <= max) return s;
+	return `${s.slice(0, max - 1)}…`;
+}
+
+function termWidth(): number {
+	return process.stdout.columns || 100;
+}
+
+function textOf(result: { content: Array<{ type: string; text?: string }> }): string {
+	const c = result.content.find((c) => c.type === "text" && c.text);
+	return c?.text ?? "";
+}
+
+function parseBashExit(output: string): number | null {
+	const m = output.match(/exit code: (\d+)/);
+	return m ? parseInt(m[1], 10) : null;
+}
+
+function firstErrorLine(result: { content: Array<{ type: string; text?: string }> }): string {
+	return truncate(textOf(result).split("\n").find((l) => l.trim()) || "error", 60);
+}
+
+// ---------- built-in tool cache ----------
+
+type BuiltInTools = ReturnType<typeof createBuiltInTools>;
+const toolCache = new Map<string, BuiltInTools>();
+
+function createBuiltInTools(cwd: string) {
+	return {
+		read: createReadTool(cwd),
+		bash: createBashTool(cwd),
+		edit: createEditTool(cwd),
+		write: createWriteTool(cwd),
+		find: createFindTool(cwd),
+		grep: createGrepTool(cwd),
+		ls: createLsTool(cwd),
+	};
+}
+
+function getBuiltInTools(cwd: string): BuiltInTools {
+	let tools = toolCache.get(cwd);
+	if (!tools) {
+		tools = createBuiltInTools(cwd);
+		toolCache.set(cwd, tools);
+	}
+	return tools;
+}
+
+// ---------- tool spec ----------
+
+interface ToolSpec {
+	name: string;
+	/** Key argument shown after the tool name (path / command / pattern). */
+	arg: (args: any) => string;
+	/** Final compact summary after the separator (for example "12M" or "0 · 3L"). */
+	summary: (result: any, ctx: any) => string;
+	/** Expanded content; empty string means nothing extra. */
+	expanded?: (result: any) => string;
+	/** Success predicate; defaults to !ctx.isError. */
+	ok?: (result: any, ctx: any) => boolean;
+}
+
+const SPECS: ToolSpec[] = [
+	{
+		name: "read",
+		arg: (a) => shortenPath(a.path || ""),
+		summary: (r) => {
+			const c = r.content[0];
+			if (c?.type === "image") return "image";
+			const lines = c?.type === "text" ? c.text.split("\n").length : 0;
+			const d = r.details as ReadToolDetails | undefined;
+			let s = `${lines}L`;
+			if (d?.truncation?.truncated) s += `/${d.truncation.totalLines}L`;
+			return s;
+		},
+		expanded: (r) => textOf(r).split("\n").slice(0, 15).join("\n"),
+	},
+	{
+		name: "bash",
+		arg: (a) => a.command || "",
+		summary: (r) => {
+			const out = textOf(r);
+			const exit = parseBashExit(out);
+			const n = out.split("\n").filter((l: string) => l.trim()).length;
+			const d = r.details as BashToolDetails | undefined;
+			let s = `${exit ?? "?"} · ${n}L`;
+			if (d?.truncation?.truncated) s += " · trunc";
+			return s;
+		},
+		expanded: (r) => textOf(r).split("\n").slice(0, 20).join("\n"),
+		ok: (r, ctx) => {
+			if (ctx.isError) return false;
+			const exit = parseBashExit(textOf(r));
+			return exit === null || exit === 0;
+		},
+	},
+	{
+		name: "edit",
+		arg: (a) => shortenPath(a.path || ""),
+		summary: (r, ctx) => {
+			if (ctx.isError) return firstErrorLine(r);
+			const d = r.details as EditToolDetails | undefined;
+			if (!d?.diff) return "applied";
+			let add = 0;
+			let del = 0;
+			for (const line of d.diff.split("\n")) {
+				if (line.startsWith("+") && !line.startsWith("+++")) add++;
+				if (line.startsWith("-") && !line.startsWith("---")) del++;
+			}
+			return `+${add}/-${del}`;
+		},
+		expanded: (r) => {
+			const d = r.details as EditToolDetails | undefined;
+			return d?.diff ?? textOf(r);
+		},
+	},
+	{
+		name: "write",
+		arg: (a) => shortenPath(a.path || ""),
+		summary: (r, ctx) => {
+			if (ctx.isError) return firstErrorLine(r);
+			const content = typeof ctx.args?.content === "string" ? ctx.args.content : "";
+			return `${content === "" ? 0 : content.split("\n").length}L`;
+		},
+	},
+	{
+		name: "find",
+		arg: (a) => `${a.pattern || ""} @ ${shortenPath(a.path || ".")}`,
+		summary: (r, ctx) => (ctx.isError ? firstErrorLine(r) : `${textOf(r).trim().split("\n").filter(Boolean).length}F`),
+		expanded: (r) => textOf(r),
+	},
+	{
+		name: "grep",
+		arg: (a) => `${a.pattern || ""} @ ${shortenPath(a.path || ".")}`,
+		summary: (r, ctx) => (ctx.isError ? firstErrorLine(r) : `${textOf(r).trim().split("\n").filter(Boolean).length}M`),
+		expanded: (r) => textOf(r),
+	},
+	{
+		name: "ls",
+		arg: (a) => shortenPath(a.path || "."),
+		summary: (r, ctx) => (ctx.isError ? firstErrorLine(r) : `${textOf(r).trim().split("\n").filter(Boolean).length}E`),
+		expanded: (r) => textOf(r),
+	},
+];
+
+// ---------- rendering ----------
+
+const TOOL_COLORS: Record<string, string> = {
+	bash: "syntaxFunction",
+	read: "syntaxType",
+	ls: "syntaxType",
+	grep: "syntaxKeyword",
+	find: "syntaxKeyword",
+	edit: "syntaxVariable",
+	write: "syntaxVariable",
+};
+
+function quietMark(
+	mode: CockpitConfig["quietSymbols"],
+	state: "running" | "success" | "failure",
+	glyphs: IconGlyphs,
+): string {
+	if (mode === "dot") {
+		if (state === "running") return glyphs.pending;
+		if (state === "success") return glyphs.dotRunning;
+		return glyphs.blocked;
+	}
+	if (state === "running") return glyphs.ellipsis;
+	if (state === "success") return glyphs.check;
+	return glyphs.cross;
+}
+
+function toolName(spec: ToolSpec, theme: any): string {
+	return theme.fg(TOOL_COLORS[spec.name] ?? "toolTitle", theme.bold(spec.name));
+}
+
+function renderCallLine(
+	spec: ToolSpec,
+	args: any,
+	theme: any,
+	glyphs: IconGlyphs,
+	mode: CockpitConfig["quietSymbols"],
+): string {
+	const mark = quietMark(mode, "running", glyphs);
+	const argCap = Math.max(10, termWidth() - (spec.name.length + mark.length + 5));
+	const argText = truncate(spec.arg(args), argCap);
+	return `  ${theme.fg("warning", mark)} ${toolName(spec, theme)}${argText ? ` ${theme.fg("accent", argText)}` : ""}`;
+}
+
+function renderResultLine(
+	spec: ToolSpec,
+	args: any,
+	result: any,
+	ctx: any,
+	theme: any,
+	expanded: boolean,
+	glyphs: IconGlyphs,
+	mode: CockpitConfig["quietSymbols"],
+): string {
+	const isOk = spec.ok ? spec.ok(result, ctx) : !ctx.isError;
+	const rawMark = quietMark(mode, isOk ? "success" : "failure", glyphs);
+	const mark = theme.fg(isOk ? "success" : "error", rawMark);
+
+	const overhead = 7 + spec.name.length + rawMark.length;
+	const budget = Math.max(20, termWidth() - overhead);
+	const sumCap = Math.min(35, Math.floor(budget * 0.4));
+	const sumRaw = truncate(spec.summary(result, ctx), sumCap);
+	const argCap = Math.max(10, budget - sumRaw.length);
+	const argText = truncate(spec.arg(args), argCap);
+
+	let t = `  ${mark} ${toolName(spec, theme)}${argText ? ` ${theme.fg("accent", argText)}` : ""}`;
+	if (sumRaw) t += ` ${theme.fg("dim", `· ${sumRaw}`)}`;
+
+	if (expanded) {
+		const full = spec.expanded ? spec.expanded(result) : textOf(result);
+		if (full && full.trim()) {
+			t += "\n" + theme.fg("dim", full);
+		}
+	}
+	return t;
+}
+
+// ---------- registration ----------
+
+/**
+ * Register compact tool renderers for quiet mode. Called once at session_start
+ * when config.quietMode is true. Tools delegate execution to the built-in
+ * implementations; only the visual shell is replaced.
+ */
+export function registerQuietTools(pi: ExtensionAPI, getConfig: () => CockpitConfig): void {
+	for (const spec of SPECS) {
+		const original = (getBuiltInTools(process.cwd()) as any)[spec.name];
+		pi.registerTool({
+			name: spec.name,
+			label: spec.name,
+			description: original.description,
+			parameters: original.parameters,
+			renderShell: "self",
+
+			async execute(toolCallId: string, params: any, signal: any, onUpdate: any, ctx: ExtensionContext) {
+				return (getBuiltInTools(ctx.cwd) as any)[spec.name].execute(toolCallId, params, signal, onUpdate);
+			},
+
+			renderCall(args: any, theme: any, ctx: any) {
+				// Once the result arrives this slot is empty; only renderResult draws.
+				if (!ctx.isPartial) return new Text("", 0, 0);
+				const config = getConfig();
+				const glyphs = resolveGlyphs(config.icons.mode);
+				return new Text(renderCallLine(spec, args, theme, glyphs, config.quietSymbols), 0, 0);
+			},
+
+			renderResult(result: any, { expanded, isPartial }: any, theme: any, ctx: any) {
+				// While streaming, leave empty because renderCall owns the row.
+				if (isPartial) return new Text("", 0, 0);
+				const config = getConfig();
+				const glyphs = resolveGlyphs(config.icons.mode);
+				return new Text(
+					renderResultLine(spec, ctx.args, result, ctx, theme, expanded, glyphs, config.quietSymbols),
+					0,
+					0,
+				);
+			},
+		});
+	}
+}

package/src/render.ts

@@ -205,6 +205,7 @@ export function renderAgents(
 	if (rows.length === 0) return [];
 	const g = opts.glyphs;
 	const ell = theme.fg("dim", g.ellipsis);
+
 	if (mode === "compact") {
 		const active = rows.filter((row) => row.status === "running" || row.status === "retrying").length;
 		const head = `${theme.fg("text", String(rows.length))} ${theme.fg("muted", "agents")}${active ? theme.fg("dim", ` · ${active} active`) : ""}`;
@@ -239,7 +240,7 @@ export function renderAgents(
 		if (status.label) segs.push({ text: theme.fg(status.color, status.label), priority: 95, clippable: false });
 		segs.push({ text: theme.fg(rc, r.role), priority: 90 });
 		if (r.task) segs.push({ text: r.task, priority: 80, minWidth: 6 });
-		segs.push({ text: theme.fg("muted", formatDuration(now - r.startedAt)), priority: 70, clippable: false });
+		segs.push({ text: theme.fg("muted", formatDuration((r.finishedAt ?? now) - r.startedAt)), priority: 70, clippable: false });
 		if (r.dependencies?.length) {
 			segs.push({ text: theme.fg("dim", formatDependencies(r.dependencies, g)), priority: 60, clippable: false });
 		}

package/src/settings-view.ts

@@ -1,129 +1,166 @@
-// Pure model for the /cockpit settings panel.
-//
-// The old panel was a flat list of blind letter accelerators: no cursor, no
-// focused row, no indication of what a key would cycle to, and every keystroke
-// wrote to disk while failures were swallowed. This module owns the row model and
-// the cursor/cycle logic so the behaviour is unit-testable; index.ts only paints
-// it and performs the actual save.
-
-import type { CockpitConfig, IconMode, ViewMode } from "./types.ts";
-
-export type SaveState =
-	| { kind: "idle" }
-	| { kind: "saving" }
-	| { kind: "saved" }
-	| { kind: "failed"; message: string };
-
-export interface SettingsRow {
-	key: string;
-	/** Single-letter accelerator, kept as a secondary path alongside the cursor. */
-	accel: string;
-	label: string;
-	value: string;
-	/** What pressing Enter/Space/accel switches to — shown so the cycle is visible. */
-	next: string;
-}
-
-const VIEW_MODES: ViewMode[] = ["list", "compact"];
-const ICON_MODES: IconMode[] = ["auto", "nerd", "ascii"];
-
-function cycle<T>(values: readonly T[], current: T): T {
-	const index = values.indexOf(current);
-	return values[(index + 1) % values.length];
-}
-
-// Empty means cockpit has not set a theme, so whatever /settings holds is live.
-// It is deliberately not called "default": pi's setting is the authority here,
-// and cockpit only ever nudges it.
-const NO_THEME_LABEL = "(pi settings)";
-
-function themeLabel(theme: string): string {
-	return theme === "" ? NO_THEME_LABEL : theme;
-}
-
-export function buildRows(config: CockpitConfig): SettingsRow[] {
-	return [
-		{
-			key: "enabled",
-			accel: "e",
-			label: "enabled",
-			value: config.enabled ? "on" : "off",
-			next: config.enabled ? "off" : "on",
-		},
-		{
-			key: "agentsMode",
-			accel: "a",
-			label: "agents",
-			value: config.agentsMode,
-			next: cycle(VIEW_MODES, config.agentsMode),
-		},
-		{
-			key: "todoMode",
-			accel: "t",
-			label: "todo",
-			value: config.todoMode,
-			next: cycle(VIEW_MODES, config.todoMode),
-		},
-		{
-			key: "todoExpanded",
-			accel: "x",
-			label: "todo expand",
-			value: config.todoExpanded ? "yes" : "no",
-			next: config.todoExpanded ? "no" : "yes",
-		},
-		{
-			key: "hideNativeAgents",
-			accel: "n",
-			label: "hide native",
-			value: config.hideNativeAgents ? "yes" : "no",
-			next: config.hideNativeAgents ? "no" : "yes",
-		},
-		{
-			key: "icons",
-			accel: "i",
-			label: "icons",
-			value: config.icons.mode,
-			next: cycle(ICON_MODES, config.icons.mode),
-		},
-		{
-			key: "theme",
-			accel: "h",
-			label: "theme",
-			value: themeLabel(config.theme),
-			// Not a cycle: this row opens the /theme picker, which previews live and
-			// reverts on Esc. Blind-cycling a name list could not do either.
-			//
-			// Worded as an affordance, not as a command to go type: every other row's
-			// `next` is the value Enter produces, and "open /theme" read as "leave this
-			// panel and run something else" when Enter opens it right here. The ellipsis
-			// is the usual terminal signal for "this one opens a dialog".
-			next: "picker…",
-		},
-	];
-}
-
-/** Apply the row's cycle to the config, returning a new config object. */
-export function applyRow(config: CockpitConfig, key: string): CockpitConfig {
-	switch (key) {
-		case "enabled":
-			return { ...config, enabled: !config.enabled };
-		case "agentsMode":
-			return { ...config, agentsMode: cycle(VIEW_MODES, config.agentsMode) };
-		case "todoMode":
-			return { ...config, todoMode: cycle(VIEW_MODES, config.todoMode) };
-		case "todoExpanded":
-			return { ...config, todoExpanded: !config.todoExpanded };
-		case "hideNativeAgents":
-			return { ...config, hideNativeAgents: !config.hideNativeAgents };
-		case "icons":
-			return { ...config, icons: { mode: cycle(ICON_MODES, config.icons.mode) } };
-		// "theme" is intentionally absent: the row hands off to the /theme picker,
-		// which owns both the preview and the write-through to pi's settings.
-		default:
-			return config;
-	}
-}
-
-export function rowKeyForAccel(rows: readonly SettingsRow[], accel: string): string | undefined {
-	return rows.find((row) => row.accel === accel)?.key;
-}
+// Pure model for the /cockpit settings panel.
+//
+// The old panel was a flat list of blind letter accelerators: no cursor, no
+// focused row, no indication of what a key would cycle to, and every keystroke
+// wrote to disk while failures were swallowed. This module owns the row model and
+// the cursor/cycle logic so the behaviour is unit-testable; index.ts only paints
+// it and performs the actual save.
+
+import type { CockpitConfig, IconMode, QuietSymbolMode, ViewMode } from "./types.ts";
+
+export type SaveState =
+	| { kind: "idle" }
+	| { kind: "saving" }
+	| { kind: "saved" }
+	| { kind: "failed"; message: string };
+
+export interface SettingsRow {
+	key: string;
+	/** Single-letter accelerator, kept as a secondary path alongside the cursor. */
+	accel: string;
+	label: string;
+	value: string;
+	/** What pressing Enter/Space/accel switches to — shown so the cycle is visible. */
+	next: string;
+}
+
+const VIEW_MODES: ViewMode[] = ["list", "compact"];
+const QUIET_SYMBOL_MODES: QuietSymbolMode[] = ["check", "dot"];
+const ICON_MODES: IconMode[] = ["auto", "nerd", "ascii"];
+
+function cycle<T>(values: readonly T[], current: T): T {
+	const index = values.indexOf(current);
+	return values[(index + 1) % values.length];
+}
+
+// Empty means cockpit has not set a theme, so whatever /settings holds is live.
+// It is deliberately not called "default": pi's setting is the authority here,
+// and cockpit only ever nudges it.
+const NO_THEME_LABEL = "(pi settings)";
+
+function themeLabel(theme: string): string {
+	return theme === "" ? NO_THEME_LABEL : theme;
+}
+
+export interface LiveRowState {
+	/** pi's effective hideThinkingBlock; the thinking row is a pass-through. */
+	thinkingHidden: boolean;
+}
+
+export function buildRows(config: CockpitConfig, live?: LiveRowState): SettingsRow[] {
+	const thinkingHidden = live?.thinkingHidden ?? false;
+	return [
+		{
+			key: "enabled",
+			accel: "e",
+			label: "enabled",
+			value: config.enabled ? "on" : "off",
+			next: config.enabled ? "off" : "on",
+		},
+		{
+			key: "quietMode",
+			accel: "q",
+			label: "quiet (reload)",
+			value: config.quietMode ? "on" : "off",
+			next: config.quietMode ? "off" : "on",
+		},
+		{
+			key: "quietSymbols",
+			accel: "s",
+			label: "quiet symbols",
+			value: config.quietSymbols,
+			next: cycle(QUIET_SYMBOL_MODES, config.quietSymbols),
+		},
+		{
+			// Pass-through to pi's native thinking toggle: the value mirrors pi's
+			// persisted hideThinkingBlock and the panel dispatches the toggle
+			// itself — applyRow deliberately ignores this key, like "theme".
+			key: "thinkingFold",
+			accel: "f",
+			label: "thinking fold",
+			value: thinkingHidden ? "hidden" : "visible",
+			next: thinkingHidden ? "visible" : "hidden",
+		},
+		{
+			key: "agentsMode",
+			accel: "a",
+			label: "agents",
+			value: config.agentsMode,
+			next: cycle(VIEW_MODES, config.agentsMode),
+		},
+		{
+			key: "todoMode",
+			accel: "t",
+			label: "todo",
+			value: config.todoMode,
+			next: cycle(VIEW_MODES, config.todoMode),
+		},
+		{
+			key: "todoExpanded",
+			accel: "x",
+			label: "todo expand",
+			value: config.todoExpanded ? "yes" : "no",
+			next: config.todoExpanded ? "no" : "yes",
+		},
+		{
+			key: "hideNativeAgents",
+			accel: "n",
+			label: "hide native",
+			value: config.hideNativeAgents ? "yes" : "no",
+			next: config.hideNativeAgents ? "no" : "yes",
+		},
+		{
+			key: "icons",
+			accel: "i",
+			label: "icons",
+			value: config.icons.mode,
+			next: cycle(ICON_MODES, config.icons.mode),
+		},
+		{
+			key: "theme",
+			accel: "h",
+			label: "theme",
+			value: themeLabel(config.theme),
+			// Not a cycle: this row opens the /theme picker, which previews live and
+			// reverts on Esc. Blind-cycling a name list could not do either.
+			//
+			// Worded as an affordance, not as a command to go type: every other row's
+			// `next` is the value Enter produces, and "open /theme" read as "leave this
+			// panel and run something else" when Enter opens it right here. The ellipsis
+			// is the usual terminal signal for "this one opens a dialog".
+			next: "picker…",
+		},
+	];
+}
+
+/** Apply the row's cycle to the config, returning a new config object. */
+export function applyRow(config: CockpitConfig, key: string): CockpitConfig {
+	switch (key) {
+		case "enabled":
+			return { ...config, enabled: !config.enabled };
+		case "quietMode":
+			return { ...config, quietMode: !config.quietMode };
+		case "quietSymbols":
+			return { ...config, quietSymbols: cycle(QUIET_SYMBOL_MODES, config.quietSymbols) };
+		case "agentsMode":
+			return { ...config, agentsMode: cycle(VIEW_MODES, config.agentsMode) };
+		case "todoMode":
+			return { ...config, todoMode: cycle(VIEW_MODES, config.todoMode) };
+		case "todoExpanded":
+			return { ...config, todoExpanded: !config.todoExpanded };
+		case "hideNativeAgents":
+			return { ...config, hideNativeAgents: !config.hideNativeAgents };
+		case "icons":
+			return { ...config, icons: { mode: cycle(ICON_MODES, config.icons.mode) } };
+		// "theme" is intentionally absent: the row hands off to the /theme picker,
+		// which owns both the preview and the write-through to pi's settings.
+		// "thinkingFold" is absent for the same reason: pi owns hideThinkingBlock,
+		// and the panel dispatches pi's native toggle instead of cycling config.
+		default:
+			return config;
+	}
+}
+
+export function rowKeyForAccel(rows: readonly SettingsRow[], accel: string): string | undefined {
+	return rows.find((row) => row.accel === accel)?.key;
+}