@oh-my-pi/pi-coding-agent 17.2.10 → 17.2.12

package/src/tools/read-sqlite.ts

@@ -0,0 +1,215 @@
+import { Database } from "bun:sqlite";
+import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import type { ToolSession } from "../sdk";
+import { DEFAULT_MAX_LINES, truncateHead } from "../session/streaming-output";
+import { applyListLimit } from "./list-limit";
+import { resolveReadPath } from "./path-utils";
+import type { ReadToolDetails } from "./read";
+import { prependSuffixResolutionNotice } from "./read-format";
+import {
+	findSuffixMatchCached,
+	isNotFoundError,
+	isRemoteMountPath,
+	type SuffixMatchCache,
+} from "./read-path-resolution";
+import {
+	executeReadQuery,
+	getRowByKey,
+	getRowByRowId,
+	getTableSchema,
+	isSqliteFile,
+	listTables,
+	MAX_RAW_QUERY_ROWS,
+	parseSqlitePathCandidates,
+	parseSqliteSelector,
+	queryRows,
+	renderRow,
+	renderSchema,
+	renderTable,
+	renderTableList,
+	resolveTableRowLookup,
+} from "./sqlite-reader";
+import { ToolError, throwIfAborted } from "./tool-errors";
+import { toolResult } from "./tool-result";
+
+interface ResolvedSqliteReadPath {
+	absolutePath: string;
+	sqliteSubPath: string;
+	queryString: string;
+	suffixResolution?: { from: string; to: string };
+}
+export async function resolveSqliteReadPath(
+	session: ToolSession,
+	readPath: string,
+	suffixCache: SuffixMatchCache,
+	signal?: AbortSignal,
+): Promise<ResolvedSqliteReadPath | null> {
+	const candidates = parseSqlitePathCandidates(readPath);
+	for (const candidate of candidates) {
+		let absolutePath = resolveReadPath(candidate.sqlitePath, session.cwd);
+		let suffixResolution: { from: string; to: string } | undefined;
+
+		try {
+			const stat = await Bun.file(absolutePath).stat();
+			if (stat.isDirectory()) continue;
+			if (!(await isSqliteFile(absolutePath))) continue;
+
+			return {
+				absolutePath,
+				sqliteSubPath: candidate.subPath,
+				queryString: candidate.queryString,
+				suffixResolution,
+			};
+		} catch (error) {
+			if (!isNotFoundError(error) || isRemoteMountPath(absolutePath)) continue;
+
+			const suffixMatch = await findSuffixMatchCached(session, suffixCache, candidate.sqlitePath, signal);
+			if (!suffixMatch) continue;
+
+			try {
+				const retryStat = await Bun.file(suffixMatch.absolutePath).stat();
+				if (retryStat.isDirectory()) continue;
+				if (!(await isSqliteFile(suffixMatch.absolutePath))) continue;
+
+				absolutePath = suffixMatch.absolutePath;
+				suffixResolution = { from: candidate.sqlitePath, to: suffixMatch.displayPath };
+				return {
+					absolutePath,
+					sqliteSubPath: candidate.subPath,
+					queryString: candidate.queryString,
+					suffixResolution,
+				};
+			} catch (retryError) {
+				if (!isNotFoundError(retryError)) {
+					throw retryError;
+				}
+			}
+		}
+	}
+
+	return null;
+}
+export async function readSqlite(
+	resolvedSqlitePath: ResolvedSqliteReadPath,
+	signal?: AbortSignal,
+): Promise<AgentToolResult<ReadToolDetails>> {
+	throwIfAborted(signal);
+
+	const selectorInput = {
+		subPath: resolvedSqlitePath.sqliteSubPath,
+		queryString: resolvedSqlitePath.queryString,
+	};
+	const selector = parseSqliteSelector(selectorInput.subPath, selectorInput.queryString);
+	const details: ReadToolDetails = {
+		resolvedPath: resolvedSqlitePath.absolutePath,
+		suffixResolution: resolvedSqlitePath.suffixResolution,
+	};
+
+	let db: Database | null = null;
+	try {
+		db = new Database(resolvedSqlitePath.absolutePath, { readonly: true, strict: true });
+		db.run("PRAGMA busy_timeout = 3000");
+		throwIfAborted(signal);
+
+		switch (selector.kind) {
+			case "list": {
+				const listLimit = applyListLimit(listTables(db), { limit: 500 });
+				const output = prependSuffixResolutionNotice(
+					renderTableList(listLimit.items),
+					resolvedSqlitePath.suffixResolution,
+				);
+				const truncation = truncateHead(output, { maxLines: Number.MAX_SAFE_INTEGER });
+				details.truncation = truncation.truncated ? truncation : undefined;
+				const resultBuilder = toolResult<ReadToolDetails>(details)
+					.text(truncation.content)
+					.sourcePath(resolvedSqlitePath.absolutePath)
+					.limits({ resultLimit: listLimit.meta.resultLimit?.reached });
+				if (truncation.truncated) {
+					resultBuilder.truncation(truncation, { direction: "head" });
+				}
+				return resultBuilder.done();
+			}
+			case "schema": {
+				const sampleRows = queryRows(db, selector.table, { limit: selector.sampleLimit, offset: 0 });
+				let output = renderSchema(getTableSchema(db, selector.table), {
+					columns: sampleRows.columns,
+					rows: sampleRows.rows,
+				});
+				if (sampleRows.rows.length < sampleRows.totalCount) {
+					const remaining = sampleRows.totalCount - sampleRows.rows.length;
+					output += `\n[${remaining} more rows; append :${selector.table}?limit=20&offset=${sampleRows.rows.length} to the database path to continue]`;
+				}
+				return toolResult<ReadToolDetails>(details)
+					.text(prependSuffixResolutionNotice(output, resolvedSqlitePath.suffixResolution))
+					.sourcePath(resolvedSqlitePath.absolutePath)
+					.done();
+			}
+			case "row": {
+				const lookup = resolveTableRowLookup(db, selector.table);
+				const row =
+					lookup.kind === "pk"
+						? getRowByKey(db, selector.table, lookup, selector.key)
+						: getRowByRowId(db, selector.table, selector.key);
+				if (!row) {
+					return toolResult<ReadToolDetails>(details)
+						.text(
+							prependSuffixResolutionNotice(
+								`No row found in table '${selector.table}' for key '${selector.key}'.`,
+								resolvedSqlitePath.suffixResolution,
+							),
+						)
+						.sourcePath(resolvedSqlitePath.absolutePath)
+						.done();
+				}
+				return toolResult<ReadToolDetails>(details)
+					.text(prependSuffixResolutionNotice(renderRow(row), resolvedSqlitePath.suffixResolution))
+					.sourcePath(resolvedSqlitePath.absolutePath)
+					.done();
+			}
+			case "query": {
+				const page = queryRows(db, selector.table, selector);
+				return toolResult<ReadToolDetails>(details)
+					.text(
+						prependSuffixResolutionNotice(
+							renderTable(page.columns, page.rows, {
+								totalCount: page.totalCount,
+								offset: selector.offset,
+								limit: selector.limit,
+								table: selector.table,
+								dbPath: resolvedSqlitePath.absolutePath,
+							}),
+							resolvedSqlitePath.suffixResolution,
+						),
+					)
+					.sourcePath(resolvedSqlitePath.absolutePath)
+					.done();
+			}
+			case "raw": {
+				const result = executeReadQuery(db, selector.sql);
+				let output = renderTable(result.columns, result.rows, {
+					totalCount: result.rows.length,
+					offset: 0,
+					limit: result.rows.length || DEFAULT_MAX_LINES,
+					table: "query",
+					dbPath: resolvedSqlitePath.absolutePath,
+				});
+				if (result.truncated) {
+					output += `\n[Output capped at ${MAX_RAW_QUERY_ROWS} rows; add a LIMIT/OFFSET clause to the query to page through more]`;
+				}
+				return toolResult<ReadToolDetails>(details)
+					.text(prependSuffixResolutionNotice(output, resolvedSqlitePath.suffixResolution))
+					.sourcePath(resolvedSqlitePath.absolutePath)
+					.done();
+			}
+		}
+
+		throw new ToolError("Unsupported SQLite selector");
+	} catch (error) {
+		if (error instanceof ToolError) {
+			throw error;
+		}
+		throw new ToolError(error instanceof Error ? error.message : String(error));
+	} finally {
+		db?.close();
+	}
+}

