@oh-my-pi/pi-coding-agent 8.12.4 → 8.12.7

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [8.12.7] - 2026-01-29
+
+### Fixed
+- Fixed LSP servers showing as "unknown" in status display when server warmup fails
+- Fixed Read tool loading entire file into memory when offset/limit was specified
+
 ## [8.12.2] - 2026-01-28
 
 ### Changed

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "8.12.4",
+	"version": "8.12.7",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -79,12 +79,12 @@
 		"test": "bun test"
 	},
 	"dependencies": {
-		"@oh-my-pi/omp-stats": "8.12.4",
-		"@oh-my-pi/pi-agent-core": "8.12.4",
-		"@oh-my-pi/pi-ai": "8.12.4",
-		"@oh-my-pi/pi-natives": "8.12.4",
-		"@oh-my-pi/pi-tui": "8.12.4",
-		"@oh-my-pi/pi-utils": "8.12.4",
+		"@oh-my-pi/omp-stats": "8.12.7",
+		"@oh-my-pi/pi-agent-core": "8.12.7",
+		"@oh-my-pi/pi-ai": "8.12.7",
+		"@oh-my-pi/pi-natives": "8.12.7",
+		"@oh-my-pi/pi-tui": "8.12.7",
+		"@oh-my-pi/pi-utils": "8.12.7",
 		"@openai/agents": "^0.4.4",
 		"@sinclair/typebox": "^0.34.48",
 		"ajv": "^8.17.1",

package/src/lsp/index.ts

@@ -107,7 +107,9 @@ export async function warmupLspServers(cwd: string, options?: LspWarmupOptions):
 		}),
 	);
 
