@oh-my-pi/pi-coding-agent 11.2.3 → 11.3.0

package/src/extensibility/slash-commands.ts

@@ -1,3 +1,48 @@
+export type SlashCommandSource = "extension" | "prompt" | "skill";
+
+export type SlashCommandLocation = "user" | "project" | "path";
+
+export interface SlashCommandInfo {
+	name: string;
+	description?: string;
+	source: SlashCommandSource;
+	location?: SlashCommandLocation;
+	path?: string;
+}
+
+export interface BuiltinSlashCommand {
+	name: string;
+	description: string;
+}
+
+export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
+	{ name: "settings", description: "Open settings menu" },
+	{ name: "plan", description: "Toggle plan mode (agent plans before executing)" },
+	{ name: "model", description: "Select model (opens selector UI)" },
+	{ name: "export", description: "Export session to HTML file" },
+	{ name: "dump", description: "Copy session transcript to clipboard" },
+	{ name: "share", description: "Share session as a secret GitHub gist" },
+	{ name: "browser", description: "Toggle browser headless vs visible mode" },
+	{ name: "copy", description: "Copy last agent message to clipboard" },
+	{ name: "session", description: "Show session info and stats" },
+	{ name: "usage", description: "Show provider usage and limits" },
+	{ name: "changelog", description: "Show changelog entries" },
+	{ name: "hotkeys", description: "Show all keyboard shortcuts" },
+	{ name: "extensions", description: "Open Extension Control Center dashboard" },
+	{ name: "branch", description: "Create a new branch from a previous message" },
+	{ name: "fork", description: "Create a new fork from a previous message" },
+	{ name: "tree", description: "Navigate session tree (switch branches)" },
+	{ name: "login", description: "Login with OAuth provider" },
+	{ name: "logout", description: "Logout from OAuth provider" },
+	{ name: "new", description: "Start a new session" },
+	{ name: "compact", description: "Manually compact the session context" },
+	{ name: "handoff", description: "Hand off session context to a new session" },
+	{ name: "resume", description: "Resume a different session" },
+	{ name: "background", description: "Detach UI and continue running in background" },
+	{ name: "debug", description: "Write debug log (TUI state and messages)" },
+	{ name: "exit", description: "Exit the application" },
+];
+
 import { slashCommandCapability } from "../capability/slash-command";
 import { renderPromptTemplate } from "../config/prompt-templates";
 import type { SlashCommand } from "../discovery";

package/src/index.ts