package/src/tools/read-summary.ts

@@ -0,0 +1,199 @@
+import * as path from "node:path";
+import { type SummaryResult, summarizeCode } from "@oh-my-pi/pi-natives";
+import { LRUCache } from "@oh-my-pi/pi-utils/lru";
+import { isMarkdownPath } from "../modes/theme/theme";
+import type { ToolSession } from "../sdk";
+import { resolveFileDisplayMode } from "../utils/file-display-mode";
+import {
+	canMergeBracePair,
+	countTextLines,
+	type ElidedRange,
+	formatMergedBraceLine,
+	formatSingleLine,
+} from "./read-format";
+import { throwIfAborted } from "./tool-errors";
+
+// Per-session memo for tree-sitter summaries. `summarizeCode` is a pure function
+// of (code, path, fold settings) but costs ~12-18ms for a ~1500-line file, and a
+// repeat summary read of the same unchanged file re-parses from scratch. Key on
+// the content hash of the freshly-read bytes (+ path + fold settings): the file
+// is still read fresh on every call, so a hit only reuses the deterministic
+// parse — there is no staleness window and no stat guard is needed. Bounded LRU,
+// aged out with the session via WeakMap.
+// Unusable results (not parsed, or nothing elided) are memoized as `false`: the
+// full SummaryResult embeds the whole source in kept segments, and the caller
+// only ever renders `parsed && elided` summaries — caching the segments would
+// retain up to 48 near-2MiB sources just to remember "no summary".
+const SUMMARY_CACHE_MAX = 48;
+const summaryParseCaches = new WeakMap<object, LRUCache<string, SummaryResult | false>>();
+function getSummaryParseCache(session: object): LRUCache<string, SummaryResult | false> {
+	let cache = summaryParseCaches.get(session);
+	if (!cache) {
+		cache = new LRUCache<string, SummaryResult | false>({ max: SUMMARY_CACHE_MAX });
+		summaryParseCaches.set(session, cache);
+	}
+	return cache;
+}
+const MAX_SUMMARY_BYTES = 2 * 1024 * 1024;
+const MAX_SUMMARY_LINES = 20_000;
+/**
+ * Prose files (Markdown flavors and plain text) skip code-block summarization
+ * unless `read.summarize.prose` opts them in.
+ */
+export function isProseSummaryPath(filePath: string): boolean {
+	return isMarkdownPath(filePath) || path.extname(filePath).toLowerCase() === ".txt";
+}
+export function routeReadThroughBridge(
+	session: ToolSession,
+	absolutePath: string,
+	options?: { line?: number; limit?: number },
+): Promise<string> | undefined {
+	const bridge = session.getClientBridge?.();
+	if (!bridge?.capabilities.readTextFile || !bridge.readTextFile) return undefined;
+	return bridge.readTextFile({ path: absolutePath, ...options });
+}
+export async function trySummarize(
+	session: ToolSession,
+	absolutePath: string,
+	fileSize: number,
+	signal?: AbortSignal,
+): Promise<SummaryResult | null> {
+	if (fileSize > MAX_SUMMARY_BYTES) return null;
+
+	try {
+		throwIfAborted(signal);
+		const bridgePromise = routeReadThroughBridge(session, absolutePath);
+		const code =
+			bridgePromise !== undefined
+				? await bridgePromise.catch(() => Bun.file(absolutePath).text())
+				: await Bun.file(absolutePath).text();
+		throwIfAborted(signal);
+		const lineCount = countTextLines(code);
+		if (lineCount > MAX_SUMMARY_LINES) return null;
+		if (lineCount < session.settings.get("read.summarize.minTotalLines")) return null;
+
+		const minBodyLines = session.settings.get("read.summarize.minBodyLines");
+		const minCommentLines = session.settings.get("read.summarize.minCommentLines");
+		const unfoldUntilLines = session.settings.get("read.summarize.unfoldUntil");
+		const unfoldLimitLines = session.settings.get("read.summarize.unfoldLimit");
+		const cache = getSummaryParseCache(session);
+		const cacheKey = `${absolutePath}\0${Bun.hash(code)}\0${minBodyLines},${minCommentLines},${unfoldUntilLines},${unfoldLimitLines}`;
+		const memoized = cache.get(cacheKey);
+		if (memoized !== undefined) return memoized || null;
+		const result = summarizeCode({
+			code,
+			path: absolutePath,
+			minBodyLines,
+			minCommentLines,
+			unfoldUntilLines,
+			unfoldLimitLines,
+		});
+		const usable = result.parsed && result.elided ? result : false;
+		cache.set(cacheKey, usable);
+		return usable || null;
+	} catch {
+		return null;
+	}
+}
+
+export function renderSummary(
+	session: ToolSession,
+	summary: SummaryResult,
+): {
+	text: string;
+	displayText: string;
+	elidedRanges: ElidedRange[];
+	elidedLines: number;
+} {
+	const displayMode = resolveFileDisplayMode(session);
+	const shouldAddHashLines = displayMode.hashLines;
+	const shouldAddLineNumbers = shouldAddHashLines ? false : displayMode.lineNumbers;
+
+	// Flatten segments into per-line units so we can merge a kept-head /
+	// elided / kept-tail sandwich into a single brace-pair line when the
+	// boundary lines look like `… {` and `}` (or matching variants).
+	type Unit =
+		| { kind: "line"; line: number; text: string }
+		| { kind: "elided"; startLine: number; endLine: number }
+		| {
+				kind: "merged";
+				startLine: number;
+				endLine: number;
+				headText: string;
+				tailText: string;
+		  };
+
+	const raw: Unit[] = [];
+	for (const segment of summary.segments) {
+		if (segment.kind === "elided") {
+			raw.push({ kind: "elided", startLine: segment.startLine, endLine: segment.endLine });
+			continue;
+		}
+		const text = segment.text ?? "";
+		if (text.length === 0) continue;
+		const lines = text.split("\n");
+		for (let i = 0; i < lines.length; i++) {
+			raw.push({ kind: "line", line: segment.startLine + i, text: lines[i] });
+		}
+	}
+
+	const units: Unit[] = [];
+	let i = 0;
+	while (i < raw.length) {
+		const cur = raw[i];
+		if (cur.kind === "elided") {
+			const prev = units.length > 0 ? units[units.length - 1] : null;
+			const next = i + 1 < raw.length ? raw[i + 1] : null;
+			if (prev?.kind === "line" && next?.kind === "line" && canMergeBracePair(prev.text, next.text)) {
+				units.pop();
+				units.push({
+					kind: "merged",
+					startLine: prev.line,
+					endLine: next.line,
+					headText: prev.text,
+					tailText: next.text,
+				});
+				i += 2;
+				continue;
+			}
+		}
+		units.push(cur);
+		i++;
+	}
+
+	const modelParts: string[] = [];
+	const displayParts: string[] = [];
+	const elidedRanges: ElidedRange[] = [];
+	let elidedLines = 0;
+	for (const unit of units) {
+		if (unit.kind === "elided") {
+			modelParts.push("…");
+			displayParts.push("…");
+			elidedRanges.push({ start: unit.startLine, end: unit.endLine });
+			elidedLines += unit.endLine - unit.startLine + 1;
+			continue;
+		}
+		if (unit.kind === "merged") {
+			const formatted = formatMergedBraceLine(
+				unit.startLine,
+				unit.endLine,
+				unit.headText,
+				unit.tailText,
+				shouldAddHashLines,
+				shouldAddLineNumbers,
+			);
+			modelParts.push(formatted.model);
+			displayParts.push(formatted.display);
+			// Suggest the full brace range so re-reading shows both braces
+			// plus the elided body in one shot.
+			elidedRanges.push({ start: unit.startLine, end: unit.endLine });
+			// Merged brace pair encloses (start+1)..(end-1) as elided.
+			elidedLines += Math.max(0, unit.endLine - unit.startLine - 1);
+			continue;
+		}
+		modelParts.push(formatSingleLine(unit.line, unit.text, shouldAddHashLines, shouldAddLineNumbers));
+		displayParts.push(unit.text);
+	}
+
+	return { text: modelParts.join("\n"), displayText: displayParts.join("\n"), elidedRanges, elidedLines };
+}