pi-readseek 0.7.6 → 0.7.8

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "pi-readseek",
-  "version": "0.7.6",
+  "version": "0.7.8",
   "description": "Pi extension for readseek-backed hash-anchored read/edit/grep, structural code maps, structural search, and file exploration",
   "type": "module",
   "exports": {
-    ".": "./index.ts"
+    ".": "./dist/index.js"
   },
   "keywords": [
     "pi-package",
@@ -21,25 +21,26 @@
   "license": "Apache-2.0",
   "pi": {
     "extensions": [
-      "./index.ts"
+      "./dist/index.js"
     ]
   },
   "files": [
-    "index.ts",
-    "src/",
+    "dist/",
     "prompts/",
     "LICENSE",
     "README.md"
   ],
   "scripts": {
-    "test": "node scripts/vitest-run.mjs",
+    "build": "bun build index.ts --outfile dist/index.js --target=node --packages=external",
+    "prepack": "npm run build",
+    "test": "npm run build && node scripts/vitest-run.mjs",
     "typecheck": "tsc --noEmit"
   },
   "engines": {
     "node": ">=20.0.0"
   },
   "dependencies": {
-    "@jarkkojs/readseek": "^0.7.6",
+    "@jarkkojs/readseek": "^0.7.8",
     "diff": "^8.0.3",
     "xxhash-wasm": "^1.1.0"
   },

package/index.ts

@@ -1,147 +0,0 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { registerReadTool } from "./src/read.js";
-import { registerEditTool } from "./src/edit.js";
-import { registerGrepTool } from "./src/grep.js";
-import { registerSearchTool } from "./src/search.js";
-import { registerRefsTool } from "./src/refs.js";
-import { registerRenameTool } from "./src/rename.js";
-import { registerHoverTool } from "./src/hover.js";
-import { registerWriteTool } from "./src/write.js";
-import { registerDefTool } from "./src/def.js";
-import { registerCheckTool } from "./src/check.js";
-import { registerViewTool } from "./src/view.js";
-import { SessionAnchors } from "./src/session-anchors.js";
-import { readSeekBinaryAvailability } from "./src/readseek-client.js";
-import { resolveReadSeekJsonSettings, type ReadSeekSettingsWarning } from "./src/readseek-settings.js";
-
-/** Built-in tool names that pi-readseek can replace with a readSeek-backed implementation. */
-const REPLACEABLE_TOOLS = {
-	read: "readSeek_read",
-	edit: "readSeek_edit",
-	write: "readSeek_write",
-	grep: "readSeek_grep",
-} as const;
-
-type ReplacedBuiltIn = keyof typeof REPLACEABLE_TOOLS;
-
-/**
- * Canonical list of readSeek tools in registration/activation order. Each
- * replaceable entry carries the built-in name it swaps in when replaced; null
- * entries are readSeek-only and never replaced.
- */
-const READSEEK_TOOL_ENTRIES: ReadonlyArray<{ builtIn: ReplacedBuiltIn | null; readSeekName: string }> = [
-	{ builtIn: "read", readSeekName: "readSeek_read" },
-	{ builtIn: "edit", readSeekName: "readSeek_edit" },
-	{ builtIn: "grep", readSeekName: "readSeek_grep" },
-	{ builtIn: null, readSeekName: "readSeek_search" },
-	{ builtIn: null, readSeekName: "readSeek_refs" },
-	{ builtIn: null, readSeekName: "readSeek_rename" },
-	{ builtIn: null, readSeekName: "readSeek_hover" },
-	{ builtIn: "write", readSeekName: "readSeek_write" },
-	{ builtIn: null, readSeekName: "readSeek_def" },
-	{ builtIn: null, readSeekName: "readSeek_check" },
-	{ builtIn: null, readSeekName: "readSeek_view" },
-];
-
-function formatSettingsWarning(warning: ReadSeekSettingsWarning): string {
-	return `${warning.message} (${warning.source})`;
-}
-
-function editingPolicy(readName: string, editName: string, writeName: string): string {
-	return [
-		"ReadSeek editing policy:",
-		`- Prefer ${readName} when preparing to edit existing text; its LINE:HASH anchors are required by ${editName}.`,
-		`- Prefer ${editName} for existing text files, ${writeName} for whole-file creation or replacement, and readSeek_rename for symbol renames.`,
-		"- Do not use Pi's built-in edit or write when the corresponding ReadSeek tool is available.",
-		"- Use readSeek_check after source edits for a quick syntax check.",
-	].join("\n");
-}
-
-export default function piReadSeekExtension(pi: ExtensionAPI): void {
-	const sessionAnchors = new SessionAnchors();
-	const markAnchored = (absolutePath: string) => sessionAnchors.markAnchored(absolutePath);
-	const hasFreshAnchors = (absolutePath: string) => sessionAnchors.hasFreshAnchors(absolutePath);
-	const forgetAnchors = (absolutePath: string) => sessionAnchors.forget(absolutePath);
-
-	// Resolve replacedTools at load time so the readSeek implementation is
-	// registered under the built-in name (e.g. "edit") when replaced. Extension
-	// tool registrations override built-ins of the same name in pi's tool
-	// definition registry, so registering under "edit" makes calls to `edit`
-	// dispatch to the readSeek implementation.
-	const { settings } = resolveReadSeekJsonSettings();
-	const replacedBuiltIns = new Set<ReplacedBuiltIn>(
-		(settings.replacedTools ?? []) as ReplacedBuiltIn[],
-	);
-	// Only swap registration under the built-in name when the readSeek binary
-	// is available; otherwise keep readSeek_* names so pi's built-ins stay
-	// intact and usable.
-	const binaryAvailable = readSeekBinaryAvailability().available;
-	const swap = (builtIn: ReplacedBuiltIn, readSeekName: string) =>
-		binaryAvailable && replacedBuiltIns.has(builtIn) ? builtIn : readSeekName;
-
-	const readName = swap("read", "readSeek_read");
-	const editName = swap("edit", "readSeek_edit");
-	const writeName = swap("write", "readSeek_write");
-	const grepName = swap("grep", "readSeek_grep");
-	const toolAliases = {
-		readSeek_read: readName,
-		readSeek_edit: editName,
-		readSeek_grep: grepName,
-		readSeek_write: writeName,
-	};
-
-	registerReadTool(pi, { onSuccessfulRead: markAnchored, name: readName });
-	registerEditTool(pi, { wasReadInSession: hasFreshAnchors, onFileMutated: forgetAnchors, name: editName, toolAliases });
-	registerGrepTool(pi, { onFileAnchored: markAnchored, name: grepName });
-	registerSearchTool(pi, { onFileAnchored: markAnchored });
-	registerRefsTool(pi, { onFileAnchored: markAnchored });
-	registerRenameTool(pi, { onFileMutated: forgetAnchors });
-	registerHoverTool(pi);
-	registerDefTool(pi, { onFileAnchored: markAnchored });
-	registerCheckTool(pi);
-	registerViewTool(pi);
-	registerWriteTool(pi, { onFileAnchored: markAnchored, name: writeName });
-
-	pi.on("before_agent_start", (event) => {
-		if (!binaryAvailable) return;
-		return { systemPrompt: `${event.systemPrompt}\n\n${editingPolicy(readName, editName, writeName)}` };
-	});
-
-	pi.on("session_start", (_event, ctx) => {
-		sessionAnchors.clear();
-		const { warnings } = resolveReadSeekJsonSettings();
-		const problems = warnings.map(formatSettingsWarning);
-
-		const availability = readSeekBinaryAvailability();
-		if (!availability.available) {
-			problems.push(`readseek tools are inactive: ${availability.reason}`);
-		}
-
-		for (const problem of problems) {
-			if (ctx.hasUI) ctx.ui.notify(problem, "warning");
-			else console.warn(problem);
-		}
-
-		if (!availability.available) return;
-
-		// readSeek tools were registered at load under names chosen from the
-		// load-time replacedTools. Replaced built-ins are registered under the
-		// built-in name, so the built-in stays active (now readSeek-backed);
-		// their readSeek_* variant was never registered and is excluded.
-		const activeReadSeekNames = READSEEK_TOOL_ENTRIES.map((entry) =>
-			entry.builtIn && replacedBuiltIns.has(entry.builtIn) ? entry.builtIn : entry.readSeekName,
-		);
-		const inactiveReadSeekNames = new Set(
-			READSEEK_TOOL_ENTRIES.filter(
-				(entry): entry is { builtIn: ReplacedBuiltIn; readSeekName: string } =>
-					entry.builtIn !== null && replacedBuiltIns.has(entry.builtIn),
-			).map((entry) => entry.readSeekName),
-		);
-
-		const activeTools = [...pi.getActiveTools(), ...activeReadSeekNames].filter(
-			(name) => !inactiveReadSeekNames.has(name),
-		);
-		pi.setActiveTools([...new Set(activeTools)]);
-	});
-
-}

package/src/binary-detect.ts

@@ -1,22 +0,0 @@
-/**
- * Returns true if the buffer appears to contain binary (non-text) content.
- *
- * Detection strategy:
- *   1. NUL byte (0x00) — universally indicates binary
- *   2. Invalid UTF-8 sequences — Node.js decodes them as U+FFFD replacement
- *      characters. To avoid false-positives on valid UTF-8 text that
- *      intentionally contains U+FFFD (encoded as EF BF BD), we do a round-trip
- *      check: if re-encoding the decoded string produces a different byte
- *      sequence, then U+FFFD was introduced by the decoder — not present in
- *      the original bytes as valid UTF-8.
- */
-export function looksLikeBinary(buf: Buffer): boolean {
-  if (buf.length === 0) return false;
-  // Fast path: NUL byte is a reliable binary marker
-  if (buf.includes(0)) return true;
-  const decoded = buf.toString("utf8");
-  if (!decoded.includes("\uFFFD")) return false;
-
-  // If U+FFFD came from invalid byte sequences, re-encoding will differ.
-  return !Buffer.from(decoded, "utf8").equals(buf);
-}

package/src/check.ts

@@ -1,92 +0,0 @@
-import { readFile } from "node:fs/promises";
-
-import type { ExtensionAPI, ToolRenderResultOptions } from "@earendil-works/pi-coding-agent";
-import { Text } from "@earendil-works/pi-tui";
-import { Type } from "@sinclair/typebox";
-
-import { classifyReadSeekFailure, readSeekCheck, type ReadSeekCheckOutput } from "./readseek-client.js";
-import { buildToolErrorResult } from "./readseek-value.js";
-import { defineToolPromptMetadata } from "./tool-prompt-metadata.js";
-import { formatFsError } from "./fs-error.js";
-import { resolveToCwd } from "./path-utils.js";
-import { filePathParam, registerReadSeekTool } from "./register-tool.js";
-import { clampLineToWidth, clampLinesToWidth, linkToolPath, renderErrorResult, renderPendingResult, resolveRenderResultContext, summaryLine } from "./tui-render-utils.js";
-
-const CHECK_PROMPT_METADATA = defineToolPromptMetadata({
-  promptUrl: new URL("../prompts/check.md", import.meta.url),
-  promptSnippet: "Check a source file for parser errors and missing syntax",
-});
-
-export async function executeCheck(opts: {
-  params: unknown;
-  signal: AbortSignal | undefined;
-  cwd: string;
-}): Promise<any> {
-  const { params, signal, cwd } = opts;
-  const p = params as { path: string };
-  const filePath = resolveToCwd(p.path, cwd);
-
-  let content: string;
-  try {
-    content = await readFile(filePath, "utf-8");
-  } catch (err: any) {
-    const { code, message } = formatFsError(err, "check-error");
-    return buildToolErrorResult("check", code, message, { path: p.path });
-  }
-
-  try {
-    const output = await readSeekCheck(filePath, content, { signal });
-    const lines = output.diagnostics.map((diagnostic) =>
-      `${diagnostic.kind}: lines ${diagnostic.start_line}-${diagnostic.end_line}`,
-    );
-    const summary = output.errorCount === 0 && output.missingCount === 0
-      ? "No syntax errors found."
-      : `${output.errorCount} error(s), ${output.missingCount} missing syntax node(s)`;
-    return {
-      content: [{ type: "text", text: [summary, ...lines].join("\n") }],
-      details: {
-        readSeekValue: { tool: "check", ok: true, path: filePath, output },
-      },
-    };
-  } catch (err: any) {
-    const failure = classifyReadSeekFailure(err);
-    return buildToolErrorResult("check", failure.code, failure.message, failure.hint ? { hint: failure.hint } : {});
-  }
-}
-
-export function registerCheckTool(pi: ExtensionAPI) {
-  return registerReadSeekTool(pi, {
-    name: "readSeek_check",
-    label: "Check",
-    description: CHECK_PROMPT_METADATA.description,
-    promptSnippet: CHECK_PROMPT_METADATA.promptSnippet,
-    promptGuidelines: CHECK_PROMPT_METADATA.promptGuidelines,
-    parameters: Type.Object({ path: filePathParam() }),
-    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
-      return executeCheck({ params, signal, cwd: ctx.cwd });
-    },
-    renderCall(args: any, theme: any, ...rest: any[]) {
-      const context = rest[0] ?? {};
-      const cwd = context.cwd ?? process.cwd();
-      const displayPath = typeof args?.path === "string" ? args.path : "?";
-      const text = `${theme.fg("toolTitle", theme.bold("check"))} ${linkToolPath(theme.fg("accent", displayPath), displayPath, cwd)}`;
-      return new Text(clampLineToWidth(text, context.width), 0, 0);
-    },
-    renderResult(result: any, options: ToolRenderResultOptions, theme: any, ...rest: any[]) {
-      const { isPartial, isError, expanded, width } = resolveRenderResultContext(options, rest);
-      if (isPartial) return renderPendingResult("pending check", width, theme);
-      const textContent = result.content?.[0]?.type === "text" ? result.content[0].text : "";
-      if (isError || result.isError) {
-        return renderErrorResult(textContent, { expanded, width, fallback: "check failed", theme });
-      }
-      const output = (result.details as any)?.readSeekValue?.output as ReadSeekCheckOutput | undefined;
-      const issueCount = (output?.errorCount ?? 0) + (output?.missingCount ?? 0);
-      let text = summaryLine(issueCount === 0 ? "syntax valid" : `${issueCount} syntax issue(s)`, {
-        theme,
-        style: issueCount === 0 ? "success" : "warning",
-      });
-      if (expanded && textContent) text += `\n${textContent}`;
-      return new Text(clampLinesToWidth(text.split("\n"), width).join("\n"), 0, 0);
-    },
-  });
-}

