lsd-pi 1.3.2 → 1.3.7

package/packages/pi-coding-agent/src/core/settings-manager.fast-mode.test.ts

@@ -0,0 +1,46 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, it } from "node:test";
+
+import { SettingsManager } from "./settings-manager.js";
+
+describe("SettingsManager fastMode", () => {
+	it("defaults fastMode to false", () => {
+		const manager = SettingsManager.inMemory();
+		assert.equal(manager.getFastMode(), false);
+	});
+
+	it("persists fastMode changes to settings.json", async () => {
+		const root = mkdtempSync(join(tmpdir(), "pi-fast-mode-settings-"));
+		const cwd = join(root, "project");
+		const agentDir = join(root, "agent");
+
+		try {
+			const manager = SettingsManager.create(cwd, agentDir);
+			assert.equal(manager.getFastMode(), false);
+
+			manager.setFastMode(true);
+			await manager.flush();
+
+			const rawEnabled = JSON.parse(readFileSync(join(agentDir, "settings.json"), "utf8")) as {
+				fastMode?: boolean;
+			};
+			assert.equal(rawEnabled.fastMode, true);
+
+			const reloaded = SettingsManager.create(cwd, agentDir);
+			assert.equal(reloaded.getFastMode(), true);
+
+			reloaded.setFastMode(false);
+			await reloaded.flush();
+
+			const rawDisabled = JSON.parse(readFileSync(join(agentDir, "settings.json"), "utf8")) as {
+				fastMode?: boolean;
+			};
+			assert.equal(rawDisabled.fastMode, false);
+		} finally {
+			rmSync(root, { recursive: true, force: true });
+		}
+	});
+});

package/packages/pi-coding-agent/src/core/settings-manager.ts

