pi-hashline-edit-pro 2.6.5 → 2.7.1

package/src/grep.ts

@@ -0,0 +1,323 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { readdir, stat } from "fs/promises";
+import { dirname, join, relative } from "path";
+import { loadFileKindAndText } from "./file-kind";
+import { readNormFile } from "./file-reader";
+import { MAX_HASH_LINES, fmtRow } from "./hashline";
+import { toCwd } from "./paths";
+import { loadP, loadGuide } from "./prompts";
+import { normReq } from "./replace-normalize";
+import { recordServedSafe } from "./served";
+import { abortIf, errCode, isRec, makePrepareArguments, rejectUnknownFields, visLines } from "./utils";
+
+const GREP_KS = new Set(["pattern", "path", "glob", "context", "ignoreCase", "literal", "limit"]);
+const SKIP_DIRS = new Set(["node_modules", ".git", ".tmp", "coverage"]);
+const MAX_SCAN_FILES = 4000;
+const MAX_SHOWN_ROWS = 2000;
+
+export interface GrepReq {
+  pattern: string;
+  path?: string;
+  glob?: string;
+  context?: number;
+  ignoreCase?: boolean;
+  literal?: boolean;
+  limit?: number;
+}
+
+export function assertGrepReq(request: unknown): asserts request is GrepReq {
+  if (!isRec(request)) {
+    throw new Error("[E_BAD_SHAPE] Grep request must be an object.");
+  }
+  rejectUnknownFields(request, GREP_KS, "Grep request");
+  if (typeof request.pattern !== "string" || request.pattern.length === 0) {
+    throw new Error('[E_BAD_SHAPE] Grep request requires a non-empty "pattern" string.');
+  }
+  if (request.context !== undefined && (typeof request.context !== "number" || !Number.isInteger(request.context) || request.context < 0)) {
+    throw new Error('[E_BAD_SHAPE] Grep request field "context" must be a non-negative integer.');
+  }
+  if (request.limit !== undefined && (typeof request.limit !== "number" || !Number.isInteger(request.limit) || request.limit < 1)) {
+    throw new Error('[E_BAD_SHAPE] Grep request field "limit" must be a positive integer.');
+  }
+}
+
+function buildRegex(pattern: string, literal: boolean, ignoreCase: boolean): RegExp {
+  const source = literal ? pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") : pattern;
+  try {
+    return new RegExp(source, ignoreCase ? "ui" : "u");
+  } catch {
+    throw new Error(`[E_BAD_SHAPE] Invalid pattern: ${pattern}`);
+  }
+}
+
+function globToRegex(glob: string): RegExp {
+  let source = "";
+  let i = 0;
+  while (i < glob.length) {
+    const ch = glob[i]!;
+    if (ch === "*") {
+      if (glob[i + 1] === "*") {
+        i += 2;
+        if (glob[i] === "/") {
+          i += 1;
+          source += "(?:.*\\/)?";
+        } else {
+          source += ".*";
+        }
+        continue;
+      }
+      source += ".*";
+    } else if (ch === "?") {
+      source += "[^/]";
+    } else {
+      source += ch.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    }
+    i += 1;
+  }
+  return new RegExp(`^${source}$`);
+}
+
+function isSkipableLoadError(error: unknown): boolean {
+  const code = errCode(error);
+  if (code === "EACCES" || code === "EPERM" || code === "ENOENT" || code === "ELOOP") return true;
+  return error instanceof Error && error.message.startsWith("[E_FILE_TOO_LARGE]");
+}
+
+interface FileHit {
+  path: string;
+  displayPath: string;
+  fileHashes: string[];
+  rows: string[];
+  hashes: string[];
+  matchCount: number;
+  totalMatchCount: number;
+}
+
+interface ScanState {
+  scanned: number;
+  stopped: boolean;
+}
+
+async function walkFiles(
+  root: string,
+  state: ScanState,
+  onFile: (absPath: string) => Promise<void>,
+): Promise<void> {
+  const queue: string[] = [root];
+  while (queue.length > 0 && !state.stopped) {
+    const dir = queue.pop()!;
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (state.stopped) break;
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS.has(entry.name)) continue;
+        queue.push(full);
+      } else if (entry.isFile()) {
+        state.scanned += 1;
+        if (state.scanned > MAX_SCAN_FILES) {
+          state.stopped = true;
+          break;
+        }
+        await onFile(full);
+      }
+    }
+  }
+}
+
+async function searchFile(
+  absPath: string,
+  globRoot: string,
+  cwd: string,
+  regex: RegExp,
+  globRegex: RegExp | undefined,
+  context: number,
+  maxMatches: number,
+): Promise<FileHit | undefined> {
+  const displayPath = relative(cwd, absPath).replace(/\\/g, "/");
+  if (globRegex) {
+    const globPath = relative(globRoot, absPath).replace(/\\/g, "/");
+    if (!globRegex.test(globPath)) return undefined;
+  }
+  let file;
+  try {
+    file = await loadFileKindAndText(absPath, { maxLines: MAX_HASH_LINES, displayPath });
+  } catch (error) {
+    if (isSkipableLoadError(error)) return undefined;
+    throw error;
+  }
+  if (file.kind !== "text") return undefined;
+  let norm;
+  try {
+    norm = await readNormFile(absPath, cwd, { maxLines: MAX_HASH_LINES, preloadedFile: file, noPersist: true });
+  } catch (error) {
+    if (isSkipableLoadError(error)) return undefined;
+    throw error;
+  }
+  const lines = visLines(norm.normalized);
+  const matchLines: number[] = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (regex.test(lines[i]!)) matchLines.push(i);
+  }
+  if (matchLines.length === 0) return undefined;
+  const keptMatches = matchLines.length > maxMatches ? matchLines.slice(0, maxMatches) : matchLines;
+  const shown = new Set<number>();
+  for (const i of keptMatches) {
+    for (let j = Math.max(0, i - context); j <= Math.min(lines.length - 1, i + context); j++) shown.add(j);
+  }
+  const sorted = [...shown].sort((a, b) => a - b);
+  const rows: string[] = [];
+  const hashes: string[] = [];
+  for (const idx of sorted) {
+    rows.push(fmtRow(norm.fileHashes[idx]!, lines[idx]!));
+    hashes.push(norm.fileHashes[idx]!);
+  }
+  return {
+    path: norm.absolutePath,
+    displayPath,
+    fileHashes: norm.fileHashes,
+    rows,
+    hashes,
+    matchCount: keptMatches.length,
+    totalMatchCount: matchLines.length,
+  };
+}
+
+const grepToolSchema = Type.Object(
+  {
+    pattern: Type.String({
+      description: "Search pattern (regex or literal string)",
+    }),
+    path: Type.Optional(
+      Type.String({
+        description: "Directory or file to search (default: current directory)",
+      }),
+    ),
+    glob: Type.Optional(
+      Type.String({
+        description: "Filter files by glob pattern; * matches across directories, e.g. '*.ts' or '**/*.spec.ts'",
+      }),
+    ),
+    ignoreCase: Type.Optional(
+      Type.Boolean({
+        description: "Case-insensitive search (default: false)",
+      }),
+    ),
+    literal: Type.Optional(
+      Type.Boolean({
+        description: "Treat pattern as literal string instead of regex (default: false)",
+      }),
+    ),
+    context: Type.Optional(
+      Type.Integer({
+        minimum: 0,
+        description: "Number of lines to show before and after each match (default: 0)",
+      }),
+    ),
+    limit: Type.Optional(
+      Type.Integer({
+        minimum: 1,
+        description: "Maximum number of matches to return (default: 100)",
+      }),
+    ),
+  },
+  { additionalProperties: false },
+);
+
+export function regGrep(pi: ExtensionAPI): void {
+  pi.registerTool({
+    name: "grep",
+    label: "Grep",
+    description: loadP("../prompts/grep.md"),
+    promptSnippet: loadP("../prompts/grep-snippet.md"),
+    promptGuidelines: loadGuide("../prompts/grep-guidelines.md"),
+    prepareArguments: makePrepareArguments(),
+    parameters: grepToolSchema,
+
+    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+      const canonical = normReq(params);
+      assertGrepReq(canonical);
+      const req = canonical;
+      const regex = buildRegex(req.pattern, req.literal === true, req.ignoreCase === true);
+      const context = req.context ?? 0;
+      const limit = req.limit ?? 100;
+      const globRegex = req.glob === undefined ? undefined : globToRegex(req.glob);
+      const base = req.path ? toCwd(req.path, ctx.cwd) : ctx.cwd;
+      abortIf(signal);
+      let baseStat;
+      try {
+        baseStat = await stat(base);
+      } catch (error) {
+        if (errCode(error) === "ENOENT") {
+          throw new Error(`[E_NOT_FOUND] File not found: ${req.path ?? ctx.cwd}`);
+        }
+        throw new Error(`[E_ACCESS] Cannot access path: ${req.path ?? ctx.cwd}`);
+      }
+      const globRoot = baseStat.isFile() ? dirname(base) : base;
+      const state: ScanState = { scanned: 0, stopped: false };
+      const files: string[] = [];
+      if (baseStat.isFile()) {
+        files.push(base);
+      } else {
+        await walkFiles(base, state, async (absPath) => {
+          files.push(absPath);
+        });
+      }
+      const hits: FileHit[] = [];
+      let matches = 0;
+      let limitTruncated = false;
+      let rowTruncated = false;
+      let rowCount = 0;
+      for (const absPath of files) {
+        abortIf(signal);
+        const remaining = limit - matches;
+        if (remaining <= 0) {
+          limitTruncated = true;
+          break;
+        }
+        const hit = await searchFile(absPath, globRoot, ctx.cwd, regex, globRegex, context, remaining);
+        if (!hit) continue;
+        const rowBudget = MAX_SHOWN_ROWS - rowCount;
+        if (rowBudget <= 0) {
+          rowTruncated = true;
+          break;
+        }
+        const keptRows = hit.rows.slice(0, rowBudget);
+        const keptHashes = hit.hashes.slice(0, rowBudget);
+        rowCount += keptRows.length;
+        if (hit.totalMatchCount > hit.matchCount) limitTruncated = true;
+        if (keptRows.length < hit.rows.length) rowTruncated = true;
+        matches += hit.matchCount;
+        hits.push({ ...hit, rows: keptRows, hashes: keptHashes });
+      }
+      for (const hit of hits) {
+        await recordServedSafe(hit.path, hit.hashes, "grep", new Set(hit.fileHashes));
+      }
+      const blocks = hits
+        .map((hit) => `=== ${hit.displayPath} ===\n${hit.rows.join("\n")}`)
+        .join("\n");
+      const notes: string[] = [];
+      if (rowTruncated) notes.push(`[grep: output truncated at ${MAX_SHOWN_ROWS} rows; refine the pattern to see more.]`);
+      if (limitTruncated) notes.push(`[grep: showing first ${limit} matches; increase limit to see more.]`);
+      if (state.stopped) notes.push(`[grep: scan cap of ${MAX_SCAN_FILES} files reached; results may be incomplete.]`);
+      const truncated = limitTruncated || rowTruncated;
+      const text = blocks.length > 0 ? `${blocks}${notes.length > 0 ? `\n${notes.join("\n")}` : ""}` : "No matches found.";
+      return {
+        content: [{ type: "text", text }],
+        details: {
+          metrics: {
+            matches,
+            files: hits.length,
+            truncated: truncated || state.stopped,
+          },
+        },
+      };
+    },
+  });
+}

