@oh-my-pi/pi-coding-agent 15.7.6 → 15.8.2

package/src/tools/read.ts

@@ -69,6 +69,7 @@ import {
 	type LineRange,
 	parseLineRanges,
 	resolveReadPath,
+	splitDelimitedPathEntry,
 	splitInternalUrlSel,
 	splitPathAndSel,
 } from "./path-utils";
@@ -693,6 +694,50 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		});
 	}
 
+	async #tryReadDelimitedPaths(
+		readPath: string,
+		signal?: AbortSignal,
+	): Promise<AgentToolResult<ReadToolDetails> | null> {
+		const parts = await splitDelimitedPathEntry(readPath, this.session.cwd);
+		if (!parts) return null;
+
+		const notice = `Note: interpreted as ${parts.length} paths: ${parts.join(", ")}`;
+		const notes = [notice];
+		const content: Array<TextContent | ImageContent> = [];
+		let pendingText = notice;
+		const flushText = () => {
+			if (pendingText.length === 0) return;
+			content.push({ type: "text", text: pendingText });
+			pendingText = "";
+		};
+		const appendText = (text: string) => {
+			pendingText = pendingText.length > 0 ? `${pendingText}\n\n${text}` : text;
+		};
+
+		for (const part of parts) {
+			try {
+				const result = await this.execute("read-delimited-part", { path: part }, signal);
+				for (const block of result.content) {
+					if (block.type === "text") {
+						appendText(block.text);
+						continue;
+					}
+					flushText();
+					content.push(block);
+				}
+			} catch (error) {
+				if (error instanceof ToolAbortError || signal?.aborted) throw error;
+				const message = error instanceof Error ? error.message : String(error);
+				const errorNote = `Could not read ${part}: ${message}`;
+				notes.push(errorNote);
+				appendText(`[${errorNote}]`);
+			}
+		}
+		flushText();
+
+		return toolResult<ReadToolDetails>({ notes }).content(content).done();
+	}
+
 	async #resolveArchiveReadPath(readPath: string, signal?: AbortSignal): Promise<ResolvedArchiveReadPath | null> {
 		const candidates = parseArchivePathCandidates(readPath);
 		for (const candidate of candidates) {
@@ -1596,6 +1641,8 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 				}
 
 				if (!suffixResolution) {
+					const delimitedResult = await this.#tryReadDelimitedPaths(readPath, signal);
+					if (delimitedResult) return delimitedResult;
 					throw new ToolError(`Path '${localReadPath}' not found`);
 				}
 			} else {

package/src/tools/search-tool-bm25.ts

@@ -10,6 +10,7 @@ import {
 	buildDiscoverableToolSearchIndex,
 	type DiscoverableTool,
 	type DiscoverableToolSearchIndex,
+	filterBySource,
 	formatDiscoverableToolServerSummary,
 	searchDiscoverableTools,
 	summarizeDiscoverableTools,
@@ -141,10 +142,15 @@ function isDiscoveryEnabled(session: ToolSession): boolean {
 
 export function renderSearchToolBm25Description(discoverableTools: DiscoverableTool[] = []): string {
 	const summary = summarizeDiscoverableTools(discoverableTools);
+	const builtinToolNames = filterBySource(discoverableTools, "builtin")
+		.map(t => t.name)
+		.sort();
 	return prompt.render(searchToolBm25Description, {
-		discoverableMCPToolCount: summary.toolCount,
+		discoverableToolCount: summary.toolCount,
 		discoverableMCPServerSummaries: summary.servers.map(formatDiscoverableToolServerSummary),
 		hasDiscoverableMCPServers: summary.servers.length > 0,
+		discoverableBuiltinToolNames: builtinToolNames,
+		hasDiscoverableBuiltinTools: builtinToolNames.length > 0,
 	});
 }
 

package/src/tools/search.ts

@@ -30,6 +30,7 @@ import { formatGroupedFiles } from "./grouped-file-output";
 import { formatMatchLine } from "./match-line-format";
 import { formatFullOutputReference, type OutputMeta } from "./output-meta";
 import {
+	expandDelimitedPathEntries,
 	hasGlobPathChars,
 	isLineInRanges,
 	type LineRange,
@@ -93,29 +94,6 @@ export const SINGLE_FILE_MATCHES = 200;
  * pagination headroom so the caller can see total file count. */
 const INTERNAL_TOTAL_CAP = 2000;
 
-/**
- * Detect a `,` that is not inside a `{…}` brace expansion. Used to catch
- * `paths: ["a,b"]` mistakes where the caller flattened multiple entries
- * into a single string instead of passing a JSON array of strings.
- */
-function containsTopLevelComma(entry: string): boolean {
-	let depth = 0;
-	for (let i = 0; i < entry.length; i++) {
-		const ch = entry[i];
-		if (ch === "\\" && i + 1 < entry.length) {
-			i++;
-			continue;
-		}
-		if (ch === "{") depth++;
-		else if (ch === "}") {
-			if (depth > 0) depth--;
-		} else if (ch === "," && depth === 0) {
-			return true;
-		}
-	}
-	return false;
-}
-
 /**
  * Parsed `paths` entry — a path (possibly archive-shaped) plus an optional
  * line-range selector peeled off the trailing `:N-M` (or `:N+K`, `:N,M`, …)
@@ -146,9 +124,6 @@ function parsePathSpecs(rawEntries: readonly string[]): SearchPathSpec[] {
 			clean = split.path;
 			ranges = parsed;
 		}
-		if (containsTopLevelComma(clean)) {
-			throw new ToolError('paths is an array — pass ["a", "b"] not ["a,b"]');
-		}
 		specs.push({ original: entry, clean, ranges });
 	}
 	return specs;
@@ -663,7 +638,7 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 			if (normalizedSkip < 0 || !Number.isFinite(normalizedSkip)) {
 				throw new ToolError("Skip must be a non-negative number");
 			}
-			const rawEntries = toPathList(rawPaths);
+			const rawEntries = await expandDelimitedPathEntries(toPathList(rawPaths), this.session.cwd);
 			const pathSpecs = parsePathSpecs(rawEntries);
 			const paths = pathSpecs.map(spec => spec.clean);
 			const {

package/src/tools/sqlite-reader.ts

@@ -12,6 +12,15 @@ const MAX_QUERY_LIMIT = 500;
 const MAX_RENDER_WIDTH = 120;
 const MAX_COLUMN_WIDTH = 40;
 const MIN_COLUMN_WIDTH = 1;
+/**
+ * Upper bound on rows scanned when counting a table for the listing. SQLite has
+ * no stored row count, so `COUNT(*)` is a full b-tree scan — multi-second on a
+ * multi-GB database, and `bun:sqlite` runs it synchronously on the JS thread
+ * that also drives the TUI, freezing rendering and input. The listing instead
+ * trusts the planner's `sqlite_stat1` estimate for large tables and only counts
+ * exactly when a table is provably small, reading at most this many rows.
+ */
+const ROW_COUNT_PROBE_CAP = 50_000;
 
 type SqliteBinding = Exclude<SQLQueryBindings, Record<string, unknown>>;
 
@@ -26,6 +35,11 @@ interface SqliteCountRow {
 	count: number;
 }
 
+interface SqliteStat1Row {
+	tbl: string;
+	stat: string | null;
+}
+
 interface SqliteTableInfoRow {
 	cid: number;
 	name: string;
@@ -50,6 +64,23 @@ export type SqliteSelector =
 
 export type SqliteRowLookup = { kind: "pk"; column: string; type: string } | { kind: "rowid" };
 
+/**
+ * Row count for a table in the listing.
+ * - `exact`: counted in full (the table is small enough to count cheaply).
+ * - `estimate`: the planner's `sqlite_stat1` figure; the table is too large to
+ *   scan, so this may be stale.
+ * - `atLeast`: a lower bound; counting was capped before reaching the end.
+ */
+export type TableRowCount =
+	| { kind: "exact"; rows: number }
+	| { kind: "estimate"; rows: number }
+	| { kind: "atLeast"; rows: number };
+
+export interface SqliteTableSummary {
+	name: string;
+	count: TableRowCount;
+}
+
 function splitSqliteRemainder(remainder: string): { subPath: string; queryString: string } {
 	const queryIndex = remainder.indexOf("?");
 	if (queryIndex === -1) {
@@ -495,20 +526,61 @@ export function parseSqliteSelector(subPath: string, queryString: string): Sqlit
 	return { kind: "schema", table, sampleLimit: DEFAULT_SCHEMA_SAMPLE_LIMIT };
 }
 
-export function listTables(db: Database): { name: string; rowCount: number }[] {
+/**
+ * Reads the planner's per-table row estimate from `sqlite_stat1` (populated by
+ * `ANALYZE`). The first integer of each `stat` string is the number of rows in
+ * that index; for a full (non-partial) index it equals the table's row count,
+ * so the max across a table's entries is the table estimate. Returns an empty
+ * map when the database was never analyzed. One small indexed read — no scan.
+ */
+function loadRowEstimates(db: Database): Map<string, number> {
+	const estimates = new Map<string, number>();
+	const hasStat1 = db
+		.prepare<Pick<SqliteMasterRow, "name">, []>(
+			"SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'sqlite_stat1'",
+		)
+		.get();
+	if (!hasStat1) return estimates;
+
+	for (const { tbl, stat } of db.prepare<SqliteStat1Row, []>("SELECT tbl, stat FROM sqlite_stat1").all()) {
+		if (!stat) continue;
+		const rows = Number.parseInt(stat, 10);
+		if (!Number.isFinite(rows)) continue;
+		const prev = estimates.get(tbl);
+		if (prev === undefined || rows > prev) estimates.set(tbl, rows);
+	}
+	return estimates;
+}
+
+/**
+ * Counts a table while reading at most `cap + 1` rows. Returns an exact count
+ * when the table holds `cap` rows or fewer, otherwise a lower bound of `cap`.
+ * Bounds the worst-case scan so a stale or missing estimate can never trigger a
+ * full-table scan on the JS thread.
+ */
+function probeRowCount(db: Database, table: string, cap: number): TableRowCount {
+	const sql = `SELECT COUNT(*) AS count FROM (SELECT 1 FROM ${quoteSqliteIdentifier(table)} LIMIT ${cap + 1})`;
+	const counted = db.prepare<SqliteCountRow, []>(sql).get()?.count ?? 0;
+	return counted > cap ? { kind: "atLeast", rows: cap } : { kind: "exact", rows: counted };
+}
+
+export function listTables(db: Database, options: { probeCap?: number } = {}): SqliteTableSummary[] {
+	const cap = options.probeCap ?? ROW_COUNT_PROBE_CAP;
 	const names = db
 		.prepare<Pick<SqliteMasterRow, "name">, []>(
 			"SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' ORDER BY name COLLATE NOCASE",
 		)
 		.all();
+	const estimates = loadRowEstimates(db);
 
 	return names.map(({ name }) => {
-		const countRow =
-			db.prepare<SqliteCountRow, []>(`SELECT COUNT(*) AS count FROM ${quoteSqliteIdentifier(name)}`).get() ?? null;
-		return {
-			name,
-			rowCount: countRow?.count ?? 0,
-		};
+		const estimate = estimates.get(name);
+		// Trust the planner only when it says the table is too large to count
+		// cheaply; otherwise count exactly (bounded), which also corrects a
+		// stale-low estimate without ever scanning more than `cap` rows.
+		const count: TableRowCount =
+			estimate !== undefined && estimate > cap ? { kind: "estimate", rows: estimate } : probeRowCount(db, name, cap);
+		return { name, count };
 	});
 }
 
@@ -679,13 +751,24 @@ export function deleteRowByRowId(db: Database, table: string, key: string): numb
 	return statement.run(binding).changes;
 }
 
-export function renderTableList(tables: { name: string; rowCount: number }[]): string {
+function formatRowCount(count: TableRowCount): string {
+	switch (count.kind) {
+		case "exact":
+			return `${count.rows} rows`;
+		case "estimate":
+			return `~${count.rows} rows`;
+		case "atLeast":
+			return `${count.rows}+ rows`;
+	}
+}
+
+export function renderTableList(tables: SqliteTableSummary[]): string {
 	if (tables.length === 0) {
 		return "(no tables)";
 	}
 
 	return tables
-		.map(table => truncateToWidth(replaceTabs(`${table.name} (${table.rowCount} rows)`), MAX_RENDER_WIDTH))
+		.map(table => truncateToWidth(replaceTabs(`${table.name} (${formatRowCount(table.count)})`), MAX_RENDER_WIDTH))
 		.join("\n");
 }
 

package/src/tools/write.ts

@@ -273,6 +273,12 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 	readonly loadMode = "discoverable";
 	readonly summary = "Write content to a file (creates or overwrites)";
 
+	/** Stream matchers should see the real file content, not its JSON-escaped argument encoding. */
+	matcherDigest(args: unknown): string | undefined {
+		const content = (args as Partial<WriteParams>).content;
+		return typeof content === "string" ? content : undefined;
+	}
+
 	readonly #writethrough: WritethroughCallback;
 
 	constructor(private readonly session: ToolSession) {

package/src/utils/clipboard.ts

@@ -119,7 +119,7 @@ async function readImageViaPowerShell(): Promise<ClipboardImage | null> {
 		if (!b64) return null;
 		const bytes = Buffer.from(b64, "base64");
 		if (bytes.byteLength === 0) return null;
-		return { data: new Uint8Array(bytes), mimeType: "image/png" };
+		return { data: bytes, mimeType: "image/png" };
 	} catch {
 		return null;
 	}
@@ -154,3 +154,40 @@ export async function readImageFromClipboard(): Promise<ClipboardImage | null> {
 
 	return (await native.readImageFromClipboard()) ?? null;
 }
+
+/**
+ * Read plain text from the system clipboard.
+ */
+export async function readTextFromClipboard(): Promise<string> {
+	try {
+		const p = process.platform;
+		if (p === "darwin") {
+			return execSync("pbpaste", { encoding: "utf8", timeout: 2000 }).toString();
+		}
+		if (p === "win32") {
+			return execSync('powershell.exe -NoProfile -Command "Get-Clipboard"', {
+				encoding: "utf8",
+				timeout: 2000,
+			}).toString();
+		}
+		if (process.env.TERMUX_VERSION) {
+			return execSync("termux-clipboard-get", { encoding: "utf8", timeout: 2000 }).toString();
+		}
+		const hasWaylandDisplay = Boolean(process.env.WAYLAND_DISPLAY);
+		const hasX11Display = Boolean(process.env.DISPLAY);
+		if (hasWaylandDisplay) {
+			try {
+				return execSync("wl-paste --type text/plain --no-newline", { encoding: "utf8", timeout: 2000 }).toString();
+			} catch {
+				if (hasX11Display) {
+					return execSync("xclip -selection clipboard -o", { encoding: "utf8", timeout: 2000 }).toString();
+				}
+			}
+		} else if (hasX11Display) {
+			return execSync("xclip -selection clipboard -o", { encoding: "utf8", timeout: 2000 }).toString();
+		}
+	} catch (error) {
+		logger.warn("clipboard: failed to read clipboard text", { error: String(error) });
+	}
+	return "";
+}

package/src/utils/git.ts

@@ -189,11 +189,7 @@ function formatCommandFailure(
 	return `git ${args.join(" ")} failed with exit code ${result.exitCode}`;
 }
 
-async function runCommand(
-	cwd: string,
-	args: readonly string[],
-	options: CommandOptions = {},
-): Promise<GitCommandResult> {
+async function git(cwd: string, args: readonly string[], options: CommandOptions = {}): Promise<GitCommandResult> {
 	const commandArgs = withShortLivedGitConfig(options.readOnly ? withNoOptionalLocks(args) : [...args]);
 	const child = Bun.spawn(["git", ...commandArgs], {
 		cwd,
@@ -248,7 +244,7 @@ async function runChecked(
 	options: CommandOptions = {},
 ): Promise<GitCommandResult> {
 	ensureAvailable();
-	const result = await runCommand(cwd, args, options);
+	const result = await git(cwd, args, options);
 	if (result.exitCode !== 0) {
 		throw new GitCommandError(args, result);
 	}
@@ -269,7 +265,7 @@ async function tryText(
 	options: CommandOptions = {},
 ): Promise<string | undefined> {
 	ensureAvailable();
-	const result = await runCommand(cwd, args, options);
+	const result = await git(cwd, args, options);
 	if (result.exitCode !== 0) return undefined;
 	return result.stdout;
 }
@@ -709,7 +705,7 @@ export const diff = Object.assign(
 	async function diff(cwd: string, options: DiffOptions = {}): Promise<string> {
 		const args = buildDiffArgs(options);
 		if (options.allowFailure) {
-			return (await runCommand(cwd, args, { env: options.env, readOnly: true, signal: options.signal })).stdout;
+			return (await git(cwd, args, { env: options.env, readOnly: true, signal: options.signal })).stdout;
 		}
 		return runText(cwd, args, { env: options.env, readOnly: true, signal: options.signal });
 	},
@@ -741,7 +737,7 @@ export const diff = Object.assign(
 			if (options.cached) args.push("--cached");
 			args.push("--quiet");
 			if (options.files?.length) args.push("--", ...options.files);
-			const result = await runCommand(cwd, args, { readOnly: true, signal: options.signal });
+			const result = await git(cwd, args, { readOnly: true, signal: options.signal });
 			if (result.exitCode === 0) return false;
 			if (result.exitCode === 1) return true;
 			throw new GitCommandError(args, result);
@@ -757,7 +753,7 @@ export const diff = Object.assign(
 			if (options.binary) args.push("--binary");
 			args.push(base, headRef);
 			if (options.allowFailure) {
-				return (await runCommand(cwd, args, { readOnly: true, signal: options.signal })).stdout;
+				return (await git(cwd, args, { readOnly: true, signal: options.signal })).stdout;
 			}
 			return runText(cwd, args, { readOnly: true, signal: options.signal });
 		},
@@ -789,7 +785,7 @@ export const status = Object.assign(
 	{
 		/** Parsed status counts (staged, unstaged, untracked). */
 		async summary(cwd: string, signal?: AbortSignal): Promise<GitStatusSummary | null> {
-			const result = await runCommand(cwd, ["status", "--porcelain"], { readOnly: true, signal });
+			const result = await git(cwd, ["status", "--porcelain"], { readOnly: true, signal });
 			if (result.exitCode !== 0) return null;
 			return parseStatusPorcelain(result.stdout);
 		},
@@ -950,7 +946,7 @@ export const branch = {
 	async current(cwd: string, signal?: AbortSignal): Promise<string | null> {
 		const headState = await resolveHead(cwd);
 		if (headState?.kind === "ref") return headState.branchName ?? headState.ref;
-		const result = await runCommand(cwd, ["symbolic-ref", "--short", "HEAD"], { readOnly: true, signal });
+		const result = await git(cwd, ["symbolic-ref", "--short", "HEAD"], { readOnly: true, signal });
 		if (result.exitCode !== 0) return null;
 		return result.stdout.trim() || null;
 	},
@@ -966,7 +962,7 @@ export const branch = {
 			}
 		}
 		for (const remoteRef of ["origin/HEAD", "upstream/HEAD"]) {
-			const result = await runCommand(cwd, ["rev-parse", "--abbrev-ref", remoteRef], { readOnly: true, signal });
+			const result = await git(cwd, ["rev-parse", "--abbrev-ref", remoteRef], { readOnly: true, signal });
 			if (result.exitCode !== 0) continue;
 			const branchName = stripRemotePrefix(result.stdout.trim());
 			if (branchName) return branchName;
@@ -995,7 +991,7 @@ export const branch = {
 		name: string,
 		options: { force?: boolean; signal?: AbortSignal } = {},
 	): Promise<boolean> {
-		const result = await runCommand(cwd, ["branch", options.force === false ? "-d" : "-D", name], {
+		const result = await git(cwd, ["branch", options.force === false ? "-d" : "-D", name], {
 			signal: options.signal,
 		});
 		return result.exitCode === 0;
@@ -1038,7 +1034,7 @@ export const remote = {
 	 * needs to resolve, not paper over.
 	 */
 	async add(cwd: string, name: string, url: string, signal?: AbortSignal): Promise<void> {
-		const result = await runCommand(cwd, ["remote", "add", name, url], { signal });
+		const result = await git(cwd, ["remote", "add", name, url], { signal });
 		if (result.exitCode === 0) return;
 		if (REMOTE_ALREADY_EXISTS.test(result.stderr)) {
 			const existing = await remote.url(cwd, name, signal);
@@ -1059,7 +1055,7 @@ export const ref = {
 		if (refName === "HEAD") return (await head.sha(cwd, signal)) !== null;
 		const repository = await resolveRepository(cwd);
 		if (repository && refName.startsWith("refs/")) return (await readRef(repository, refName)) !== null;
-		const result = await runCommand(cwd, ["show-ref", "--verify", "--quiet", refName], { readOnly: true, signal });
+		const result = await git(cwd, ["show-ref", "--verify", "--quiet", refName], { readOnly: true, signal });
 		return result.exitCode === 0;
 	},
 
@@ -1068,7 +1064,7 @@ export const ref = {
 		if (refName === "HEAD") return head.sha(cwd, signal);
 		const repository = await resolveRepository(cwd);
 		if (repository && refName.startsWith("refs/")) return readRef(repository, refName);
-		const result = await runCommand(cwd, ["rev-parse", refName], { readOnly: true, signal });
+		const result = await git(cwd, ["rev-parse", refName], { readOnly: true, signal });
 		if (result.exitCode !== 0) return null;
 		return result.stdout.trim() || null;
 	},
@@ -1150,7 +1146,7 @@ export const worktree = {
 		const args = ["worktree", "remove"];
 		if (options.force ?? true) args.push("-f");
 		args.push(worktreePath);
-		const result = await runCommand(cwd, args, { signal: options.signal });
+		const result = await git(cwd, args, { signal: options.signal });
 		return result.exitCode === 0;
 	},
 
@@ -1186,7 +1182,7 @@ export const patch = {
 
 	/** Check if a patch file can be applied cleanly. */
 	async canApply(cwd: string, patchPath: string, options: Omit<PatchOptions, "check"> = {}): Promise<boolean> {
-		const result = await runCommand(cwd, buildApplyArgs(patchPath, { ...options, check: true }), {
+		const result = await git(cwd, buildApplyArgs(patchPath, { ...options, check: true }), {
 			env: options.env,
 			readOnly: true,
 			signal: options.signal,
@@ -1346,7 +1342,7 @@ export const ls = {
 
 	/** List submodule paths (recursive). */
 	async submodules(cwd: string, signal?: AbortSignal): Promise<string[]> {
-		const output = await runCommand(cwd, ["submodule", "--quiet", "foreach", "--recursive", "echo $sm_path"], {
+		const output = await git(cwd, ["submodule", "--quiet", "foreach", "--recursive", "echo $sm_path"], {
 			readOnly: true,
 			signal,
 		});
@@ -1381,14 +1377,14 @@ export const head = {
 	async sha(cwd: string, signal?: AbortSignal): Promise<string | null> {
 		const headState = await head.resolve(cwd);
 		if (headState?.commit) return headState.commit;
-		const result = await runCommand(cwd, ["rev-parse", "HEAD"], { readOnly: true, signal });
+		const result = await git(cwd, ["rev-parse", "HEAD"], { readOnly: true, signal });
 		if (result.exitCode !== 0) return null;
 		return result.stdout.trim() || null;
 	},
 
 	/** Abbreviated HEAD commit SHA. */
 	async short(cwd: string, length = 7, signal?: AbortSignal): Promise<string | null> {
-		const result = await runCommand(cwd, ["rev-parse", `--short=${length}`, "HEAD"], { readOnly: true, signal });
+		const result = await git(cwd, ["rev-parse", `--short=${length}`, "HEAD"], { readOnly: true, signal });
 		if (result.exitCode !== 0) return null;
 		return result.stdout.trim() || null;
 	},
@@ -1403,7 +1399,7 @@ export const repo = {
 	async root(cwd: string, signal?: AbortSignal): Promise<string | null> {
 		const repository = await resolveRepository(cwd);
 		if (repository) return repository.repoRoot;
-		const result = await runCommand(cwd, ["rev-parse", "--show-toplevel"], { readOnly: true, signal });
+		const result = await git(cwd, ["rev-parse", "--show-toplevel"], { readOnly: true, signal });
 		if (result.exitCode !== 0) return null;
 		return result.stdout.trim() || null;
 	},