@oh-my-pi/pi-coding-agent 11.0.3 → 11.2.0

package/src/lsp/index.ts

@@ -50,6 +50,7 @@ import {
 	formatLocation,
 	formatSymbolInformation,
 	formatWorkspaceEdit,
+	sortDiagnostics,
 	symbolKindToIcon,
 } from "./utils";
 
@@ -458,6 +459,7 @@ async function getDiagnosticsForFile(
 		}
 	}
 
+	sortDiagnostics(uniqueDiagnostics);
 	const formatted = uniqueDiagnostics.map(d => formatDiagnostic(d, relPath));
 	const limited = limitDiagnosticMessages(formatted);
 	const summary = formatDiagnosticsSummary(uniqueDiagnostics);
@@ -858,10 +860,7 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 	public readonly mergeCallAndResult = true;
 	public readonly inline = true;
 
-	private readonly session: ToolSession;
-
-	constructor(session: ToolSession) {
-		this.session = session;
+	constructor(private readonly session: ToolSession) {
 		this.description = renderPromptTemplate(lspDescription);
 	}
 
@@ -966,6 +965,8 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 					}
 				}
 
+				sortDiagnostics(uniqueDiagnostics);
+
 				if (!detailed && targets.length === 1) {
 					if (uniqueDiagnostics.length === 0) {
 						return {

package/src/lsp/utils.ts

@@ -205,6 +205,24 @@ export function severityToString(severity?: DiagnosticSeverity): string {
 	return SEVERITY_NAMES[severity ?? 1] ?? "unknown";
 }
 
+/**
+ * Sort diagnostics by severity, then by location and message.
+ */
+export function sortDiagnostics(diagnostics: Diagnostic[]): Diagnostic[] {
+	return diagnostics.sort((a, b) => {
+		const aSeverity = a.severity ?? 1;
+		const bSeverity = b.severity ?? 1;
+		if (aSeverity !== bSeverity) return aSeverity - bSeverity;
+		const aLine = a.range.start.line;
+		const bLine = b.range.start.line;
+		if (aLine !== bLine) return aLine - bLine;
+		const aCol = a.range.start.character;
+		const bCol = b.range.start.character;
+		if (aCol !== bCol) return aCol - bCol;
+		return a.message.localeCompare(b.message);
+	});
+}
+
 /**
  * Get icon for diagnostic severity.
  */

package/src/main.ts

@@ -8,34 +8,24 @@ import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import { createInterface } from "node:readline/promises";
+import { run } from "@oclif/core";
 import { type ImageContent, supportsXhigh } from "@oh-my-pi/pi-ai";
 import { $env, postmortem } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
-import { type Args, parseArgs, printHelp } from "./cli/args";
-import { parseConfigArgs, printConfigHelp, runConfigCommand } from "./cli/config-cli";
+import type { Args } from "./cli/args";
 import { processFileArguments } from "./cli/file-processor";
-import { parseGrepArgs, printGrepHelp, runGrepCommand } from "./cli/grep-cli";
-import { parseJupyterArgs, printJupyterHelp, runJupyterCommand } from "./cli/jupyter-cli";
 import { listModels } from "./cli/list-models";
-import { parsePluginArgs, printPluginHelp, runPluginCommand } from "./cli/plugin-cli";
 import { selectSession } from "./cli/session-picker";
-import { parseSetupArgs, printSetupHelp, runSetupCommand } from "./cli/setup-cli";
-import { parseShellArgs, printShellHelp, runShellCommand } from "./cli/shell-cli";
-import { parseStatsArgs, printStatsHelp, runStatsCommand } from "./cli/stats-cli";
-import { parseUpdateArgs, printUpdateHelp, runUpdateCommand } from "./cli/update-cli";
-import { runCommitCommand } from "./commit";
-import { parseCommitArgs, printCommitHelp } from "./commit/cli";
-import { findConfigFile, getModelsPath, VERSION } from "./config";
-import type { ModelRegistry } from "./config/model-registry";
+import { findConfigFile, VERSION } from "./config";
+import { ModelRegistry, ModelsConfigFile } from "./config/model-registry";
 import { parseModelPattern, parseModelString, resolveModelScope, type ScopedModel } from "./config/model-resolver";
 import { Settings, settings } from "./config/settings";
 import { initializeWithSettings } from "./discovery";
 import { exportFromFile } from "./export/html";
 import type { ExtensionUIContext } from "./extensibility/extensions/types";
-import { runMigrations, showDeprecationWarnings } from "./migrations";
 import { InteractiveMode, runPrintMode, runRpcMode } from "./modes";
 import { initTheme, stopThemeWatcher } from "./modes/theme/theme";
-import { type CreateAgentSessionOptions, createAgentSession, discoverAuthStorage, discoverModels } from "./sdk";
+import { type CreateAgentSessionOptions, createAgentSession, discoverAuthStorage } from "./sdk";
 import type { AgentSession } from "./session/agent-session";
 import { type SessionInfo, SessionManager } from "./session/session-manager";
 import { resolvePromptInput } from "./system-prompt";
@@ -82,13 +72,16 @@ async function readPipedInput(): Promise<string | undefined> {
 	}
 }
 
+export interface InteractiveModeNotify {
+	kind: "warn" | "error" | "info";
+	message: string;
+}
+
 async function runInteractiveMode(
 	session: AgentSession,
 	version: string,
 	changelogMarkdown: string | undefined,
-	modelFallbackMessage: string | undefined,
-	modelsJsonError: string | undefined,
-	migratedProviders: string[],
+	notifs: (InteractiveModeNotify | null)[],
 	versionCheckPromise: Promise<string | undefined>,
 	initialMessages: string[],
 	setExtensionUIContext: (uiContext: ExtensionUIContext, hasUI: boolean) => void,
@@ -111,16 +104,17 @@ async function runInteractiveMode(
 
 	mode.renderInitialMessages();
 
-	if (migratedProviders.length > 0) {
-		mode.showWarning(`Migrated credentials to agent.db: ${migratedProviders.join(", ")}`);
-	}
-
-	if (modelsJsonError) {
-		mode.showError(`models.json error: ${modelsJsonError}`);
-	}
-
-	if (modelFallbackMessage) {
-		mode.showWarning(modelFallbackMessage);
+	for (const notify of notifs) {
+		if (!notify) {
+			continue;
+		}
+		if (notify.kind === "warn") {
+			mode.showWarning(notify.message);
+		} else if (notify.kind === "error") {
+			mode.showError(notify.message);
+		} else if (notify.kind === "info") {
+			mode.showStatus(notify.message);
+		}
 	}
 
 	if (initialMessage) {
@@ -477,7 +471,7 @@ async function buildSessionOptions(
 	return options;
 }
 
-export async function main(args: string[]) {
+export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<void> {
 	time("start");
 	debugStartup("main:entry");
 
@@ -486,140 +480,34 @@ export async function main(args: string[]) {
 	await initTheme();
 	debugStartup("main:initTheme");
 
-	// Handle plugin subcommand before regular parsing
-	const pluginCmd = parsePluginArgs(args);
-	if (pluginCmd) {
-		if (args.includes("--help") || args.includes("-h")) {
-			printPluginHelp();
-			return;
-		}
-		await runPluginCommand(pluginCmd);
-		return;
-	}
-
-	// Handle update subcommand
-	const updateCmd = parseUpdateArgs(args);
-	if (updateCmd) {
-		if (args.includes("--help") || args.includes("-h")) {
-			printUpdateHelp();
-			return;
-		}
-		await runUpdateCommand(updateCmd);
-		return;
-	}
-
-	// Handle config subcommand
-	const configCmd = parseConfigArgs(args);
-	if (configCmd) {
-		if (args.includes("--help") || args.includes("-h")) {
-			printConfigHelp();
-			return;
-		}
-		await runConfigCommand(configCmd);
-		return;
-	}
-
-	// Handle setup subcommand
-	const setupCmd = parseSetupArgs(args);
-	if (setupCmd) {
-		if (args.includes("--help") || args.includes("-h")) {
-			printSetupHelp();
-			return;
-		}
-		await runSetupCommand(setupCmd);
-		return;
-	}
-
-	// Handle jupyter subcommand
-	const jupyterCmd = parseJupyterArgs(args);
-	if (jupyterCmd) {
-		if (args.includes("--help") || args.includes("-h")) {
-			printJupyterHelp();
-			return;
-		}
-		await runJupyterCommand(jupyterCmd);
-		return;
-	}
-
-	// Handle stats subcommand
-	const statsCmd = parseStatsArgs(args);
-	if (statsCmd) {
-		if (args.includes("--help") || args.includes("-h")) {
-			printStatsHelp();
-			return;
-		}
-		await runStatsCommand(statsCmd);
-		return;
-	}
-
-	// Handle grep subcommand (for testing grep tool)
-	const grepCmd = parseGrepArgs(args);
-	if (grepCmd) {
-		if (args.includes("--help") || args.includes("-h")) {
-			printGrepHelp();
-			return;
-		}
-		await runGrepCommand(grepCmd);
-		return;
-	}
-
-	// Handle shell subcommand (for testing brush-core shell)
-	const shellCmd = parseShellArgs(args);
-	if (shellCmd) {
-		if (args.includes("--help") || args.includes("-h")) {
-			printShellHelp();
-			return;
-		}
-		await runShellCommand(shellCmd);
-		return;
-	}
-
-	// Handle commit subcommand
-	const commitCmd = parseCommitArgs(args);
-	if (commitCmd) {
-		if (args.includes("--help") || args.includes("-h")) {
-			printCommitHelp();
-			return;
-		}
-		await runCommitCommand(commitCmd);
-		process.exit(0);
-	}
-
-	const parsed = parseArgs(args);
+	const parsedArgs = parsed;
 	debugStartup("main:parseArgs");
 	time("parseArgs");
-	await maybeAutoChdir(parsed);
+	await maybeAutoChdir(parsedArgs);
 
-	// Run migrations (pass cwd for project-local migrations)
-	const { migratedAuthProviders: migratedProviders, deprecationWarnings } = await runMigrations(process.cwd());
-	debugStartup("main:runMigrations");
+	const notifs: (InteractiveModeNotify | null)[] = [];
 
 	// Create AuthStorage and ModelRegistry upfront
 	const authStorage = await discoverAuthStorage();
-	const modelRegistry = discoverModels(authStorage);
+	const modelRegistry = new ModelRegistry(authStorage);
 	debugStartup("main:discoverModels");
 	time("discoverModels");
 
-	if (parsed.version) {
+	if (parsedArgs.version) {
 		writeStdout(VERSION);
 		return;
 	}
 
-	if (parsed.help) {
-		printHelp();
-		return;
-	}
-
-	if (parsed.listModels !== undefined) {
-		const searchPattern = typeof parsed.listModels === "string" ? parsed.listModels : undefined;
+	if (parsedArgs.listModels !== undefined) {
+		const searchPattern = typeof parsedArgs.listModels === "string" ? parsedArgs.listModels : undefined;
 		await listModels(modelRegistry, searchPattern);
 		return;
 	}
 
-	if (parsed.export) {
+	if (parsedArgs.export) {
 		try {
-			const outputPath = parsed.messages.length > 0 ? parsed.messages[0] : undefined;
-			const result = await exportFromFile(parsed.export, outputPath);
+			const outputPath = parsedArgs.messages.length > 0 ? parsedArgs.messages[0] : undefined;
+			const result = await exportFromFile(parsedArgs.export, outputPath);
 			writeStdout(`Exported to: ${result}`);
 			return;
 		} catch (error: unknown) {
@@ -629,7 +517,7 @@ export async function main(args: string[]) {
 		}
 	}
 
-	if (parsed.mode === "rpc" && parsed.fileArgs.length > 0) {
+	if (parsedArgs.mode === "rpc" && parsedArgs.fileArgs.length > 0) {
 		writeStderr(chalk.red("Error: @file arguments are not supported in RPC mode"));
 		process.exit(1);
 	}
@@ -639,23 +527,23 @@ export async function main(args: string[]) {
 	debugStartup("main:Settings.init");
 	time("Settings.init");
 	const pipedInput = await readPipedInput();
-	let { initialMessage, initialImages } = await prepareInitialMessage(parsed, settings.get("images.autoResize"));
+	let { initialMessage, initialImages } = await prepareInitialMessage(parsedArgs, settings.get("images.autoResize"));
 	if (pipedInput) {
 		initialMessage = initialMessage ? `${initialMessage}\n${pipedInput}` : pipedInput;
 	}
 	time("prepareInitialMessage");
-	const autoPrint = pipedInput !== undefined && !parsed.print && parsed.mode === undefined;
-	const isInteractive = !parsed.print && !autoPrint && parsed.mode === undefined;
-	const mode = parsed.mode || "text";
+	const autoPrint = pipedInput !== undefined && !parsedArgs.print && parsedArgs.mode === undefined;
+	const isInteractive = !parsedArgs.print && !autoPrint && parsedArgs.mode === undefined;
+	const mode = parsedArgs.mode || "text";
 
 	// Initialize discovery system with settings for provider persistence
 	initializeWithSettings(settings);
 	time("initializeWithSettings");
 
 	// Apply model role overrides from CLI args or env vars (ephemeral, not persisted)
-	const smolModel = parsed.smol ?? $env.PI_SMOL_MODEL;
-	const slowModel = parsed.slow ?? $env.PI_SLOW_MODEL;
-	const planModel = parsed.plan ?? $env.PI_PLAN_MODEL;
+	const smolModel = parsedArgs.smol ?? $env.PI_SMOL_MODEL;
+	const slowModel = parsedArgs.slow ?? $env.PI_SLOW_MODEL;
+	const planModel = parsedArgs.plan ?? $env.PI_PLAN_MODEL;
 	if (smolModel || slowModel || planModel) {
 		settings.overrideModelRoles({
 			smol: smolModel,
@@ -668,13 +556,8 @@ export async function main(args: string[]) {
 	debugStartup("main:initTheme2");
 	time("initTheme");
 
-	// Show deprecation warnings in interactive mode
-	if (isInteractive && deprecationWarnings.length > 0) {
-		await showDeprecationWarnings(deprecationWarnings);
-	}
-
 	let scopedModels: ScopedModel[] = [];
-	const modelPatterns = parsed.models ?? settings.get("enabledModels");
+	const modelPatterns = parsedArgs.models ?? settings.get("enabledModels");
 	const modelMatchPreferences = {
 		usageOrder: settings.getStorage()?.getModelUsageOrder(),
 	};
@@ -684,13 +567,13 @@ export async function main(args: string[]) {
 	}
 
 	// Create session manager based on CLI flags
-	let sessionManager = await createSessionManager(parsed, cwd);
+	let sessionManager = await createSessionManager(parsedArgs, cwd);
 	debugStartup("main:createSessionManager");
 	time("createSessionManager");
 
 	// Handle --resume: show session picker
-	if (parsed.resume) {
-		const sessions = await SessionManager.list(cwd, parsed.sessionDir);
+	if (parsedArgs.resume) {
+		const sessions = await SessionManager.list(cwd, parsedArgs.sessionDir);
 		time("SessionManager.list");
 		if (sessions.length === 0) {
 			writeStdout(chalk.dim("No sessions found"));
@@ -705,19 +588,19 @@ export async function main(args: string[]) {
 		sessionManager = await SessionManager.open(selectedPath);
 	}
 
-	const sessionOptions = await buildSessionOptions(parsed, scopedModels, sessionManager, modelRegistry);
+	const sessionOptions = await buildSessionOptions(parsedArgs, scopedModels, sessionManager, modelRegistry);
 	debugStartup("main:buildSessionOptions");
 	sessionOptions.authStorage = authStorage;
 	sessionOptions.modelRegistry = modelRegistry;
 	sessionOptions.hasUI = isInteractive;
 
 	// Handle CLI --api-key as runtime override (not persisted)
-	if (parsed.apiKey) {
+	if (parsedArgs.apiKey) {
 		if (!sessionOptions.model) {
 			writeStderr(chalk.red("--api-key requires a model to be specified via --provider/--model or -m/--models"));
 			process.exit(1);
 		}
-		authStorage.setRuntimeApiKey(sessionOptions.model.provider, parsed.apiKey);
+		authStorage.setRuntimeApiKey(sessionOptions.model.provider, parsedArgs.apiKey);
 	}
 
 	time("buildSessionOptions");
@@ -726,17 +609,36 @@ export async function main(args: string[]) {
 	debugStartup("main:createAgentSession");
 	time("createAgentSession");
 
+	if (modelFallbackMessage) {
+		notifs.push({ kind: "warn", message: modelFallbackMessage });
+	}
+
+	const modelRegistryError = modelRegistry.getError();
+	if (modelRegistryError) {
+		notifs.push({ kind: "error", message: modelRegistryError.message });
+	}
+
 	// Re-parse CLI args with extension flags and apply values
 	if (session.extensionRunner) {
 		const extFlags = session.extensionRunner.getFlags();
 		if (extFlags.size > 0) {
-			const flagDefs = new Map<string, { type: "boolean" | "string" }>();
-			for (const [name, flag] of extFlags) {
-				flagDefs.set(name, { type: flag.type });
-			}
-			const reparsed = parseArgs(args, flagDefs);
-			for (const [name, value] of reparsed.unknownFlags) {
-				session.extensionRunner.setFlagValue(name, value);
+			for (let i = 0; i < rawArgs.length; i++) {
+				const arg = rawArgs[i];
+				if (!arg.startsWith("--")) {
+					continue;
+				}
+				const flagName = arg.slice(2);
+				const extFlag = extFlags.get(flagName);
+				if (!extFlag) {
+					continue;
+				}
+				if (extFlag.type === "boolean") {
+					session.extensionRunner.setFlagValue(flagName, true);
+					continue;
+				}
+				if (i + 1 < rawArgs.length) {
+					session.extensionRunner.setFlagValue(flagName, rawArgs[++i]);
+				}
 			}
 		}
 	}
@@ -747,13 +649,13 @@ export async function main(args: string[]) {
 		writeStderr(chalk.red("No models available."));
 		writeStderr(chalk.yellow("\nSet an API key environment variable:"));
 		writeStderr("  ANTHROPIC_API_KEY, OPENAI_API_KEY, GEMINI_API_KEY, etc.");
-		writeStderr(chalk.yellow(`\nOr create ${getModelsPath()}`));
+		writeStderr(chalk.yellow(`\nOr create ${ModelsConfigFile.path()}`));
 		process.exit(1);
 	}
 
 	// Clamp thinking level to model capabilities (for CLI override case)
-	if (session.model && parsed.thinking) {
-		let effectiveThinking = parsed.thinking;
+	if (session.model && parsedArgs.thinking) {
+		let effectiveThinking = parsedArgs.thinking;
 		if (!session.model.reasoning) {
 			effectiveThinking = "off";
 		} else if (effectiveThinking === "xhigh" && !supportsXhigh(session.model)) {
@@ -768,7 +670,7 @@ export async function main(args: string[]) {
 		await runRpcMode(session);
 	} else if (isInteractive) {
 		const versionCheckPromise = checkForNewVersion(VERSION).catch(() => undefined);
-		const changelogMarkdown = await getChangelogForDisplay(parsed);
+		const changelogMarkdown = await getChangelogForDisplay(parsedArgs);
 
 		const scopedModelsForDisplay = sessionOptions.scopedModels ?? scopedModels;
 		if (scopedModelsForDisplay.length > 0) {
@@ -787,11 +689,9 @@ export async function main(args: string[]) {
 			session,
 			VERSION,
 			changelogMarkdown,
-			modelFallbackMessage,
-			modelRegistry.getError(),
-			migratedProviders,
+			notifs,
 			versionCheckPromise,
-			parsed.messages,
+			parsedArgs.messages,
 			setToolUIContext,
 			lspServers,
 			mcpManager,
@@ -801,7 +701,7 @@ export async function main(args: string[]) {
 	} else {
 		await runPrintMode(session, {
 			mode,
-			messages: parsed.messages,
+			messages: parsedArgs.messages,
 			initialMessage,
 			initialImages,
 		});
@@ -810,3 +710,8 @@ export async function main(args: string[]) {
 		await postmortem.quit(0);
 	}
 }
+
+export async function main(args: string[]): Promise<void> {
+	const argv = args.length === 0 ? ["index"] : args;
+	await run(argv, import.meta.url);
+}

package/src/mcp/json-rpc.ts

@@ -13,8 +13,8 @@ export function parseSSE(text: string): unknown {
 		if (line.startsWith("data: ")) {
 			const data = line.slice(6).trim();
 			if (data === "[DONE]") continue;
-			const result = Bun.JSONL.parseChunk(`${data}\n`);
-			if (result.values.length > 0) return result.values[0];
+			const result = JSON.parse(data) as unknown;
+			if (result) return result;
 		}
 	}
 	// Fallback: try parsing entire response as JSON

package/src/mcp/transports/http.ts

@@ -4,7 +4,7 @@
  * Implements JSON-RPC 2.0 over HTTP POST with optional SSE streaming.
  * Based on MCP spec 2025-03-26.
  */
-import { readSseEvents } from "@oh-my-pi/pi-utils";
+import { readSseJson } from "@oh-my-pi/pi-utils";
 import type {
 	JsonRpcMessage,
 	JsonRpcResponse,
@@ -86,26 +86,11 @@ export class HttpTransport implements MCPTransport {
 				return;
 			}
 
-			let buffer = "";
 			// Read SSE stream
-			for await (const event of readSseEvents(response.body)) {
+			for await (const message of readSseJson<JsonRpcMessage>(response.body, this.sseConnection.signal)) {
 				if (!this._connected) break;
-				const data = event.data?.trim();
-				if (!data || data === "[DONE]") continue;
-				buffer += data;
-				if (!data.endsWith("\n")) {
-					buffer += "\n";
-				}
-				const result = Bun.JSONL.parseChunk(buffer);
-				buffer = buffer.slice(result.read);
-				if (result.error) {
-					buffer = "";
-					continue;
-				}
-				for (const message of result.values as JsonRpcMessage[]) {
-					if ("method" in message && !("id" in message)) {
-						this.onNotification?.(message.method, message.params);
-					}
+				if ("method" in message && !("id" in message)) {
+					this.onNotification?.(message.method, message.params);
 				}
 			}
 		} catch (error) {
@@ -182,40 +167,18 @@ export class HttpTransport implements MCPTransport {
 		const timeout = this.config.timeout ?? 30000;
 
 		const parse = async (): Promise<T> => {
-			let buffer = "";
-			for await (const event of readSseEvents(response.body!)) {
-				const data = event.data?.trim();
-				if (!data || data === "[DONE]") continue;
-				buffer += data;
-				if (!data.endsWith("\n")) {
-					buffer += "\n";
-				}
-				const result = Bun.JSONL.parseChunk(buffer);
-				buffer = buffer.slice(result.read);
-				if (result.error) {
-					buffer = "";
-					continue;
-				}
-
-				for (const message of result.values as JsonRpcMessage[]) {
-					if (
-						"id" in message &&
-						(message as JsonRpcResponse).id === expectedId &&
-						("result" in message || "error" in message)
-					) {
-						const response = message as JsonRpcResponse;
-						if (response.error) {
-							throw new Error(`MCP error ${response.error.code}: ${response.error.message}`);
-						}
-						return response.result as T;
+			for await (const message of readSseJson<JsonRpcMessage>(response.body!)) {
+				if ("id" in message && message.id === expectedId && ("result" in message || "error" in message)) {
+					if (message.error) {
+						throw new Error(`MCP error ${message.error.code}: ${message.error.message}`);
 					}
+					return message.result as T;
+				}
 
-					if ("method" in message && !("id" in message)) {
-						this.onNotification?.(message.method, message.params);
-					}
+				if ("method" in message && !("id" in message)) {
+					this.onNotification?.(message.method, message.params);
 				}
 			}
-
 			throw new Error(`No response received for request ID ${expectedId}`);
 		};
 

package/src/modes/components/armin.ts

@@ -57,7 +57,6 @@ function buildFinalGrid(): string[][] {
 }
 
 export class ArminComponent implements Component {
-	private ui: TUI;
 	private interval: ReturnType<typeof setInterval> | null = null;
 	private effect: Effect;
 	private finalGrid: string[][];
@@ -68,8 +67,7 @@ export class ArminComponent implements Component {
 	private gridVersion = 0;
 	private cachedVersion = -1;
 
-	constructor(ui: TUI) {
-		this.ui = ui;
+	constructor(private readonly ui: TUI) {
 		this.effect = EFFECTS[Math.floor(Math.random() * EFFECTS.length)];
 		this.finalGrid = buildFinalGrid();
 		this.currentGrid = this.createEmptyGrid();

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

@@ -8,15 +8,15 @@ import { getMarkdownTheme, theme } from "../../modes/theme/theme";
  */
 export class AssistantMessageComponent extends Container {
 	private contentContainer: Container;
-	private hideThinkingBlock: boolean;
 	private lastMessage?: AssistantMessage;
 	private prerenderInFlight = false;
 
-	constructor(message?: AssistantMessage, hideThinkingBlock = false) {
+	constructor(
+		message?: AssistantMessage,
+		private hideThinkingBlock = false,
+	) {
 		super();
 
-		this.hideThinkingBlock = hideThinkingBlock;
-
 		// Container for text/thinking content
 		this.contentContainer = new Container();
 		this.addChild(this.contentContainer);

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

@@ -12,7 +12,6 @@ import { truncateToVisualLines } from "./visual-truncate";
 const PREVIEW_LINES = 20;
 
 export class BashExecutionComponent extends Container {
-	private command: string;
 	private outputLines: string[] = [];
 	private status: "running" | "complete" | "cancelled" | "error" = "running";
 	private exitCode: number | undefined = undefined;
@@ -21,9 +20,12 @@ export class BashExecutionComponent extends Container {
 	private expanded = false;
 	private contentContainer: Container;
 
-	constructor(command: string, ui: TUI, excludeFromContext = false) {
+	constructor(
+		private readonly command: string,
+		ui: TUI,
+		excludeFromContext = false,
+	) {
 		super();
-		this.command = command;
 
 		// Use dim border for excluded-from-context commands (!! prefix)
 		const colorKey = excludeFromContext ? "dim" : "bashMode";

package/src/modes/components/branch-summary-message.ts

@@ -8,11 +8,9 @@ import type { BranchSummaryMessage } from "../../session/messages";
  */
 export class BranchSummaryMessageComponent extends Box {
 	private expanded = false;
-	private message: BranchSummaryMessage;
 
-	constructor(message: BranchSummaryMessage) {
+	constructor(private readonly message: BranchSummaryMessage) {
 		super(1, 1, t => theme.bg("customMessageBg", t));
-		this.message = message;
 		this.updateDisplay();
 	}