@oh-my-pi/pi-coding-agent 15.10.9 → 15.10.11

package/src/tools/search.ts

@@ -112,6 +112,10 @@ const INTERNAL_TOTAL_CAP = 2000;
  * silently returns no matches for files larger than this; surface a warning
  * when the caller explicitly targeted such a file so they know to chunk it. */
 const NATIVE_GREP_MAX_FILE_BYTES = 4 * 1024 * 1024;
+/** Wall-clock budget for a single native grep invocation. Without it, an
+ * aborted or runaway search (huge tree, network mount) keeps burning CPU on
+ * the native thread pool after the JS promise is abandoned. */
+const SEARCH_GREP_TIMEOUT_MS = 30_000;
 
 /**
  * Parsed `paths` entry — a path (possibly archive-shaped) plus an optional
@@ -351,6 +355,8 @@ function makeVirtualMatch(
 	lineIndex: number,
 	contextBefore: number,
 	contextAfter: number,
+	lastEmittedLine: number,
+	nextMatchLine: number,
 ): GrepMatch {
 	const lineNumber = lineIndex + 1;
 	const { text, wasTruncated } = truncateLine(lines[lineIndex] ?? "", DEFAULT_MAX_COLUMN);
@@ -363,7 +369,9 @@ function makeVirtualMatch(
 
 	if (contextBefore > 0) {
 		const before: NonNullable<GrepMatch["contextBefore"]> = [];
-		const start = Math.max(0, lineIndex - contextBefore);
+		// Start after the previous match's last emitted line so adjacent matches
+		// never repeat or rewind context lines (mirrors native grep's sink).
+		const start = Math.max(0, lineIndex - contextBefore, lastEmittedLine);
 		for (let idx = start; idx < lineIndex; idx++) {
 			const contextLineNumber = idx + 1;
 			if (lineAllowed(contextLineNumber, resource.ranges)) {
@@ -375,7 +383,8 @@ function makeVirtualMatch(
 
 	if (contextAfter > 0) {
 		const after: NonNullable<GrepMatch["contextAfter"]> = [];
-		const end = Math.min(lines.length - 1, lineIndex + contextAfter);
+		// Stop before the next match line; it is emitted as a match itself.
+		const end = Math.min(lines.length - 1, lineIndex + contextAfter, nextMatchLine - 2);
 		for (let idx = lineIndex + 1; idx <= end; idx++) {
 			const contextLineNumber = idx + 1;
 			if (lineAllowed(contextLineNumber, resource.ranges)) {
@@ -388,6 +397,38 @@ function makeVirtualMatch(
 	return match;
 }
 
+/** Build matches for ascending matched line indexes with forward-only,
+ * deduplicated context windows (line numbers never repeat or go backwards
+ * within one resource). */
+function buildVirtualMatches(
+	resource: VirtualSearchResource,
+	lines: readonly string[],
+	matchedIndexes: readonly number[],
+	contextBefore: number,
+	contextAfter: number,
+	maxCount: number,
+): GrepMatch[] {
+	const matches: GrepMatch[] = [];
+	let lastEmittedLine = 0;
+	for (let i = 0; i < matchedIndexes.length && matches.length < maxCount; i++) {
+		const lineIndex = matchedIndexes[i];
+		const nextMatchLine = i + 1 < matchedIndexes.length ? matchedIndexes[i + 1] + 1 : Number.POSITIVE_INFINITY;
+		const match = makeVirtualMatch(
+			resource,
+			lines,
+			lineIndex,
+			contextBefore,
+			contextAfter,
+			lastEmittedLine,
+			nextMatchLine,
+		);
+		const after = match.contextAfter;
+		lastEmittedLine = after && after.length > 0 ? after[after.length - 1].lineNumber : match.lineNumber;
+		matches.push(match);
+	}
+	return matches;
+}
+
 function compileVirtualRegex(pattern: string, ignoreCase: boolean, multiline: boolean): RegExp {
 	const flags = `${ignoreCase ? "i" : ""}${multiline ? "gm" : ""}`;
 	try {
@@ -406,24 +447,18 @@ function searchVirtualResourceLines(
 	maxCount: number,
 ): { matches: GrepMatch[]; totalMatches: number; limitReached: boolean } {
 	const lines = splitSearchLines(resource.content);
-	const matches: GrepMatch[] = [];
-	let totalMatches = 0;
-	let limitReached = false;
+	const matchedIndexes: number[] = [];
 
 	for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
 		const lineNumber = lineIndex + 1;
 		if (!lineAllowed(lineNumber, resource.ranges)) continue;
 		regex.lastIndex = 0;
 		if (!regex.test(lines[lineIndex] ?? "")) continue;
-		totalMatches++;
-		if (matches.length >= maxCount) {
-			limitReached = true;
-			continue;
-		}
-		matches.push(makeVirtualMatch(resource, lines, lineIndex, contextBefore, contextAfter));
+		matchedIndexes.push(lineIndex);
 	}
 
-	return { matches, totalMatches, limitReached };
+	const matches = buildVirtualMatches(resource, lines, matchedIndexes, contextBefore, contextAfter, maxCount);
+	return { matches, totalMatches: matchedIndexes.length, limitReached: matchedIndexes.length > matches.length };
 }
 
 function searchVirtualResourceMultiline(
@@ -434,10 +469,8 @@ function searchVirtualResourceMultiline(
 	maxCount: number,
 ): { matches: GrepMatch[]; totalMatches: number; limitReached: boolean } {
 	const indexed = indexSearchLines(resource.content);
-	const matches: GrepMatch[] = [];
 	const matchedLines = new Set<number>();
-	let totalMatches = 0;
-	let limitReached = false;
+	const matchedIndexes: number[] = [];
 
 	while (true) {
 		const match = regex.exec(resource.content);
@@ -447,12 +480,7 @@ function searchVirtualResourceMultiline(
 			const lineNumber = lineIndex + 1;
 			if (!matchedLines.has(lineNumber) && lineAllowed(lineNumber, resource.ranges)) {
 				matchedLines.add(lineNumber);
-				totalMatches++;
-				if (matches.length >= maxCount) {
-					limitReached = true;
-				} else {
-					matches.push(makeVirtualMatch(resource, indexed.lines, lineIndex, contextBefore, contextAfter));
-				}
+				matchedIndexes.push(lineIndex);
 			}
 		}
 		if (match[0].length === 0) {
@@ -460,7 +488,8 @@ function searchVirtualResourceMultiline(
 		}
 	}
 
-	return { matches, totalMatches, limitReached };
+	const matches = buildVirtualMatches(resource, indexed.lines, matchedIndexes, contextBefore, contextAfter, maxCount);
+	return { matches, totalMatches: matchedIndexes.length, limitReached: matchedIndexes.length > matches.length };
 }
 
 function searchVirtualResources(
@@ -666,10 +695,12 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 		const { pattern, paths: rawPaths, i, gitignore, skip } = params;
 
 		return untilAborted(signal, async () => {
-			const normalizedPattern = pattern.trim();
-			if (!normalizedPattern) {
+			// Preserve the pattern verbatim — leading/trailing whitespace is
+			// meaningful in regexes (indentation anchors, trailing-space matches).
+			if (!pattern.trim()) {
 				throw new ToolError("Pattern must not be empty");
 			}
+			const normalizedPattern = pattern;
 
 			const normalizedSkip =
 				skip === undefined || skip === null ? 0 : Number.isFinite(skip) ? Math.floor(skip) : Number.NaN;
@@ -729,7 +760,11 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 					}
 				}
 
-				if (archiveUnreadable.length > 0 && searchablePaths.length === archiveUnreadable.length) {
+				if (
+					archiveUnreadable.length > 0 &&
+					searchablePaths.length === archiveUnreadable.length &&
+					virtualResources.length === 0
+				) {
 					// All inputs were archive selectors we couldn't materialize; surface the
 					// reason instead of a downstream "path not found" from the scope resolver.
 					throw new ToolError(
@@ -823,6 +858,7 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 					filesSearched: 0,
 					limitReached: false,
 				};
+				let skippedOversizedCount = 0;
 				try {
 					if (searchablePaths.length > 0) {
 						if (exactFilePaths || multiTargets) {
@@ -852,9 +888,13 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 										contextAfter: normalizedContextAfter,
 										maxColumns: DEFAULT_MAX_COLUMN,
 										mode: effectiveOutputMode,
+										maxCountPerFile: perFileMatchCap + 1,
+										signal,
+										timeoutMs: SEARCH_GREP_TIMEOUT_MS,
 									},
 									undefined,
 								);
+								skippedOversizedCount += targetResult.skippedOversized ?? 0;
 								limitReached = limitReached || Boolean(targetResult.limitReached);
 								totalMatches += targetResult.totalMatches;
 								filesSearched += targetResult.filesSearched;
@@ -887,15 +927,24 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 									contextAfter: normalizedContextAfter,
 									maxColumns: DEFAULT_MAX_COLUMN,
 									mode: effectiveOutputMode,
+									maxCountPerFile: perFileMatchCap + 1,
+									signal,
+									timeoutMs: SEARCH_GREP_TIMEOUT_MS,
 								},
 								undefined,
 							);
+							skippedOversizedCount = result.skippedOversized ?? 0;
 						}
 					}
 				} catch (err) {
 					if (err instanceof Error && /^regex(?: parse)? error/i.test(err.message)) {
 						throw new ToolError(err.message.replace(/^regex(?: parse)? error:?\s*/i, "Invalid regex: "));
 					}
+					if (err instanceof Error && err.message.includes("Aborted: Timeout")) {
+						throw new ToolError(
+							`Search timed out after ${SEARCH_GREP_TIMEOUT_MS / 1000}s; narrow paths or pattern, or scope with \`find\` first`,
+						);
+					}
 					throw err;
 				}
 				const virtualResult = searchVirtualResources(
@@ -971,6 +1020,9 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 					}
 				}
 				const totalFiles = fileOrder.length;
+				// When native grep stopped at its internal cap, files past the cap were
+				// never surfaced — the file total is only a lower bound.
+				const totalFilesLabel = result.limitReached ? `${totalFiles}+` : `${totalFiles}`;
 				// Single-file scopes can't paginate — there is one file by definition.
 				const canPaginate = isMultiScope;
 				const skipFiles = canPaginate ? Math.min(normalizedSkip, totalFiles) : 0;
@@ -993,7 +1045,7 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 				}
 				const nextSkip = skipFiles + windowFiles.length;
 				const limitMessage = fileLimitReached
-					? `Showing files ${skipFiles + 1}-${nextSkip} of ${totalFiles}. Use skip=${nextSkip} for the next page, or narrow paths/pattern.`
+					? `Showing files ${skipFiles + 1}-${nextSkip} of ${totalFilesLabel}. Use skip=${nextSkip} for the next page, or narrow paths/pattern.`
 					: "";
 				const { record: recordFile, list: fileList } = createFileRecorder();
 				const fileMatchCounts = new Map<string, number>();
@@ -1025,6 +1077,12 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 					const limitMb = Math.floor(NATIVE_GREP_MAX_FILE_BYTES / (1024 * 1024));
 					return `Skipped oversized files (>${limitMb}MB grep limit; split the file or narrow with \`read\`): ${oversized.join(", ")}`;
 				})();