package/src/coerce-obvious-int.ts

@@ -1,41 +0,0 @@
-const BASE10_INT_RE = /^-?\d+$/;
-const MIN_SAFE_INTEGER = BigInt(Number.MIN_SAFE_INTEGER);
-const MAX_SAFE_INTEGER = BigInt(Number.MAX_SAFE_INTEGER);
-
-type CoercedIntResult =
-  | { ok: true; value: number | undefined }
-  | { ok: false; message: string };
-
-function formatReceived(value: unknown): string {
-  if (typeof value === "number" || typeof value === "bigint") return String(value);
-  return JSON.stringify(value) ?? String(value);
-}
-
-function invalidInteger(value: unknown, name: string): CoercedIntResult {
-  return {
-    ok: false,
-    message: `Invalid ${name}: expected a safe base-10 integer, received ${formatReceived(value)}.`,
-  };
-}
-
-export function coerceObviousBase10Int(value: unknown, name: string): CoercedIntResult {
-  if (value === undefined) {
-    return { ok: true, value: undefined };
-  }
-
-  if (typeof value === "number") {
-    if (Number.isSafeInteger(value)) {
-      return { ok: true, value };
-    }
-    return invalidInteger(value, name);
-  }
-
-  if (typeof value === "string" && BASE10_INT_RE.test(value)) {
-    const parsed = BigInt(value);
-    if (parsed >= MIN_SAFE_INTEGER && parsed <= MAX_SAFE_INTEGER) {
-      return { ok: true, value: Number(parsed) };
-    }
-  }
-
-  return invalidInteger(value, name);
-}

