pi-hashline-edit-pro 2.6.4 → 2.7.0

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, HASH_SEP } 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 });
+  } 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(`${norm.fileHashes[idx]}${HASH_SEP}${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/hashline/apply.ts

@@ -55,7 +55,7 @@ type NoopSpan = {
 function assertNotEmpty(originalContent: string, result: string): void {
 	if (originalContent.length > 0 && result.length === 0) {
 		throw new Error(
-			"[E_WOULD_EMPTY] Cannot empty a non-empty file via edit. Use `write` if you need to clear the file."
+			"[E_WOULD_EMPTY] A replace cannot empty a non-empty file. Use `write` to clear the file."
 		);
 	}
 }

package/src/hashline/hash.ts

@@ -70,7 +70,7 @@ function nextZeroBit(bits: Uint32Array, start: number): number {
     if (idx >= totalBits) idx -= totalBits;
   }
   throw new Error(
-    `[E_FILE_TOO_LARGE] Cannot allocate a unique hash anchor: the file exceeds the ${HASH_SPACE}-line limit for ${HASH_LEN}-char hashline anchors. For very large files use write or a non-line-based approach.`,
+    `[E_FILE_TOO_LARGE] File exceeds the ${HASH_SPACE}-line hashline limit; use write for very large files.`,
   );
 }
 

package/src/hashline/index.ts

@@ -27,6 +27,8 @@ export {
 	type BDup,
 	type AutoFix,
 	resEdit,
+	stripAnchorRow,
+	resolveAnchorLine,
 	valEdit,
 	stripBarePrefixes,
 	stripDiffPrefixes,

package/src/hashline/parse.ts

@@ -14,11 +14,11 @@ function diagRef(ref: string): string {
 	}
 
 	if (/^\d+/.test(trimmed)) {
-		return `[E_BAD_REF] Invalid anchor. Use the hash alone (e.g. "aB3") — no line numbers or trailing content.`;
+		return `[E_BAD_REF] Invalid anchor. Use the hash alone (e.g. "aB3"): no line numbers or trailing content.`;
 	}
 
 	if (trimmed.includes("│")) {
-		return `[E_BAD_REF] Invalid anchor "${trimmed}". remove_from and remove_to must contain the 3-char hash only — remove everything from "│" onward.`;
+		return `[E_BAD_REF] Invalid anchor "${trimmed}": use only the 3-char hash, drop everything from "│" onward.`;
 	}
 
 	return `[E_BAD_REF] Invalid anchor "${trimmed}". Expected a 3-char alphanumeric anchor (e.g. "aB3").`;
@@ -52,7 +52,7 @@ export function parseText(edit: string[], warnings?: string[]): string[] {
   }
   if (split) {
     warnings?.push(
-      "[E_BAD_SHAPE] Autocorrected: split replacement_lines element(s) containing embedded newlines into separate lines.",
+      "[E_BAD_SHAPE] Autocorrected: split embedded newlines in replacement_lines into separate lines.",
     );
   }
   return out;

package/src/hashline/resolve.ts

@@ -90,7 +90,7 @@ export function fmtMismatchWithHashes(
   const refList = notFound.map((m) => `"${m.ref.hash}"`).join(", ");
   if (notFound.length > 0) {
     out.push(
-      `[E_STALE_ANCHOR] ${notFound.length} stale anchor${notFound.length > 1 ? "s" : ""}${filePath ? ` in ${filePath}` : ""}: ${refList}. The file content has changed since those anchors were read. Call read() to get fresh anchors, then copy the 3-char HASH of the start and end of the range you are replacing into remove_from and remove_to of your next replace call.`
+      `[E_STALE_ANCHOR] ${notFound.length} stale anchor${notFound.length > 1 ? "s" : ""}${filePath ? ` in ${filePath}` : ""}: ${refList}. The file changed since read. Call read() for fresh anchors.`
     );
     for (const m of notFound) {
       const ctx = m.context;
@@ -109,7 +109,7 @@ export function fmtMismatchWithHashes(
   if (ambiguous.length > 0) {
     if (out.length > 0) out.push("");
     out.push(
-      `[E_AMBIGUOUS_ANCHOR] ${ambiguous.length} ambiguous anchor${ambiguous.length > 1 ? "s" : ""}${filePath ? ` in ${filePath}` : ""}. Call read() to get fresh anchors, then copy the 3-char HASH of the start and end of the range you are replacing into remove_from and remove_to of your next replace call.`
+      `[E_AMBIGUOUS_ANCHOR] ${ambiguous.length} ambiguous anchor${ambiguous.length > 1 ? "s" : ""}${filePath ? ` in ${filePath}` : ""}. Call read() for fresh anchors.`
     );
     for (const m of ambiguous) {
       const sample = (m.candidates ?? []).slice(0, 5);
@@ -150,7 +150,7 @@ function assertItem(edit: Record<string, unknown>): void {
     );
   }
   if (!("replacement_lines" in edit)) {
-    throw new Error(`[E_BAD_SHAPE] The edit requires a "replacement_lines" field. Provide the replacement lines as an array of strings (use [] to delete).`);
+    throw new Error(`[E_BAD_SHAPE] The edit requires a "replacement_lines" array (use [] to delete).`);
   }
   if (!Array.isArray(edit.replacement_lines) || edit.replacement_lines.some((line) => typeof line !== "string")) {
     throw new Error(NEW_CONTENT_NOT_ARRAY_MSG);
@@ -164,26 +164,29 @@ function assertItem(edit: Record<string, unknown>): void {
 
 export const ANCHOR_ROW_RE = new RegExp(`^([+-]?)(${HASH_RUN})│`);
 
+export function stripAnchorRow(
+	trimmed: string,
+	entryLabel: string,
+	warnings?: string[],
+): string {
+	const match = trimmed.match(ANCHOR_ROW_RE);
+	if (!match) return trimmed;
+	const marker =
+		match[1] === "+"
+			? "diff-preview marker"
+			: match[1] === "-"
+				? 'leading "-" marker'
+				: '"HASH│" prefix';
+	warnings?.push(`[E_BAD_REF] Stripped ${marker} from ${entryLabel} "${trimmed}".`);
+	return match[2]!;
+}
+
 export function resEdit(edit: HTEdit, warnings?: string[]): HEdit {
   assertItem(edit as Record<string, unknown>);
 
   const replaceLines = parseText(edit.replacement_lines, warnings);
   const bounds = [edit.remove_from, edit.remove_to].map((ref) => {
-    const trimmed = ref.trim();
-    const match = trimmed.match(ANCHOR_ROW_RE);
-    if (match) {
-      let message: string;
-      if (match[1] === "+") {
-        message = `[E_BAD_REF] Autocorrected: stripped diff-preview marker copied from the diff preview in remove_from/remove_to entry "${trimmed}".`;
-      } else if (match[1] === "-") {
-        message = `[E_BAD_REF] Autocorrected: stripped leading "-" marker in remove_from/remove_to entry "${trimmed}".`;
-      } else {
-        message = `[E_BAD_REF] Autocorrected: stripped "HASH│" prefix copied from read output in remove_from/remove_to entry "${trimmed}".`;
-      }
-      warnings?.push(message);
-      return match[2]!;
-    }
-    return ref;
+    return stripAnchorRow(ref.trim(), "remove_from/remove_to entry", warnings);
   }) as [string, string];
   return {
     content_lines: replaceLines,
@@ -197,7 +200,7 @@ function warnUnicodeEsc(
 ): void {
   if (edit.content_lines.some((line) => /\\uDDDD/i.test(line))) {
     warnings.push(
-      "Detected literal \\uDDDD in edit content; no autocorrection applied. Verify whether this should be a real Unicode escape or plain text.",
+      "Detected literal \\uDDDD in edit content; no autocorrection applied.",
     );
   }
 }
@@ -220,16 +223,12 @@ export function stripBarePrefixes(
 		.map((s) => `replacement_lines line ${s.lineIndex + 1}`)
 		.join(", ");
 	const matchedCount = stripped.filter((s) => s.matched).length;
-	const evidence =
-		matchedCount === 0
-			? "none of the stripped hashes match current file lines"
-			: `${matchedCount} of ${stripped.length} stripped hash(es) match current file lines`;
 	const guidance =
 		matchedCount === 0
-			? " Verify that these lines were pasted from read output; literal content starting with 'HASH│' would be altered by this strip."
+			? " Verify it was pasted from read output."
 			: "";
 	warnings.push(
-		`[E_BARE_HASH_PREFIX] Autocorrected: stripped "HASH│" prefix copied from read output in ${locations} (${evidence}).${guidance}`
+		`[E_BARE_HASH_PREFIX] Stripped "HASH│" prefix from ${locations}.${guidance}`
 	);
 	return { ...edit, content_lines: contentLines };
 }
@@ -255,7 +254,7 @@ export function stripDiffPrefixes(
 	if (stripped.length === 0) return edit;
 	const locations = stripped.map((i) => `replacement_lines line ${i + 1}`).join(", ");
 	warnings.push(
-		`[E_INVALID_PATCH] Autocorrected: stripped diff-preview marker copied from the diff preview in ${locations}.`
+		`[E_INVALID_PATCH] Stripped diff-preview marker from ${locations}.`
 	);
 	return { ...edit, content_lines: contentLines };
 }
@@ -280,7 +279,7 @@ export function swapReversedRanges(
 		return edit;
 	}
 	warnings.push(
-		`[E_BAD_OP] Autocorrected: remove_from and remove_to were reversed (remove_from ${startRef.hash} is after remove_to ${endRef.hash}); swapped the pair.`
+		`[E_BAD_OP] Autocorrected: remove_from/remove_to were reversed; swapped them.`
 	);
 	return { ...edit, hash_bounds: [endRef, startRef] as [Anchor, Anchor] };
 }
@@ -345,6 +344,7 @@ function firstNewAfterDups(
 	let runLen = 0;
 	while (
 		runLen < maxK &&
+		canonLines[endLine + runLen]!.length > 0 &&
 		canon(contentLines[firstNew.index + runLen]!) === canonLines[endLine + runLen]!
 	) {
 		runLen++;
@@ -369,6 +369,7 @@ function lastNewBeforeDups(
 	let runLen = 0;
 	while (
 		runLen < maxK &&
+		canonLines[startLine - 2 - runLen]!.length > 0 &&
 		canon(contentLines[lastNew.index - runLen]!) === canonLines[startLine - 2 - runLen]!
 	) {
 		runLen++;
@@ -402,8 +403,8 @@ export function findNewEdge(
 	const start = fromEnd ? contentLines.length - 1 : 0;
 	for (let i = start; i >= 0 && i < contentLines.length; i += step) {
 		const line = contentLines[i]!;
-		if (line.length === 0) continue;
 		const key = canon(line);
+		if (key.length === 0) continue;
 		const count = multiset.get(key) ?? 0;
 		if (count > 0) {
 			multiset.set(key, count - 1);
@@ -475,6 +476,31 @@ export function valEdit(
 	};
 }
 
+export function resolveAnchorLine(
+	ref: Anchor,
+	fileLines: string[],
+	fileHashes: string[],
+	filePath?: string,
+): number {
+	const { resolved, mismatches } = valEdit(
+		{ hash_bounds: [ref, ref], content_lines: [] },
+		fileLines,
+		fileHashes,
+		[],
+		undefined,
+	);
+	if (mismatches.length > 0 || !resolved) {
+		const feedback = fmtMismatchWithHashes(
+			mismatches,
+			fileLines,
+			fileHashes,
+			filePath,
+		);
+		throw new AnchorMismatchError(feedback.text, feedback.hashes);
+	}
+	return resolved.hash_bounds[0].line;
+}
+
 export class RangeStaleError extends Error {
   readonly firstMismatchLine: number;
   readonly rangeHashes: string[];
@@ -531,7 +557,7 @@ export function assertRangeServed(
       ? `\n\n[The range has ${rangeLength} lines; showing the first ${shownLength}. Call read() with offset=${startLine + shownLength} to see the rest.]`
       : "";
   const message =
-    `[E_RANGE_STALE] ${mismatchText} what was previously shown: the file changed on disk after the anchors were read, or the line(s) were never shown. Nothing was modified. Current range with fresh anchors:\n\n${rows.join("\n")}${capHint}`;
+    `[E_RANGE_STALE] ${mismatchText} what was shown. Nothing was modified. Current range with fresh anchors:\n\n${rows.join("\n")}${capHint}`;
   throw new RangeStaleError(message, first, shownHashes);
 }