package/src/hash-store.ts

@@ -66,6 +66,7 @@ interface Prepared {
   get: (...params: SqlParams) => Record<string, unknown> | undefined;
   allPaths: (...params: SqlParams) => Record<string, unknown>[];
   allHashes: (...params: SqlParams) => Record<string, unknown>[];
+  allServed: (...params: SqlParams) => Record<string, unknown>[];
   deleteOne: (...params: SqlParams) => void;
   upsert: (...params: SqlParams) => void;
   undoUpsert: (...params: SqlParams) => void;
@@ -118,6 +119,14 @@ export function parseHashList(raw: string, onInvalid: () => void): string[] | un
   return parsed;
 }
 
+export function parseStoredHashes(
+  row: Record<string, unknown> | undefined,
+  onInvalid: () => void,
+): string[] | undefined {
+  if (!row) return undefined;
+  return parseHashList(row.hashes as string, onInvalid);
+}
+
 function isValidSnapshot(value: unknown): value is LegacySnapshot {
   if (typeof value !== "object" || value === null) return false;
   const v = value as Record<string, unknown>;
@@ -174,6 +183,14 @@ function openDbWithBusyRetry(storePath: string): { db: RawDb; stmts: Prepared }
   return withBusyRetry(() => openDb(storePath));
 }
 