@@ -62,6 +62,7 @@ export type {
 	MessageRenderer,
 	MessageRenderOptions,
 	RegisteredCommand,
+	ToolCallEvent,
 	ToolResultEvent,
 	TurnEndEvent,
 	TurnStartEvent,
@@ -222,6 +223,7 @@ export {
 	type CustomMessageEntry,
 	type FileEntry,
 	getLatestCompactionEntry,
+	type ModeChangeEntry,
 	type ModelChangeEntry,
 	migrateSessionEntries,
 	type NewSessionOptions,
@@ -238,22 +240,27 @@ export {
 // Tools (detail types and utilities)
 export {
 	type BashToolDetails,
+	type BashToolInput,
 	type BrowserToolDetails,
 	DEFAULT_MAX_BYTES,
 	DEFAULT_MAX_LINES,
 	type FindOperations,
 	type FindToolDetails,
+	type FindToolInput,
 	type FindToolOptions,
 	formatSize,
 	type GrepOperations,
 	type GrepToolDetails,
+	type GrepToolInput,
 	type GrepToolOptions,
 	type PythonToolDetails,
 	type ReadToolDetails,
+	type ReadToolInput,
 	type TruncationOptions,
 	type TruncationResult,
 	truncateHead,
 	truncateLine,
 	truncateTail,
 	type WriteToolDetails,
+	type WriteToolInput,
 } from "./tools";

package/src/lsp/render.ts

@@ -19,7 +19,8 @@ import {
 	TRUNCATE_LENGTHS,
 	truncateToWidth,
 } from "../tools/render-utils";
-import { renderOutputBlock, renderStatusLine } from "../tui";
+import { renderStatusLine } from "../tui";
+import { CachedOutputBlock } from "../tui/output-block";
 import type { LspParams, LspToolDetails } from "./types";
 
 // =============================================================================
@@ -114,43 +115,16 @@ export function renderResult(
 
 	const text = content.text;
 	const lines = text.split("\n");
-	const expanded = options.expanded;
-
-	let label = "Result";
-	let state: "success" | "warning" | "error" = "success";
-	let bodyLines: string[] = [];
 
+	// Static type detection (result content doesn't change between renders)
 	const codeBlockMatch = text.match(/```(\w*)\n([\s\S]*?)```/);
-	if (codeBlockMatch) {
-		label = "Hover";
-		bodyLines = renderHover(codeBlockMatch, text, lines, expanded, theme);
-	} else {
-		const errorMatch = text.match(/(\d+)\s+error\(s\)/);
-		const warningMatch = text.match(/(\d+)\s+warning\(s\)/);
-		if (errorMatch || warningMatch || text.includes(theme.status.error)) {
-			label = "Diagnostics";
-			const errorCount = errorMatch ? Number.parseInt(errorMatch[1], 10) : 0;
-			const warnCount = warningMatch ? Number.parseInt(warningMatch[1], 10) : 0;
-			state = errorCount > 0 ? "error" : warnCount > 0 ? "warning" : "success";
-			bodyLines = renderDiagnostics(errorMatch, warningMatch, lines, expanded, theme);
-		} else {
-			const refMatch = text.match(/(\d+)\s+reference\(s\)/);
-			if (refMatch) {
-				label = "References";
-				bodyLines = renderReferences(refMatch, lines, expanded, theme);
-			} else {
-				const symbolsMatch = text.match(/Symbols in (.+):/);
-				if (symbolsMatch) {
-					label = "Symbols";
-					bodyLines = renderSymbols(symbolsMatch, lines, expanded, theme);
-				} else {
-					label = "Response";
-					bodyLines = renderGeneric(text, lines, expanded, theme);
-				}
-			}
-		}
-	}
+	const errorMatch = text.match(/(\d+)\s+error\(s\)/);
+	const warningMatch = text.match(/(\d+)\s+warning\(s\)/);
+	const refMatch = text.match(/(\d+)\s+reference\(s\)/);
+	const symbolsMatch = text.match(/Symbols in (.+):/);
+	const hasStatusError = text.includes(theme.status.error);
 
+	// Static request info
 	const request = args ?? result.details?.request;
 	const requestLines: string[] = [];
 	if (request?.file) {
@@ -175,14 +149,44 @@ export function renderResult(
 		requestLines.push(theme.fg("dim", `include declaration: ${request.include_declaration ? "true" : "false"}`));
 	}
 
-	const actionLabel = (request?.action ?? result.details?.action ?? label.toLowerCase()).replace(/_/g, " ");
-	const status = options.isPartial ? "running" : result.isError ? "error" : "success";
-	const icon = formatStatusIcon(status, theme, options.spinnerFrame);
-	const header = `${icon} LSP ${actionLabel}`;
+	const outputBlock = new CachedOutputBlock();
 
 	return {
-		render: (width: number) =>
-			renderOutputBlock(
+		render(width: number): string[] {
+			// Read mutable state at render time
+			const { expanded, isPartial, spinnerFrame } = options;
+
+			// Determine label, state, bodyLines based on type + current expanded
+			let label = "Result";
+			let state: "success" | "warning" | "error" = "success";
+			let bodyLines: string[] = [];
+
+			if (codeBlockMatch) {
+				label = "Hover";
+				bodyLines = renderHover(codeBlockMatch, text, lines, expanded, theme);
+			} else if (errorMatch || warningMatch || hasStatusError) {
+				label = "Diagnostics";
+				const errorCount = errorMatch ? Number.parseInt(errorMatch[1], 10) : 0;
+				const warnCount = warningMatch ? Number.parseInt(warningMatch[1], 10) : 0;
+				state = errorCount > 0 ? "error" : warnCount > 0 ? "warning" : "success";
+				bodyLines = renderDiagnostics(errorMatch, warningMatch, lines, expanded, theme);
+			} else if (refMatch) {
+				label = "References";
+				bodyLines = renderReferences(refMatch, lines, expanded, theme);
+			} else if (symbolsMatch) {
+				label = "Symbols";
+				bodyLines = renderSymbols(symbolsMatch, lines, expanded, theme);
+			} else {
+				label = "Response";
+				bodyLines = renderGeneric(text, lines, expanded, theme);
+			}
+
+			const actionLabel = (request?.action ?? result.details?.action ?? label.toLowerCase()).replace(/_/g, " ");
+			const status = isPartial ? "running" : result.isError ? "error" : "success";
+			const icon = formatStatusIcon(status, theme, spinnerFrame);
+			const header = `${icon} LSP ${actionLabel}`;
+
+			return outputBlock.render(
 				{
 					header,
 					state,
@@ -194,8 +198,11 @@ export function renderResult(
 					applyBg: false,
 				},
 				theme,
-			),
-		invalidate: () => {},
+			);
+		},
+		invalidate() {
+			outputBlock.invalidate();
+		},
 	};
 }
 

package/src/lsp/utils.ts

@@ -371,7 +371,7 @@ export function formatTextEdit(edit: TextEdit, maxLength = 50): string {
 	const range = `${edit.range.start.line + 1}:${edit.range.start.character + 1}`;
 	const preview =
 		edit.newText.length > maxLength
-			? `${edit.newText.slice(0, maxLength).replace(/\n/g, "\\n")}...`
+			? `${edit.newText.slice(0, maxLength).replace(/\n/g, "\\n")}…`
 			: edit.newText.replace(/\n/g, "\\n");
 	return `line ${range} ${theme.nav.cursor} "${preview}"`;
 }
@@ -530,7 +530,7 @@ export function extractHoverText(
  */
 export function truncate(str: string, maxLength: number): string {
 	if (str.length <= maxLength) return str;
-	return `${str.slice(0, maxLength - 3)}...`;
+	return `${str.slice(0, maxLength - 1)}…`;
 }
 
 /**

package/src/main.ts

@@ -235,8 +235,8 @@ async function createSessionManager(parsed: Args, cwd: string): Promise<SessionM
 	if (parsed.noSession) {
 		return SessionManager.inMemory();
 	}
-	if (parsed.session) {
-		const sessionArg = parsed.session;
+	if (typeof parsed.resume === "string") {
+		const sessionArg = parsed.resume;
 		if (sessionArg.includes("/") || sessionArg.includes("\\") || sessionArg.endsWith(".jsonl")) {
 			return await SessionManager.open(sessionArg, parsed.sessionDir);
 		}
@@ -258,7 +258,7 @@ async function createSessionManager(parsed: Args, cwd: string): Promise<SessionM
 	if (parsed.continue) {
 		return await SessionManager.continueRecent(cwd, parsed.sessionDir);
 	}
-	// --resume is handled separately (needs picker UI)
+	// --resume without value is handled separately (needs picker UI)
 	// If --session-dir provided without --continue/--resume, create new session there
 	if (parsed.sessionDir) {
 		return SessionManager.create(cwd, parsed.sessionDir);
@@ -495,26 +495,27 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 
 	if (parsedArgs.version) {
 		writeStdout(VERSION);
-		return;
+		process.exit(0);
 	}
 
 	if (parsedArgs.listModels !== undefined) {
 		const searchPattern = typeof parsedArgs.listModels === "string" ? parsedArgs.listModels : undefined;
 		await listModels(modelRegistry, searchPattern);
-		return;
+		process.exit(0);
 	}
 
 	if (parsedArgs.export) {
+		let result: string;
 		try {
 			const outputPath = parsedArgs.messages.length > 0 ? parsedArgs.messages[0] : undefined;
-			const result = await exportFromFile(parsedArgs.export, outputPath);
-			writeStdout(`Exported to: ${result}`);
-			return;
+			result = await exportFromFile(parsedArgs.export, outputPath);
 		} catch (error: unknown) {
 			const message = error instanceof Error ? error.message : "Failed to export session";
 			writeStderr(chalk.red(`Error: ${message}`));
 			process.exit(1);
 		}
+		writeStdout(`Exported to: ${result}`);
+		process.exit(0);
 	}
 
 	if (parsedArgs.mode === "rpc" && parsedArgs.fileArgs.length > 0) {
@@ -571,8 +572,8 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 	debugStartup("main:createSessionManager");
 	time("createSessionManager");
 
-	// Handle --resume: show session picker
-	if (parsedArgs.resume) {
+	// Handle --resume (no value): show session picker
+	if (parsedArgs.resume === true) {
 		const sessions = await SessionManager.list(cwd, parsedArgs.sessionDir);
 		time("SessionManager.list");
 		if (sessions.length === 0) {

package/src/mcp/transports/stdio.ts

@@ -5,7 +5,7 @@
  * Messages are newline-delimited JSON.
  */
 
-import { readLines } from "@oh-my-pi/pi-utils";
+import { readJsonl } from "@oh-my-pi/pi-utils";
 import { type Subprocess, spawn } from "bun";
 import type { JsonRpcResponse, MCPStdioServerConfig, MCPTransport } from "../../mcp/types";
 
@@ -72,13 +72,11 @@ export class StdioTransport implements MCPTransport {
 
 	private async startReadLoop(): Promise<void> {
 		if (!this.process?.stdout) return;
-
-		const decoder = new TextDecoder();
 		try {
-			for await (const line of readLines(this.process.stdout)) {
+			for await (const line of readJsonl(this.process.stdout)) {
 				if (!this._connected) break;
 				try {
-					this.handleMessage(JSON.parse(decoder.decode(line)) as JsonRpcResponse);
+					this.handleMessage(line as JsonRpcResponse);
 				} catch {
 					// Skip malformed lines
 				}

package/src/modes/components/custom-message.ts

@@ -82,14 +82,6 @@ export class CustomMessageComponent extends Container {
 				.join("\n");
 		}
 
-		// Limit lines when collapsed
-		if (!this._expanded) {
-			const lines = text.split("\n");
-			if (lines.length > 5) {
-				text = `${lines.slice(0, 5).join("\n")}\n…`;
-			}
-		}
-
 		this.box.addChild(
 			new Markdown(text, 0, 0, getMarkdownTheme(), {
 				color: (value: string) => theme.fg("customMessageText", value),

package/src/modes/components/diff.ts

@@ -1,5 +1,6 @@
 import * as Diff from "diff";
 import { theme } from "../../modes/theme/theme";
+import { replaceTabs } from "../../tools/render-utils";
 
 /**
  * Parse diff line to extract prefix, line number, and content.
@@ -11,13 +12,6 @@ function parseDiffLine(line: string): { prefix: string; lineNum: string; content
 	return { prefix: match[1], lineNum: match[2] ?? "", content: match[3] };
 }
 
-/**
- * Replace tabs with spaces for consistent rendering.
- */
-function replaceTabs(text: string): string {
-	return text.replace(/\t/g, "   ");
-}
-
 /**
  * Compute word-level diff and render with inverse on changed parts.
  * Uses diffWords which groups whitespace with adjacent words for cleaner highlighting.

package/src/modes/components/footer.ts

@@ -211,11 +211,11 @@ export class FooterComponent implements Component {
 
 		// Truncate path if too long to fit width
 		if (pwd.length > width) {
-			const half = Math.floor(width / 2) - 2;
-			if (half > 0) {
+			const half = Math.floor(width / 2) - 1;
+			if (half > 1) {
 				const start = pwd.slice(0, half);
 				const end = pwd.slice(-(half - 1));
-				pwd = `${start}...${end}`;
+				pwd = `${start}…${end}`;
 			} else {
 				pwd = pwd.slice(0, Math.max(1, width));
 			}
@@ -269,7 +269,7 @@ export class FooterComponent implements Component {
 		if (statsLeftWidth > width) {
 			// Truncate statsLeft to fit width (no room for right side)
 			const plainStatsLeft = statsLeft.replace(/\x1b\[[0-9;]*m/g, "");
-			statsLeft = `${plainStatsLeft.substring(0, width - 3)}...`;
+			statsLeft = `${plainStatsLeft.substring(0, width - 1)}…`;
 			statsLeftWidth = visibleWidth(statsLeft);
 		}
 

package/src/modes/components/model-selector.ts

@@ -398,6 +398,10 @@ export class ModelSelectorComponent extends Container {
 			}
 		} else if (this.filteredModels.length === 0) {
 			this.listContainer.addChild(new Text(theme.fg("muted", "  No matching models"), 0, 0));
+		} else {
+			const selected = this.filteredModels[this.selectedIndex];
+			this.listContainer.addChild(new Spacer(1));
+			this.listContainer.addChild(new Text(theme.fg("muted", `  Model Name: ${selected.model.name}`), 0, 0));
 		}
 	}
 

package/src/modes/components/todo-display.ts

@@ -1,8 +1,9 @@
 import * as path from "node:path";
-import { Text } from "@oh-my-pi/pi-tui";
+import { Ellipsis, Text, truncateToWidth } from "@oh-my-pi/pi-tui";
 import { logger } from "@oh-my-pi/pi-utils";
 import { theme } from "../../modes/theme/theme";
 import type { TodoItem } from "../../modes/types";
+import { Hasher, type RenderCache } from "../../tui";
 
 const TODO_FILE_NAME = "todos.json";
 
@@ -29,6 +30,7 @@ export class TodoDisplayComponent {
 	public todos: TodoItem[] = [];
 	private expanded = false;
 	private visible = false;
+	private cached: RenderCache | undefined;
 
 	constructor(private readonly sessionFile: string | null) {}
 
@@ -44,26 +46,32 @@ export class TodoDisplayComponent {
 		const data = await loadTodoFile(todoPath);
 		this.todos = data?.todos ?? [];
 		this.visible = this.todos.length > 0;
+		this.cached = undefined;
 	}
 
 	setTodos(todos: TodoItem[]): void {
 		this.todos = todos;
 		this.visible = this.todos.length > 0;
+		this.cached = undefined;
 	}
 
 	setExpanded(expanded: boolean): void {
 		this.expanded = expanded;
+		this.cached = undefined;
 	}
 
 	isVisible(): boolean {
 		return this.visible;
 	}
 
-	render(_width: number): string[] {
+	render(width: number): string[] {
 		if (!this.visible || this.todos.length === 0) {
 			return [];
 		}
 
+		const key = new Hasher().bool(this.expanded).u32(width).digest();
+		if (this.cached?.key === key) return this.cached.lines;
+
 		const lines: string[] = [];
 		const maxItems = this.expanded ? this.todos.length : Math.min(5, this.todos.length);
 		const hasMore = !this.expanded && this.todos.length > 5;
@@ -93,7 +101,9 @@ export class TodoDisplayComponent {
 			lines.push(theme.fg("dim", `        ${theme.tree.hook} +${this.todos.length - 5} more (Ctrl+T to expand)`));
 		}
 
-		return lines;
+		const result = lines.map(l => truncateToWidth(l, width, Ellipsis.Omit));
+		this.cached = { key, lines: result };
+		return result;
 	}
 
 	getRenderedComponent(): Text | null {

package/src/modes/components/tool-execution.ts

@@ -12,7 +12,7 @@ import {
 	Text,
 	type TUI,
 } from "@oh-my-pi/pi-tui";
-import { sanitizeText } from "@oh-my-pi/pi-utils";
+import { logger, sanitizeText } from "@oh-my-pi/pi-utils";
 import type { Theme } from "../../modes/theme/theme";
 import { theme } from "../../modes/theme/theme";
 import { computeEditDiff, computePatchDiff, type EditDiffError, type EditDiffResult } from "../../patch";
@@ -89,6 +89,16 @@ export class ToolExecutionComponent extends Container {
 	private spinnerInterval: ReturnType<typeof setInterval> | null = null;
 	// Track if args are still being streamed (for edit/write spinner)
 	private argsComplete = false;
+	private renderState: {
+		spinnerFrame: number;
+		expanded: boolean;
+		isPartial: boolean;
+		renderContext?: Record<string, unknown>;
+	} = {
+		spinnerFrame: 0,
+		expanded: false,
+		isPartial: true,
+	};
 
 	constructor(
 		toolName: string,
@@ -280,8 +290,9 @@ export class ToolExecutionComponent extends Container {
 				const frameCount = theme.spinnerFrames.length;
 				if (frameCount === 0) return;
 				this.spinnerFrame = (this.spinnerFrame + 1) % frameCount;
-				this.updateDisplay();
+				this.renderState.spinnerFrame = this.spinnerFrame;
 				this.ui.requestRender();
+				// NO updateDisplay() — existing component closures read from renderState
 			}, 80);
 		} else if (!needsSpinner && this.spinnerInterval) {
 			clearInterval(this.spinnerInterval);
@@ -322,6 +333,11 @@ export class ToolExecutionComponent extends Container {
 				? (text: string) => theme.bg("toolErrorBg", text)
 				: (text: string) => theme.bg("toolSuccessBg", text);
 
+		// Sync shared mutable render state for component closures
+		this.renderState.expanded = this.expanded;
+		this.renderState.isPartial = this.isPartial;
+		this.renderState.spinnerFrame = this.spinnerFrame;
+
 		// Check for custom tool rendering
 		if (this.tool && (this.tool.renderCall || this.tool.renderResult)) {
 			const tool = this.tool;
@@ -344,7 +360,8 @@ export class ToolExecutionComponent extends Container {
 						}
 						this.contentBox.addChild(component);
 					}
-				} catch {
+				} catch (err) {
+					logger.warn("Tool renderer failed", { tool: this.toolName, error: String(err) });
 					// Fall back to default on error
 					this.contentBox.addChild(new Text(theme.fg("toolTitle", theme.bold(this.toolLabel)), 0, 0));
 				}
@@ -364,7 +381,7 @@ export class ToolExecutionComponent extends Container {
 					) => Component;
 					const resultComponent = renderResult(
 						{ content: this.result.content as any, details: this.result.details, isError: this.result.isError },
-						{ expanded: this.expanded, isPartial: this.isPartial, spinnerFrame: this.spinnerFrame },
+						this.renderState,
 						theme,
 						this.args,
 					);
@@ -376,7 +393,8 @@ export class ToolExecutionComponent extends Container {
 						}
 						this.contentBox.addChild(component);
 					}
-				} catch {
+				} catch (err) {
+					logger.warn("Tool renderer failed", { tool: this.toolName, error: String(err) });
 					// Fall back to showing raw output on error
 					const output = this.getTextOutput();
 					if (output) {
@@ -401,9 +419,7 @@ export class ToolExecutionComponent extends Container {
 			if (shouldRenderCall) {
 				// Render call component
 				try {
-					const callComponent = renderer.renderCall(this.args, theme, {
-						spinnerFrame: this.spinnerFrame,
-					});
+					const callComponent = renderer.renderCall(this.args, theme, this.renderState);
 					if (callComponent) {
 						// Ensure component has invalidate() method for Component interface
 						const component = callComponent as any;
@@ -412,7 +428,8 @@ export class ToolExecutionComponent extends Container {
 						}
 						this.contentBox.addChild(component);
 					}
-				} catch {
+				} catch (err) {
+					logger.warn("Tool renderer failed", { tool: this.toolName, error: String(err) });
 					// Fall back to default on error
 					this.contentBox.addChild(new Text(theme.fg("toolTitle", theme.bold(this.toolLabel)), 0, 0));
 				}
@@ -423,15 +440,11 @@ export class ToolExecutionComponent extends Container {
 				try {
 					// Build render context for tools that need extra state
 					const renderContext = this.buildRenderContext();
+					this.renderState.renderContext = renderContext;
 
 					const resultComponent = renderer.renderResult(
 						{ content: this.result.content as any, details: this.result.details, isError: this.result.isError },
-						{
-							expanded: this.expanded,
-							isPartial: this.isPartial,
-							spinnerFrame: this.spinnerFrame,
-							renderContext,
-						},
+						this.renderState,
 						theme,
 						this.args, // Pass args for tools that need them
 					);
@@ -443,7 +456,8 @@ export class ToolExecutionComponent extends Container {
 						}
 						this.contentBox.addChild(component);
 					}
-				} catch {
+				} catch (err) {
+					logger.warn("Tool renderer failed", { tool: this.toolName, error: String(err) });
 					// Fall back to showing raw output on error
 					const output = this.getTextOutput();
 					if (output) {