+				// Directory/multi-target scopes: native grep counts oversized skips but
+				// cannot name them; explicit-file scopes are covered (with names) above.
+				const oversizedScanNote =
+					!oversizedNote && skippedOversizedCount > 0
+						? `Skipped ${skippedOversizedCount} oversized file(s) (>${Math.floor(NATIVE_GREP_MAX_FILE_BYTES / (1024 * 1024))}MB grep limit); target them directly with \`read\``
+						: undefined;
 				const archiveNote =
 					archiveUnreadable.length > 0
 						? `Skipped archive entries (search supports text members only): ${archiveUnreadable.join(", ")}`
@@ -1036,8 +1094,9 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 				const missingPathsNote =
 					missingPathsForNote.length > 0 ? `Skipped missing paths: ${missingPathsForNote.join(", ")}` : undefined;
 				const warningNote =
-					[missingPathsNote, archiveNote, oversizedNote].filter((s): s is string => Boolean(s)).join("\n") ||
-					undefined;
+					[missingPathsNote, archiveNote, oversizedNote, oversizedScanNote]
+						.filter((s): s is string => Boolean(s))
+						.join("\n") || undefined;
 				if (selectedMatches.length === 0) {
 					const details: SearchToolDetails = {
 						scopePath,
@@ -1049,7 +1108,11 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 						truncated: false,
 						missingPaths: missingPaths.length > 0 ? missingPaths : undefined,
 					};
-					const text = warningNote ? `No matches found\n${warningNote}` : "No matches found";
+					const skipPastEnd = canPaginate && normalizedSkip > 0 && totalFiles > 0 && skipFiles >= totalFiles;
+					const noMatchText = skipPastEnd
+						? `No more results (${totalFilesLabel} files total; skip=${normalizedSkip} is past the end)`
+						: "No matches found";
+					const text = warningNote ? `${noMatchText}\n${warningNote}` : noMatchText;
 					return toolResult(details).text(text).done();
 				}
 				const outputLines: string[] = [];