package/src/confusable-hyphens.ts

@@ -1,6 +0,0 @@
-/**
- * Unicode hyphen-like characters normalized to ASCII "-" during text
- * comparison so edits with typographic hyphens match their originals.
- */
-export const CONFUSABLE_HYPHENS_RE =
-	/[\u2010\u2011\u2012\u2013\u2014\u2015\u2212\uFE63\uFF0D]/g;

package/src/def.ts

@@ -1,143 +0,0 @@
-import type { ExtensionAPI, ToolRenderResultOptions } from "@earendil-works/pi-coding-agent";
-import { Type } from "@sinclair/typebox";
-import path from "node:path";
-
-import { defineToolPromptMetadata } from "./tool-prompt-metadata.js";
-import { buildReadSeekLineWithHash, buildToolErrorResult } from "./readseek-value.js";
-import { resolveToCwd } from "./path-utils.js";
-import { statSearchPathOrError } from "./stat-search-path.js";
-import { classifyReadSeekFailure, readSeekDef } from "./readseek-client.js";
-import { searchPathParam, langParam, readSeekGitSearchParams, validateIgnoredRequiresOthers } from "./readseek-params.js";
-import { registerReadSeekTool } from "./register-tool.js";
-
-import { renderAnchoredFilesResult, renderReadSeekSearchCall } from "./tui-render-utils.js";
-import type { FileAnchoredCallback } from "./tool-types.js";
-
-const DEF_PROMPT_METADATA = defineToolPromptMetadata({
-	promptUrl: new URL("../prompts/def.md", import.meta.url),
-	promptSnippet: "Find where a symbol is defined",
-});
-
-type DefParams = {
-	name?: string;
-	path?: string;
-	lang?: string;
-	cached?: boolean;
-	others?: boolean;
-	ignored?: boolean;
-};
-
-interface DefToolOptions {
-	onFileAnchored?: FileAnchoredCallback;
-}
-
-export interface ExecuteDefOptions {
-	params: unknown;
-	signal: AbortSignal | undefined;
-	cwd: string;
-	onFileAnchored?: FileAnchoredCallback;
-}
-
-export async function executeDef(opts: ExecuteDefOptions): Promise<any> {
-	const { params, signal, cwd, onFileAnchored } = opts;
-	const p = params as DefParams;
-	const ignoredError = validateIgnoredRequiresOthers("def", p);
-	if (ignoredError) return ignoredError;
-
-	if (!p.name || !p.name.trim()) {
-		return buildToolErrorResult("def", "invalid-parameter", "readSeek_def requires 'name'");
-	}
-
-	const searchPath = resolveToCwd(p.path ?? ".", cwd);
-
-	const statResult = await statSearchPathOrError("def", p.path, searchPath);
-	if (!statResult.ok) return statResult.error;
-
-	try {
-		const definitions = await readSeekDef(searchPath, {
-			name: p.name,
-			language: p.lang,
-			cached: p.cached,
-			others: p.others,
-			ignored: p.ignored,
-			signal,
-		});
-
-		if (definitions.length === 0) {
-			return {
-				content: [{ type: "text", text: "no definitions found" }],
-				details: {
-					readSeekValue: { tool: "def", ok: true, path: searchPath, definitions: [] },
-				},
-			};
-		}
-
-		const files = new Map<string, { displayPath: string; path: string; lines: ReturnType<typeof buildReadSeekLineWithHash>[] }>();
-		for (const def of definitions) {
-			const abs = path.isAbsolute(def.file) ? def.file : path.resolve(cwd, def.file);
-			let file = files.get(abs);
-			if (!file) {
-				file = { displayPath: path.relative(cwd, abs) || abs, path: abs, lines: [] };
-				files.set(abs, file);
-			}
-			file.lines.push(buildReadSeekLineWithHash(def.line, def.line_hash, def.text));
-		}
-
-		const fileList = [...files.values()];
-		for (const file of fileList) {
-			onFileAnchored?.(file.path);
-		}
-
-		const textParts: string[] = [];
-		for (const file of fileList) {
-			textParts.push(file.displayPath);
-			for (const line of file.lines) {
-				textParts.push(`  ${line.line}:${line.hash} ${line.display}`);
-			}
-		}
-
-		return {
-			content: [{ type: "text", text: textParts.join("\n") }],
-			details: {
-				readSeekValue: { tool: "def", ok: true, path: searchPath, definitions },
-			},
-		};
-	} catch (err: any) {
-		const failure = classifyReadSeekFailure(err);
-		return buildToolErrorResult("def", failure.code, failure.message, failure.hint ? { hint: failure.hint } : {});
-	}
-}
-
-export function registerDefTool(pi: ExtensionAPI, options: DefToolOptions = {}) {
-	registerReadSeekTool(pi, {
-		name: "readSeek_def",
-		label: "Definition",
-		description: DEF_PROMPT_METADATA.description,
-		promptSnippet: DEF_PROMPT_METADATA.promptSnippet,
-		promptGuidelines: DEF_PROMPT_METADATA.promptGuidelines,
-		parameters: Type.Object({
-			name: Type.String({ description: "Qualified or unqualified symbol name" }),
-			path: searchPathParam(),
-			lang: langParam(),
-			...readSeekGitSearchParams(),
-		}),
-		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
-			return executeDef({ params, signal, cwd: ctx.cwd, onFileAnchored: options.onFileAnchored });
-		},
-		renderCall(args: any, theme: any, ...rest: any[]) {
-			return renderReadSeekSearchCall(args, theme, rest, {
-				label: "def",
-				accent: args.name,
-				flags: [args.cached && "cached", args.others && "others", args.ignored && "ignored"],
-			});
-		},
-		renderResult(result: any, options: ToolRenderResultOptions, theme: any, ...rest: any[]) {
-			return renderAnchoredFilesResult(result, options, theme, rest, {
-				pendingLabel: "pending def",
-				emptyLabel: "no definitions",
-				unitSingular: "definition",
-				unitPlural: "definitions",
-			});
-		},
-	});
-}