-	for (const result of results) {
+	for (let i = 0; i < results.length; i++) {
+		const result = results[i];
+		const [name, serverConfig] = lspServers[i];
 		if (result.status === "fulfilled") {
 			servers.push({
 				name: result.value.name,
@@ -115,12 +117,11 @@ export async function warmupLspServers(cwd: string, options?: LspWarmupOptions):
 				fileTypes: result.value.fileTypes,
 			});
 		} else {
-			// Extract server name from error if possible
 			const errorMsg = result.reason?.message ?? String(result.reason);
 			servers.push({
-				name: "unknown",
+				name,
 				status: "error",
-				fileTypes: [],
+				fileTypes: serverConfig.fileTypes,
 				error: errorMsg,
 			});
 		}

package/src/modes/components/visual-truncate.ts

@@ -11,6 +11,17 @@ export interface VisualTruncateResult {
 	skippedCount: number;
 }
 
+const textCache = new Map<number, Text>();
+
+function getCachedText(paddingX: number): Text {
+	let text = textCache.get(paddingX);
+	if (!text) {
+		text = new Text("", paddingX, 0);
+		textCache.set(paddingX, text);
+	}
+	return text;
+}
+
 /**
  * Truncate text to a maximum number of visual lines (from the end).
  * This accounts for line wrapping based on terminal width.
@@ -34,7 +45,10 @@ export function truncateToVisualLines(
 	}
 
 	// Create a temporary Text component to render and get visual lines
-	const tempText = new Text(text, paddingX, 0);
+	const tempText = getCachedText(paddingX);
+	if (tempText.getText() !== text) {
+		tempText.setText(text);
+	}
 	const allVisualLines = tempText.render(width);
 
 	if (allVisualLines.length <= maxVisualLines) {

package/src/modes/theme/theme.ts

@@ -1180,8 +1180,8 @@ const langMap: Record<string, SymbolKey> = {
 };
 
 export class Theme {
-	private fgColors: Map<ThemeColor, string>;
-	private bgColors: Map<ThemeBg, string>;
+	private fgColors: Record<ThemeColor, string>;
+	private bgColors: Record<ThemeBg, string>;
 	private mode: ColorMode;
 	private symbols: SymbolMap;
 	private symbolPreset: SymbolPreset;
@@ -1190,18 +1190,18 @@ export class Theme {
 		fgColors: Record<ThemeColor, string | number>,
 		bgColors: Record<ThemeBg, string | number>,
 		mode: ColorMode,
-		symbolPreset: SymbolPreset = "unicode",
-		symbolOverrides: Record<string, string> = {},
+		symbolPreset: SymbolPreset,
+		symbolOverrides: Partial<Record<SymbolKey, string>>,
 	) {
 		this.mode = mode;
 		this.symbolPreset = symbolPreset;
-		this.fgColors = new Map();
+		this.fgColors = {} as Record<ThemeColor, string>;
 		for (const [key, value] of Object.entries(fgColors) as [ThemeColor, string | number][]) {
-			this.fgColors.set(key, fgAnsi(value, mode));
+			this.fgColors[key] = fgAnsi(value, mode);
 		}
-		this.bgColors = new Map();
+		this.bgColors = {} as Record<ThemeBg, string>;
 		for (const [key, value] of Object.entries(bgColors) as [ThemeBg, string | number][]) {
-			this.bgColors.set(key, bgAnsi(value, mode));
+			this.bgColors[key] = bgAnsi(value, mode);
 		}
 		// Build symbol map from preset + overrides
 		const baseSymbols = SYMBOL_PRESETS[symbolPreset];
@@ -1216,13 +1216,13 @@ export class Theme {
 	}
 
 	fg(color: ThemeColor, text: string): string {
-		const ansi = this.fgColors.get(color);
+		const ansi = this.fgColors[color];
 		if (!ansi) throw new Error(`Unknown theme color: ${color}`);
 		return `${ansi}${text}\x1b[39m`; // Reset only foreground color
 	}
 
 	bg(color: ThemeBg, text: string): string {
-		const ansi = this.bgColors.get(color);
+		const ansi = this.bgColors[color];
 		if (!ansi) throw new Error(`Unknown theme background color: ${color}`);
 		return `${ansi}${text}\x1b[49m`; // Reset only background color
 	}
@@ -1248,13 +1248,13 @@ export class Theme {
 	}
 
 	getFgAnsi(color: ThemeColor): string {
-		const ansi = this.fgColors.get(color);
+		const ansi = this.fgColors[color];
 		if (!ansi) throw new Error(`Unknown theme color: ${color}`);
 		return ansi;
 	}
 
 	getBgAnsi(color: ThemeBg): string {
-		const ansi = this.bgColors.get(color);
+		const ansi = this.bgColors[color];
 		if (!ansi) throw new Error(`Unknown theme background color: ${color}`);
 		return ansi;
 	}

package/src/tools/ask.ts

@@ -304,7 +304,10 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 
 		// Determine timeout based on settings and plan mode
 		const planModeEnabled = this.session.getPlanModeState?.()?.enabled ?? false;
-		const settingsTimeout = this.session.settingsManager?.getAskTimeout() ?? DEFAULT_ASK_TIMEOUT_MS;
+		// getAskTimeout returns: number (ms), null (disabled), or undefined (no settingsManager)
+		// Only fall back to default if undefined; preserve null as "disabled"
+		const rawTimeout = this.session.settingsManager?.getAskTimeout();
+		const settingsTimeout = rawTimeout === undefined ? DEFAULT_ASK_TIMEOUT_MS : rawTimeout;
 		const timeout = planModeEnabled ? null : settingsTimeout;
 
 		// Send notification if waiting and not suppressed

package/src/tools/read.ts

@@ -43,6 +43,87 @@ function isRemoteMountPath(absolutePath: string): boolean {
 	return absolutePath.startsWith(REMOTE_MOUNT_PREFIX);
 }
 
+/**
+ * Stream lines from a file, collecting only the requested range.
+ * Avoids loading the entire file into memory for large files.
+ *
+ * @param filePath - Path to the file
+ * @param startLine - 0-indexed start line
+ * @param maxLinesToCollect - Maximum lines to collect (from startLine)
+ * @param maxBytes - Maximum bytes to collect
+ * @returns Collected lines, total line count, and truncation info
+ */
+async function streamLinesFromFile(
+	filePath: string,
+	startLine: number,
+	maxLinesToCollect: number,
+	maxBytes: number,
+): Promise<{
+	lines: string[];
+	totalFileLines: number;
+	collectedBytes: number;
+	stoppedByByteLimit: boolean;
+}> {
+	const stream = Bun.file(filePath).stream();
+	const decoder = new TextDecoder();
+
+	const collectedLines: string[] = [];
+	let lineIndex = 0;
+	let collectedBytes = 0;
+	let stoppedByByteLimit = false;
+	let buffer = "";
+	let doneCollecting = false;
+
+	for await (const chunk of stream) {
+		buffer += decoder.decode(chunk, { stream: true });
+
+		for (let newlinePos = buffer.indexOf("\n"); newlinePos !== -1; newlinePos = buffer.indexOf("\n")) {
+			const line = buffer.slice(0, newlinePos);
+			buffer = buffer.slice(newlinePos + 1);
+
+			if (!doneCollecting && lineIndex >= startLine) {
+				const lineBytes = Buffer.byteLength(line, "utf-8") + (collectedLines.length > 0 ? 1 : 0);
+
+				if (collectedBytes + lineBytes > maxBytes && collectedLines.length > 0) {
+					stoppedByByteLimit = true;
+					doneCollecting = true;
+				} else if (collectedLines.length < maxLinesToCollect) {
+					collectedLines.push(line);
+					collectedBytes += lineBytes;
+					if (collectedLines.length >= maxLinesToCollect) {
+						doneCollecting = true;
+					}
+				} else {
+					doneCollecting = true;
+				}
+			}
+
+			lineIndex++;
+		}
+	}
+
+	// Handle remaining buffer (last line without trailing newline)
+	if (buffer.length > 0) {
+		if (!doneCollecting && lineIndex >= startLine && collectedLines.length < maxLinesToCollect) {
+			const lineBytes = Buffer.byteLength(buffer, "utf-8") + (collectedLines.length > 0 ? 1 : 0);
+			if (collectedBytes + lineBytes <= maxBytes || collectedLines.length === 0) {
+				collectedLines.push(buffer);
+				collectedBytes += lineBytes;
+			} else {
+				stoppedByByteLimit = true;
+			}
+		}
+		lineIndex++;
+	}
+
+	return {
+		lines: collectedLines,
+		totalFileLines: lineIndex,
+		collectedBytes,
+		stoppedByByteLimit,
+	};
+}
+
 // Maximum image file size (20MB) - larger images will be rejected to prevent OOM during serialization
 const MAX_IMAGE_SIZE = 20 * 1024 * 1024;
 const MAX_FUZZY_RESULTS = 5;
@@ -514,40 +595,51 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 				content = [{ type: "text", text: `[Cannot read ${ext} file: conversion failed]` }];
 			}
 		} else {
-			// Read as text
-			const file = Bun.file(absolutePath);
-			const textContent = await file.text();
-			const allLines = textContent.split("\n");
-			const totalFileLines = allLines.length;
-
-			// Apply offset if specified (1-indexed to 0-indexed)
+			// Read as text using streaming to avoid loading huge files into memory
 			const startLine = offset ? Math.max(0, offset - 1) : 0;
 			const startLineDisplay = startLine + 1; // For display (1-indexed)
 
+			// Calculate how many lines to collect: user limit or default truncation limit
+			const maxLinesToCollect = limit !== undefined ? limit : DEFAULT_MAX_LINES;
+
+			// Stream the file, collecting only the needed lines
+			const streamResult = await streamLinesFromFile(absolutePath, startLine, maxLinesToCollect, DEFAULT_MAX_BYTES);
+
+			const { lines: collectedLines, totalFileLines, collectedBytes, stoppedByByteLimit } = streamResult;
+
 			// Check if offset is out of bounds - return graceful message instead of throwing
-			if (startLine >= allLines.length) {
+			if (startLine >= totalFileLines) {
 				const suggestion =
-					allLines.length === 0
+					totalFileLines === 0
 						? "The file is empty."
-						: `Use offset=1 to read from the start, or offset=${allLines.length} to read the last line.`;
+						: `Use offset=1 to read from the start, or offset=${totalFileLines} to read the last line.`;
 				return toolResult<ReadToolDetails>()
-					.text(`Offset ${offset} is beyond end of file (${allLines.length} lines total). ${suggestion}`)
+					.text(`Offset ${offset} is beyond end of file (${totalFileLines} lines total). ${suggestion}`)
 					.done();
 			}
 
-			// If limit is specified by user, use it; otherwise we'll let truncateHead decide
-			let selectedContent: string;
-			let userLimitedLines: number | undefined;
-			if (limit !== undefined) {
-				const endLine = Math.min(startLine + limit, allLines.length);
-				selectedContent = allLines.slice(startLine, endLine).join("\n");
-				userLimitedLines = endLine - startLine;
-			} else {
-				selectedContent = allLines.slice(startLine).join("\n");
-			}
-
-			// Apply truncation (respects both line and byte limits)
-			const truncation = truncateHead(selectedContent);
+			// Build the selected content from collected lines
+			const selectedContent = collectedLines.join("\n");
+			const userLimitedLines = limit !== undefined ? collectedLines.length : undefined;
+
+			// Build truncation result from streaming data
+			const totalSelectedLines = totalFileLines - startLine;
+			const totalSelectedBytes = collectedBytes; // We don't know exact total bytes without reading all
+			const wasTruncated = collectedLines.length < totalSelectedLines || stoppedByByteLimit;
+
+			const truncation: TruncationResult = {
+				content: selectedContent,
+				truncated: wasTruncated,
+				truncatedBy: stoppedByByteLimit ? "bytes" : wasTruncated ? "lines" : null,
+				totalLines: totalSelectedLines,
+				totalBytes: totalSelectedBytes,
+				outputLines: collectedLines.length,
+				outputBytes: collectedBytes,
+				lastLinePartial: false,
+				firstLineExceedsLimit: collectedLines.length === 0 && totalFileLines > startLine,
+				maxLines: DEFAULT_MAX_LINES,
+				maxBytes: DEFAULT_MAX_BYTES,
+			};
 
 			// Add line numbers if requested (uses setting default if not specified)
 			const shouldAddLineNumbers = lines ?? this.defaultLineNumbers;
@@ -566,7 +658,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			let outputText: string;
 
 			if (truncation.firstLineExceedsLimit) {
-				const firstLine = allLines[startLine] ?? "";
+				const firstLine = collectedLines[0] ?? "";
 				const firstLineBytes = Buffer.byteLength(firstLine, "utf-8");
 				const snippet = truncateStringToBytesFromStart(firstLine, DEFAULT_MAX_BYTES);
 
@@ -592,8 +684,8 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 					result: truncation,
 					options: { direction: "head", startLine: startLineDisplay, totalFileLines },
 				};
-			} else if (userLimitedLines !== undefined && startLine + userLimitedLines < allLines.length) {
-				const remaining = allLines.length - (startLine + userLimitedLines);
+			} else if (userLimitedLines !== undefined && startLine + userLimitedLines < totalFileLines) {
+				const remaining = totalFileLines - (startLine + userLimitedLines);
 				const nextOffset = startLine + userLimitedLines + 1;
 
 				outputText = shouldAddLineNumbers