@@ -159,7 +159,9 @@ export interface Settings {
 	images?: ImageSettings;
 	enabledModels?: string[]; // Model patterns for cycling (same format as --models CLI flag)
 	codexRotate?: boolean; // Enable the bundled codex-rotate extension (default: false)
+	fastMode?: boolean; // Enable OpenAI/Codex fast tier routing (priority service tier where supported)
 	cacheTimer?: boolean; // Show elapsed time since last response in the footer (default: true)
+	verboseFooter?: boolean; // Show extra footer usage stats like input/output/cache tokens (default: false)
 	pinLastPrompt?: boolean; // Pin last sent prompt above the editor as a reminder (default: false)
 	doubleEscapeAction?: "fork" | "tree" | "none"; // Action for double-escape with empty editor (default: "tree")
 	treeFilterMode?: "default" | "no-tools" | "user-only" | "labeled-only" | "all"; // Default filter when opening /tree
@@ -180,12 +182,14 @@ export interface Settings {
 	editMode?: "standard" | "hashline"; // Edit tool mode: "standard" (text match) or "hashline" (LINE#ID anchors). Default: "standard"
 	timestampFormat?: "date-time-iso" | "date-time-us"; // Timestamp display format for messages. Default: "date-time-iso"
 	toolOutputMode?: "minimal" | "normal"; // Collapsed tool rendering mode. "minimal" hides previews until expanded.
+	collapseToolCalls?: boolean; // default: false — group low-priority tool calls into collapsed summary lines
 	lspAutoInstall?: boolean; // default: false — whether to auto-install missing language servers during onboarding
 	lspInstalledServers?: string[]; // list of server names installed via the onboarding wizard
 	rtk?: boolean; // default: false — enable RTK shell-command compression (requires restart)
 	editorScheme?: "auto" | "vscode" | "cursor" | "zed" | "jetbrains" | "sublime" | "file"; // URI scheme for Cmd+click file links (default: "auto")
 	autoDream?: boolean; // default: false — enable automatic memory consolidation (dream) after sessions
 	autoMemory?: boolean; // default: false — enable automatic memory extraction from session transcripts
+	notificationSound?: boolean; // default: false — play terminal bell when agent finishes responding
 	telegramLiveRelayAutoConnect?: boolean; // default: false — auto-run /lsd telegram connect on startup
 }
 
@@ -1049,6 +1053,14 @@ export class SettingsManager {
 		this.setGlobalSetting("toolOutputMode", mode);
 	}
 
+	getCollapseToolCalls(): boolean {
+		return this.settings.collapseToolCalls ?? false;
+	}
+
+	setCollapseToolCalls(enabled: boolean): void {
+		this.setGlobalSetting("collapseToolCalls", enabled);
+	}
+
 	getPackages(): PackageSource[] {
 		return [...(this.settings.packages ?? [])];
 	}
@@ -1187,6 +1199,14 @@ export class SettingsManager {
 		this.setGlobalSetting("codexRotate", enabled);
 	}
 
+	getFastMode(): boolean {
+		return this.settings.fastMode ?? false;
+	}
+
+	setFastMode(enabled: boolean): void {
+		this.setGlobalSetting("fastMode", enabled);
+	}
+
 	getCacheTimer(): boolean {
 		return this.settings.cacheTimer ?? true;
 	}
@@ -1195,6 +1215,14 @@ export class SettingsManager {
 		this.setGlobalSetting("cacheTimer", enabled);
 	}
 
+	getVerboseFooter(): boolean {
+		return this.settings.verboseFooter ?? false;
+	}
+
+	setVerboseFooter(enabled: boolean): void {
+		this.setGlobalSetting("verboseFooter", enabled);
+	}
+
 	getPinLastPrompt(): boolean {
 		return this.settings.pinLastPrompt ?? false;
 	}
@@ -1445,6 +1473,14 @@ export class SettingsManager {
 		this.setGlobalSetting("autoMemory", enabled);
 	}
 
+	getNotificationSound(): boolean {
+		return this.settings.notificationSound ?? false;
+	}
+
+	setNotificationSound(enabled: boolean): void {
+		this.setGlobalSetting("notificationSound", enabled);
+	}
+
 	getTelegramLiveRelayAutoConnect(): boolean {
 		return this.settings.telegramLiveRelayAutoConnect ?? false;
 	}

package/packages/pi-coding-agent/src/core/slash-commands.ts

@@ -27,6 +27,7 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 	{ name: "session", description: "Show session info and stats" },
 	{ name: "changelog", description: "Show changelog entries" },
 	{ name: "hotkeys", description: "Show all keyboard shortcuts" },
+	{ name: "btw", description: "Ask a side question without interrupting the current task" },
 	{ name: "fork", description: "Create a new fork from a previous message" },
 	{ name: "tree", description: "Navigate session tree (switch branches)" },
 	{ name: "provider", description: "Manage provider configuration" },

package/packages/pi-coding-agent/src/core/system-prompt.ts

@@ -149,7 +149,12 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 	const hasLsp = tools.includes("lsp");
 
 	// Priority-ordered compact guidelines
-	addGuideline("Be concise. Prefer short, direct answers over preamble.");
+	addGuideline("Terse output. All technical substance stays. Only fluff dies.");
+	addGuideline("Drop: articles (a/an/the), filler (just/really/basically/actually/simply), pleasantries (sure/certainly/of course/happy to), hedging (might be worth/could consider).");
+	addGuideline("Fragments OK. Short synonyms (big not extensive, fix not implement a solution for). Pattern: [thing] [action] [reason]. [next step].");
+	addGuideline("Never announce what you're about to do — just do it. Never summarize what you just did unless the user asks.");
+	addGuideline("Code blocks, error messages, file paths, and technical terms stay exact. Only compress prose.");
+	addGuideline("For security warnings, irreversible actions, or multi-step sequences where fragments risk misread — use full clear sentences. Resume terse after.");
 	addGuideline("For conceptual, product, or UX questions, answer first; inspect code only if implementation detail is needed.");
 
 	const hasSubagent = tools.includes("subagent");

package/packages/pi-coding-agent/src/core/tool-priority.test.ts

@@ -0,0 +1,30 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+
+import { getToolPriority, shouldCollapse } from "./tool-priority.js";
+
+describe("tool priority", () => {
+	it("keeps edit and write always visible", () => {
+		assert.equal(getToolPriority("edit"), "always");
+		assert.equal(getToolPriority("write"), "always");
+		assert.equal(shouldCollapse("edit", false), false);
+		assert.equal(shouldCollapse("write", true), false);
+	});
+
+	it("collapses bash and bg_shell only on success", () => {
+		assert.equal(getToolPriority("bash"), "on-error");
+		assert.equal(getToolPriority("bg_shell"), "on-error");
+		assert.equal(shouldCollapse("bash", false), true);
+		assert.equal(shouldCollapse("bash", true), false);
+		assert.equal(shouldCollapse("bg_shell", false), true);
+		assert.equal(shouldCollapse("bg_shell", true), false);
+	});
+
+	it("collapses read, grep, and unknown tools", () => {
+		assert.equal(getToolPriority("read"), "collapse");
+		assert.equal(getToolPriority("grep"), "collapse");
+		assert.equal(getToolPriority("unknown-tool"), "collapse");
+		assert.equal(shouldCollapse("read", false), true);
+		assert.equal(shouldCollapse("unknown-tool", true), true);
+	});
+});

package/packages/pi-coding-agent/src/core/tool-priority.ts

@@ -0,0 +1,17 @@
+export type ToolPriority = "always" | "on-error" | "collapse";
+
+const ALWAYS_VISIBLE = new Set(["edit", "write"]);
+const ON_ERROR = new Set(["bash", "bg_shell"]);
+
+export function getToolPriority(toolName: string): ToolPriority {
+	if (ALWAYS_VISIBLE.has(toolName)) return "always";
+	if (ON_ERROR.has(toolName)) return "on-error";
+	return "collapse";
+}
+
+export function shouldCollapse(toolName: string, isError: boolean): boolean {
+	const priority = getToolPriority(toolName);
+	if (priority === "always") return false;
+	if (priority === "on-error") return !isError;
+	return true;
+}

package/packages/pi-coding-agent/src/core/tools/edit-diff.test.ts

@@ -6,6 +6,7 @@ import { describe, it } from "node:test";
 
 import {
 	computeEditDiff,
+	computeWriteDiff,
 	fuzzyFindText,
 	generateDiffString,
 	normalizeForFuzzyMatch,
@@ -60,6 +61,25 @@ describe("edit-diff", () => {
 		assert.match(result.diff, /CHANGED/);
 	});
 
+	it("computes diffs for write preview against existing files", async (t) => {
+		const dir = mkdtempSync(join(tmpdir(), "write-diff-test-"));
+		t.after(() => {
+			rmSync(dir, { recursive: true, force: true });
+		});
+
+		const file = join(dir, "sample.ts");
+		writeFileSync(file, "const title = \"Hello\";\n", "utf-8");
+
+		const result = await computeWriteDiff(file, "const title = \"Hi\";\n", dir);
+
+		assert.ok(!("error" in result), "expected a diff result");
+		if (!("error" in result)) {
+			assert.equal(result.firstChangedLine, 1);
+			assert.match(result.diff, /-1 const title = "Hello";/);
+			assert.match(result.diff, /\+1 const title = "Hi";/);
+		}
+	});
+
 	it("computes diffs for preview without native helpers", async (t) => {
 		const dir = mkdtempSync(join(tmpdir(), "edit-diff-test-"));
 		t.after(() => {

package/packages/pi-coding-agent/src/core/tools/edit-diff.ts

@@ -329,6 +329,32 @@ function buildLineDiffLinear(oldLines: string[], newLines: string[]): LineDiffOp
 	return ops;
 }
 
+/**
+ * Compute the diff for a write operation without applying it.
+ * Used for preview rendering in the TUI before the tool executes.
+ */
+export async function computeWriteDiff(
+	path: string,
+	newContent: string,
+	cwd: string,
+): Promise<EditDiffResult | EditDiffError> {
+	const absolutePath = resolveToCwd(path, cwd);
+
+	try {
+		let oldContent = "";
+		try {
+			await access(absolutePath, constants.R_OK);
+			oldContent = await readFile(absolutePath, "utf-8");
+		} catch {
+			oldContent = "";
+		}
+
+		return generateDiffString(normalizeToLF(stripBom(oldContent).text), normalizeToLF(newContent));
+	} catch (err) {
+		return { error: err instanceof Error ? err.message : String(err) };
+	}
+}
+
 /**
  * Compute the diff for an edit operation without applying it.
  * Used for preview rendering in the TUI before the tool executes.

package/packages/pi-coding-agent/src/modes/interactive/components/__tests__/tool-summary-line.test.ts

@@ -0,0 +1,41 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import stripAnsi from "strip-ansi";
+
+import { ToolSummaryLine } from "../tool-summary-line.js";
+import { initTheme } from "../../theme/theme.js";
+
+initTheme("dark");
+
+describe("ToolSummaryLine", () => {
+	it("renders action-based summaries for grouped identical tools", () => {
+		const summary = new ToolSummaryLine();
+		summary.addTool("read", 600);
+		summary.addTool("read", 150);
+
+		const rendered = stripAnsi(summary.render(160).join("\n"));
+		assert.match(rendered, /^ ● /);
+		assert.ok(rendered.includes("reading 2 files · 0.8s"));
+		assert.equal(summary.canGroupWith("read"), true);
+		assert.equal(summary.canGroupWith("find"), false);
+		assert.equal(rendered.includes("collapsed tools"), false);
+		assert.equal(rendered.includes("⎯"), false);
+	});
+
+	it("keeps fallback format for unknown tools", () => {
+		const summary = new ToolSummaryLine();
+		summary.addTool("custom_tool", 100);
+
+		const rendered = stripAnsi(summary.render(160).join("\n"));
+		assert.ok(rendered.includes("custom_tool · 0.1s"));
+	});
+
+	it("renders nothing when empty or hidden", () => {
+		const summary = new ToolSummaryLine();
+		assert.deepEqual(summary.render(80), []);
+
+		summary.addTool("grep", 100);
+		summary.setHidden(true);
+		assert.deepEqual(summary.render(80), []);
+	});
+});

package/packages/pi-coding-agent/src/modes/interactive/components/btw-overlay.test.ts

@@ -0,0 +1,172 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import stripAnsi from "strip-ansi";
+import type { Context, Model, SimpleStreamOptions, Message } from "@gsd/pi-ai";
+import type { TUI } from "@gsd/pi-tui";
+import { BtwOverlayComponent } from "./btw-overlay.js";
+import { getMarkdownTheme, initTheme } from "../theme/theme.js";
+
+initTheme();
+
+function makeUi(rows = 40): TUI {
+    return { terminal: { rows } } as unknown as TUI;
+}
+
+function makeModel(): Model<any> {
+    return {
+        id: "test-model",
+        name: "Test Model",
+        api: "openai-completions",
+        provider: "test",
+        baseUrl: "",
+        reasoning: false,
+        input: ["text"],
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow: 4096,
+        maxTokens: 1024,
+    } as unknown as Model<any>;
+}
+
+function makeMessages(): Message[] {
+    return [
+        {
+            role: "user",
+            content: [{ type: "text", text: "hello" }],
+            timestamp: Date.now(),
+        },
+    ];
+}
+
+function renderText(component: BtwOverlayComponent): string {
+    return stripAnsi(component.render(80).join("\n"));
+}
+
+async function flushTurns(count = 3): Promise<void> {
+    for (let i = 0; i < count; i++) {
+        await Promise.resolve();
+        await new Promise((resolve) => setTimeout(resolve, 0));
+    }
+}
+
+test("BtwOverlayComponent renders initial question and placeholder before response", async () => {
+    const component = new BtwOverlayComponent(
+        "What is btw?",
+        makeModel(),
+        "system",
+        makeMessages(),
+        getMarkdownTheme(),
+        makeUi(),
+        () => undefined,
+        () => undefined,
+        () => ({
+            async *[Symbol.asyncIterator]() {
+                await new Promise(() => undefined);
+            },
+        }) as any,
+    );
+
+    await flushTurns();
+    const text = renderText(component);
+    assert.match(text, /btw/);
+    assert.match(text, /You/);
+    assert.match(text, /What is btw\?/);
+    assert.match(text, /Awaiting response/);
+    assert.match(text, /Ask follow-up/);
+    component.dispose();
+});
+
+test("BtwOverlayComponent supports follow-up turns and reuses overlay-local history", async () => {
+    const calls: Array<{ context: Context; options?: SimpleStreamOptions }> = [];
+    const responses = [
+        [
+            { type: "text_delta", delta: "First answer" },
+            { type: "done" },
+        ],
+        [
+            { type: "text_delta", delta: "Second answer" },
+            { type: "done" },
+        ],
+    ];
+
+    const streamFn = ((_: Model<any>, context: Context, options?: SimpleStreamOptions) => {
+        calls.push({ context, options });
+        const response = responses[calls.length - 1] ?? [];
+        return {
+            async *[Symbol.asyncIterator]() {
+                for (const event of response) {
+                    yield event;
+                }
+            },
+        };
+    }) as any;
+
+    const component = new BtwOverlayComponent(
+        "What is btw?",
+        makeModel(),
+        "system",
+        makeMessages(),
+        getMarkdownTheme(),
+        makeUi(),
+        () => undefined,
+        () => undefined,
+        streamFn,
+        { apiKey: "test-key", sessionId: "session-1" },
+    );
+
+    await flushTurns();
+    for (const ch of "next") {
+        component.handleInput(ch);
+    }
+    component.handleInput("\n");
+    await flushTurns();
+
+    assert.equal(calls.length, 2);
+    assert.equal(calls[0]?.options?.apiKey, "test-key");
+    assert.equal(calls[1]?.options?.sessionId, "session-1");
+    assert.equal(calls[0]?.context.messages.length, 2);
+    assert.equal(calls[1]?.context.messages.length, 4);
+    assert.equal(calls[1]?.context.messages[1]?.role, "user");
+    assert.equal(calls[1]?.context.messages[2]?.role, "assistant");
+    assert.deepEqual(calls[1]?.context.messages[3]?.content, [{ type: "text", text: "next" }]);
+
+    const text = renderText(component);
+    assert.match(text, /First answer/);
+    assert.match(text, /Second answer/);
+    component.dispose();
+});
+
+test("BtwOverlayComponent aborts active stream on Escape", async () => {
+    let capturedSignal: AbortSignal | undefined;
+    let dismissed = false;
+    const streamFn = ((_model: any, _context: any, options?: { signal?: AbortSignal }) => {
+        capturedSignal = options?.signal;
+        return {
+            async *[Symbol.asyncIterator]() {
+                await new Promise<void>((resolve) => {
+                    capturedSignal?.addEventListener("abort", () => resolve(), { once: true });
+                });
+            },
+        };
+    }) as any;
+
+    const component = new BtwOverlayComponent(
+        "What is btw?",
+        makeModel(),
+        "system",
+        makeMessages(),
+        getMarkdownTheme(),
+        makeUi(),
+        () => {
+            dismissed = true;
+        },
+        () => undefined,
+        streamFn,
+    );
+
+    await flushTurns();
+    component.handleInput("\u001b");
+    await flushTurns();
+
+    assert.equal(dismissed, true);
+    assert.equal(capturedSignal?.aborted, true);
+});