package/src/tools/sqlite-reader.ts

@@ -17,6 +17,8 @@ const SQLITE_PATH_PATTERN = /\.(?:sqlite3?|db3?)(?=(?::|\?|$))/gi;
 const DEFAULT_QUERY_LIMIT = 20;
 const DEFAULT_SCHEMA_SAMPLE_LIMIT = 5;
 const MAX_QUERY_LIMIT = 500;
+/** Row cap for raw `?q=` SQL — protects against `SELECT *` on multi-million-row tables. */
+export const MAX_RAW_QUERY_ROWS = 1000;
 const MAX_RENDER_WIDTH = 120;
 const MAX_COLUMN_WIDTH = 40;
 const MIN_COLUMN_WIDTH = 1;
@@ -659,15 +661,25 @@ export function getRowByRowId(db: Database, table: string, key: string): Record<
 		.get(binding);
 }
 
-export function executeReadQuery(db: Database, sql: string): { columns: string[]; rows: Record<string, unknown>[] } {
+export function executeReadQuery(
+	db: Database,
+	sql: string,
+): { columns: string[]; rows: Record<string, unknown>[]; truncated: boolean } {
 	const statement = db.prepare<SqliteRow, []>(sql);
 	if (statement.paramsCount > 0) {
 		throw new ToolError("SQLite raw queries do not support bound parameters");
 	}
-	return {
-		columns: [...statement.columnNames],
-		rows: statement.all(),
-	};
+	const columns = [...statement.columnNames];
+	const rows: SqliteRow[] = [];
+	let truncated = false;
+	for (const row of statement.iterate()) {
+		if (rows.length >= MAX_RAW_QUERY_ROWS) {
+			truncated = true;
+			break;
+		}
+		rows.push(row);
+	}
+	return { columns, rows, truncated };
 }
 
 export function insertRow(db: Database, table: string, data: Record<string, unknown>): void {

package/src/tools/ssh.ts

@@ -10,7 +10,7 @@ import type { Theme } from "../modes/theme/theme";
 import sshDescriptionBase from "../prompts/tools/ssh.md" with { type: "text" };
 import { DEFAULT_MAX_BYTES, streamTailUpdates, TailBuffer } from "../session/streaming-output";
 import type { SSHHostInfo } from "../ssh/connection-manager";
-import { ensureHostInfo, getHostInfoForHost } from "../ssh/connection-manager";
+import { ensureHostInfo, getCachedHostInfoSync } from "../ssh/connection-manager";
 import { executeSSH } from "../ssh/ssh-executor";
 import { renderStatusLine } from "../tui";
 import { CachedOutputBlock, markFramedBlockComponent } from "../tui/output-block";
@@ -33,8 +33,8 @@ export interface SSHToolDetails {
 	meta?: OutputMeta;
 }
 
-async function formatHostEntry(host: SSHHost): Promise<string> {
-	const info = await getHostInfoForHost(host);
+function formatHostEntry(host: SSHHost): string {
+	const info = getCachedHostInfoSync(host);
 
 	let shell: string;
 	if (!info) {
@@ -59,12 +59,12 @@ async function formatHostEntry(host: SSHHost): Promise<string> {
 	return `- ${host.name} (${host.host}) | ${shell}`;
 }
 
-async function formatDescription(hosts: SSHHost[]): Promise<string> {
+function formatDescription(hosts: SSHHost[]): string {
 	const baseDescription = prompt.render(sshDescriptionBase);
 	if (hosts.length === 0) {
 		return baseDescription;
 	}
-	const hostList = (await Promise.all(hosts.map(formatHostEntry))).join("\n");
+	const hostList = hosts.map(formatHostEntry).join("\n");
 	return `${baseDescription}\n\nAvailable hosts:\n${hostList}`;
 }
 
@@ -206,7 +206,7 @@ export async function loadSshTool(session: ToolSession): Promise<SshTool | null>
 	const descriptionHosts = hostNames
 		.map(name => hostsByName.get(name))
 		.filter((host): host is SSHHost => host !== undefined);
-	const description = await formatDescription(descriptionHosts);
+	const description = formatDescription(descriptionHosts);
 
 	return new SshTool(session, hostNames, hostsByName, description);
 }
@@ -245,7 +245,7 @@ export const sshToolRenderer = {
 		const cmdLines = formatSshCommandLines(command, uiTheme);
 		const outputBlock = new CachedOutputBlock();
 		return markFramedBlockComponent({
-			render: (width: number): string[] =>
+			render: (width: number): readonly string[] =>
 				outputBlock.render(
 					{
 						header,
@@ -282,7 +282,7 @@ export const sshToolRenderer = {
 		const outputBlock = new CachedOutputBlock();
 
 		return markFramedBlockComponent({
-			render: (width: number): string[] => {
+			render: (width: number): readonly string[] => {
 				// REACTIVE: read mutable options at render time
 				const { expanded, renderContext } = options;
 				// Strip LLM-facing notice so we don't echo it next to the styled warning.

package/src/tools/todo.ts

@@ -51,7 +51,7 @@ export interface TodoToolDetails {
 // =============================================================================
 
 const TodoOp = z
-	.enum(["init", "start", "done", "rm", "drop", "append", "note"] as const)
+	.enum(["init", "start", "done", "rm", "drop", "append", "note", "view"] as const)
 	.describe("operation to apply");
 
 const InitListEntry = z.object({
@@ -285,6 +285,22 @@ function initPhases(entry: TodoOpEntryValue, errors: string[]): TodoPhase[] {
 		errors.push("Missing list for init operation");
 		return [];
 	}
+	// Duplicate phase names / task contents would be permanently unaddressable
+	// (every targeting op resolves the first match), so reject them up front.
+	const seenPhases = new Set<string>();
+	const seenTasks = new Set<string>();
+	for (const listEntry of entry.list) {
+		if (seenPhases.has(listEntry.phase)) {
+			errors.push(`Duplicate phase "${listEntry.phase}" in init list`);
+		}
+		seenPhases.add(listEntry.phase);
+		for (const content of listEntry.items) {
+			if (seenTasks.has(content)) {
+				errors.push(`Duplicate task "${content}" in init list`);
+			}
+			seenTasks.add(content);
+		}
+	}
 	return entry.list.map(listEntry => ({
 		name: listEntry.phase,
 		tasks: listEntry.items.map<TodoItem>(content => ({ content, status: "pending" })),
@@ -301,6 +317,19 @@ function appendItems(phases: TodoPhase[], entry: TodoOpEntryValue, errors: strin
 		return phases;
 	}
 
+	// Validate the whole batch before mutating so a failing op reports every
+	// duplicate and leaves nothing half-applied.
+	const seen = new Set<string>();
+	let hasDuplicate = false;
+	for (const content of entry.items) {
+		if (seen.has(content) || findTaskByContent(phases, content)) {
+			errors.push(`Task "${content}" already exists`);
+			hasDuplicate = true;
+		}
+		seen.add(content);
+	}
+	if (hasDuplicate) return phases;
+
 	let phase = findPhaseByName(phases, entry.phase);
 	if (!phase) {
 		phase = { name: entry.phase, tasks: [] };
@@ -308,10 +337,6 @@ function appendItems(phases: TodoPhase[], entry: TodoOpEntryValue, errors: strin
 	}
 
 	for (const content of entry.items) {
-		if (findTaskByContent(phases, content)) {
-			errors.push(`Task "${content}" already exists`);
-			return phases;
-		}
 		phase.tasks.push({ content, status: "pending" });
 	}
 	return phases;
@@ -380,6 +405,8 @@ function applyEntry(phases: TodoPhase[], entry: TodoOpEntryValue, errors: string
 		}
 		case "append":
 			return appendItems(phases, entry, errors);
+		case "view":
+			return phases;
 	}
 }
 
@@ -523,9 +550,12 @@ export function markdownToPhases(md: string): { phases: TodoPhase[]; errors: str
 	return { phases, errors };
 }
 
-function formatSummary(phases: TodoPhase[], errors: string[]): string {
+function formatSummary(phases: TodoPhase[], errors: string[], readOnly = false): string {
 	const tasks = phases.flatMap(phase => phase.tasks);
-	if (tasks.length === 0) return errors.length > 0 ? `Errors: ${errors.join("; ")}` : "Todo list cleared.";
+	if (tasks.length === 0) {
+		if (errors.length > 0) return `Errors: ${errors.join("; ")}`;
+		return readOnly ? "Todo list is empty." : "Todo list cleared.";
+	}
 
 	const remainingByPhase = phases
 		.map(phase => ({
@@ -608,15 +638,24 @@ export class TodoTool implements AgentTool<typeof todoSchema, TodoToolDetails> {
 		_context?: AgentToolContext,
 	): Promise<AgentToolResult<TodoToolDetails>> {
 		const previousPhases = clonePhases(this.session.getTodoPhases?.() ?? []);
-		const { phases: updated, errors } = applyParams(clonePhases(previousPhases), params);
-		const completedTasks = getCompletionTransitions(previousPhases, updated);
-		this.session.setTodoPhases?.(updated);
+		// Pure-view calls are reads: no normalization, no state write.
+		const readOnly = params.ops.every(entry => entry.op === "view");
+		const { phases: updated, errors } = readOnly
+			? { phases: previousPhases, errors: [] as string[] }
+			: applyParams(clonePhases(previousPhases), params);
+		// A batch with any error is discarded wholesale: persisting a
+		// half-applied batch makes the natural retry hit "already exists" for
+		// the ops that did land. State and rendered summary stay at previous.
+		const failed = errors.length > 0;
+		const effective = failed ? previousPhases : updated;
+		const completedTasks = readOnly || failed ? [] : getCompletionTransitions(previousPhases, updated);
+		if (!readOnly && !failed) this.session.setTodoPhases?.(updated);
 		const storage = this.session.getSessionFile() ? "session" : "memory";
-		const details: TodoToolDetails = { phases: updated, storage };
+		const details: TodoToolDetails = { phases: effective, storage };
 		if (completedTasks.length > 0) details.completedTasks = completedTasks;
 
 		return {
-			content: [{ type: "text", text: formatSummary(updated, errors) }],
+			content: [{ type: "text", text: formatSummary(effective, errors, readOnly) }],
 			details,
 			isError: errors.length > 0 ? true : undefined,
 		};