+function retriedWrite(
+  stmt: { run(...params: SqlParams): unknown },
+): (...params: SqlParams) => void {
+  return (...params) => {
+    withBusyRetry(() => { stmt.run(...params); });
+  };
+}
+
 let cachedDb: { path: string; db: RawDb; stmts: Prepared } | null = null;
 let opening: { path: string; promise: Promise<HashStore> } | null = null;
 let exitHandlerRegistered = false;
@@ -238,6 +255,7 @@ function buildStore(
   if (versionRow && versionRow.value !== String(HASH_STORE_VERSION)) {
     db.exec("DELETE FROM snapshots");
     db.exec("DELETE FROM undo");
+    db.exec("DELETE FROM served");
   }
   db.prepare(
     "INSERT INTO meta (key, value) VALUES ('version', ?) " +
@@ -246,6 +264,7 @@ function buildStore(
   const getStmt = db.prepare("SELECT hashes FROM snapshots WHERE path = ? AND checksum = ? AND line_count = ?");
   const allStmt = db.prepare("SELECT path FROM snapshots UNION SELECT path FROM undo UNION SELECT path FROM served");
   const allHashesStmt = db.prepare("SELECT path, hashes FROM snapshots");
+  const allServedStmt = db.prepare("SELECT path, hashes FROM served");
   const delStmt = db.prepare("DELETE FROM snapshots WHERE path = ?");
   const upsertStmt = db.prepare(
     "INSERT INTO snapshots (path, checksum, line_count, hashes, updated_at) VALUES (?, ?, ?, ?, ?) " +
@@ -269,14 +288,15 @@ function buildStore(
     get: (...params) => getStmt.get(...params) as Record<string, unknown> | undefined,
     allPaths: (...params) => allStmt.all(...params) as Record<string, unknown>[],
     allHashes: (...params) => allHashesStmt.all(...params) as Record<string, unknown>[],
-    deleteOne: (...params) => { withBusyRetry(() => { delStmt.run(...params); }); },
-    upsert: (...params) => { withBusyRetry(() => { upsertStmt.run(...params); }); },
-    undoUpsert: (...params) => { withBusyRetry(() => { undoUpsertStmt.run(...params); }); },
+    allServed: (...params) => allServedStmt.all(...params) as Record<string, unknown>[],
+    deleteOne: retriedWrite(delStmt),
+    upsert: retriedWrite(upsertStmt),
+    undoUpsert: retriedWrite(undoUpsertStmt),
     undoGet: (...params) => undoGetStmt.get(...params) as Record<string, unknown> | undefined,
-    undoDelete: (...params) => { withBusyRetry(() => { undoDelStmt.run(...params); }); },
+    undoDelete: retriedWrite(undoDelStmt),
     servedGet: (...params) => servedGetStmt.get(...params) as Record<string, unknown> | undefined,
-    servedUpsert: (...params) => { withBusyRetry(() => { servedUpsertStmt.run(...params); }); },
-    servedDelete: (...params) => { withBusyRetry(() => { servedDelStmt.run(...params); }); },
+    servedUpsert: retriedWrite(servedUpsertStmt),
+    servedDelete: retriedWrite(servedDelStmt),
   };
   return { db, stmts };
 }
@@ -489,8 +509,7 @@ export function getSnapshot(
     return cached.hashes.slice();
   }
   const row = store.stmts.get(path, checksum, lineCount);
-  if (!row) return undefined;
-  const parsed = parseHashList(row.hashes as string, () => {
+  const parsed = parseStoredHashes(row, () => {
     if (deleteCorrupt) store.stmts.deleteOne(path);
     snapshotCache.delete(path);
   });
@@ -525,7 +544,7 @@ export function upsertUndo(store: HashStore, path: string, entry: UndoRecord): v
 export function getUndoEntry(store: HashStore, path: string): UndoRecord | undefined {
   const row = store.stmts.undoGet(path);
   if (!row) return undefined;
-  const parsed = parseHashList(row.hashes as string, () => store.stmts.undoDelete(path));
+  const parsed = parseStoredHashes(row, () => store.stmts.undoDelete(path));
   if (!parsed) return undefined;
   return {
     content: row.content as string,
@@ -571,14 +590,15 @@ export async function pruneMissing(store: HashStore): Promise<void> {
     for (const path of missing) {
       store.stmts.deleteOne(path);
       snapshotCache.delete(path);
-      store.stmts.undoDelete(path);
       store.stmts.servedDelete(path);
     }
   });
 }
 
-export function findSnapshotPaths(store: HashStore, hashes: string[]): string[] {
-  const rows = store.stmts.allHashes() as { path: string; hashes: string }[];
+function matchPathsByHashes(
+  rows: { path: string; hashes: string }[],
+  hashes: string[],
+): string[] {
   const matches: string[] = [];
   for (const row of rows) {
     try {
@@ -591,3 +611,11 @@ export function findSnapshotPaths(store: HashStore, hashes: string[]): string[]
   }
   return matches;
 }
+
+export function findSnapshotPaths(store: HashStore, hashes: string[]): string[] {
+  return matchPathsByHashes(store.stmts.allHashes() as { path: string; hashes: string }[], hashes);
+}
+
+export function findServedPaths(store: HashStore, hashes: string[]): string[] {
+  return matchPathsByHashes(store.stmts.allServed() as { path: string; hashes: string }[], hashes);
+}

package/src/hashline/apply.ts

@@ -1,5 +1,5 @@
 import { abortIf, splitLines } from "../utils";
-import { _lineHashesPure, HASH_SEP } from "./hash";
+import { _lineHashesPure } from "./hash";
 import {
 	valEdit,
 	stripBarePrefixes,
@@ -268,20 +268,7 @@ export function applyEdit(
 	};
 }
 
-export function fmtRegion(
-	hashes: string[],
-	lines: string[],
-): string {
-	if (hashes.length !== lines.length) {
-		throw new Error(
-			`fmtRegion: hashes.length (${hashes.length}) must match lines.length (${lines.length}).`,
-		);
-	}
-	return lines
-		.map((line, index) => `${hashes[index]}${HASH_SEP}${line}`)
-		.join("\n");
-}
-
+export { fmtRegion, fmtRow } from "./resolve";
 export function changedRange(
 	original: string,
 	result: string,

package/src/hashline/hash.ts

@@ -47,6 +47,30 @@ export const HL_PREFIX_MINUS_RE = new RegExp(
 
 export const HL_BARE_PREFIX_RE = new RegExp(`^\\s*(${HASH_RUN})│`);
 
+export type RowPrefixKind = "bare" | "plus" | "minus";
+
+export type StrippedRow = {
+	text: string;
+	kind: RowPrefixKind | null;
+	hash: string | undefined;
+};
+
+export function stripRowPrefix(line: string): StrippedRow {
+	const bare = line.match(HL_BARE_PREFIX_RE);
+	if (bare) {
+		return { text: line.slice(bare[0].length), kind: "bare", hash: bare[1] };
+	}
+	const plus = line.match(HL_PREFIX_PLUS_RE);
+	if (plus) {
+		return { text: line.slice(plus[0].length), kind: "plus", hash: plus[1] };
+	}
+	const minus = line.match(HL_PREFIX_MINUS_RE);
+	if (minus) {
+		return { text: line.slice(minus[0].length), kind: "minus", hash: minus[1] };
+	}
+	return { text: line, kind: null, hash: undefined };
+}
+
 export function canon(line: string): string {
 	return line.replace(/\r/g, "").trimEnd();
 }

package/src/hashline/index.ts

@@ -27,6 +27,8 @@ export {
 	type BDup,
 	type AutoFix,
 	resEdit,
+	stripAnchorRow,
+	resolveAnchorLine,
 	valEdit,
 	stripBarePrefixes,
 	stripDiffPrefixes,
@@ -41,5 +43,6 @@ export {
 	buildIdx,
 	applyEdit,
 	fmtRegion,
+	fmtRow,
 	changedRange,
 } from "./apply";