pi-readseek 0.3.16 → 0.3.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-readseek",
-  "version": "0.3.16",
+  "version": "0.3.17",
   "description": "Pi extension for readseek-backed hash-anchored read/edit/grep, structural code maps, structural search, and file exploration",
   "type": "module",
   "exports": {
@@ -39,12 +39,10 @@
     "node": ">=20.0.0"
   },
   "dependencies": {
-    "@jarkkojs/readseek": "^0.3.16",
+    "@jarkkojs/readseek": "^0.3.17",
     "diff": "^8.0.3",
     "ignore": "^7.0.5",
     "picomatch": "^4.0.4",
-    "tree-sitter-wasms": "0.1.13",
-    "web-tree-sitter": "0.25.10",
     "xxhash-wasm": "^1.1.0"
   },
   "peerDependencies": {

package/src/edit-syntax-validate.ts

@@ -1,6 +1,4 @@
-import type { Node as SyntaxNode, Parser as WasmParser, Tree } from "web-tree-sitter";
-import { getWasmParser, type WasmLanguageId } from "./readseek/parser-loader.js";
-import { reportParserError } from "./readseek/parser-errors.js";
+import { readseekCheck, type ReadseekCheckOutput, type ReadseekDiagnostic } from "./readseek-client.js";
 
 export interface ValidateInput {
   filePath: string;
@@ -14,122 +12,53 @@ export interface ValidateResult {
   newMissingCount: number;
 }
 
-interface NodeStats {
-  errors: Array<{ startLine: number; endLine: number }>;
-  missing: Array<{ startLine: number; endLine: number }>;
-}
-
-function countNodes(parser: WasmParser, source: string): NodeStats {
-  const tree: Tree | null = parser.parse(source);
-  const errors: Array<{ startLine: number; endLine: number }> = [];
-  const missing: Array<{ startLine: number; endLine: number }> = [];
-  if (!tree) return { errors, missing };
-  try {
-    const stack: SyntaxNode[] = [tree.rootNode];
-    while (stack.length > 0) {
-      const node = stack.pop()!;
-      if (node.type === "ERROR") {
-        errors.push({
-          startLine: node.startPosition.row + 1,
-          endLine: node.endPosition.row + 1,
-        });
-      }
-      if (node.isMissing) {
-        missing.push({
-          startLine: node.startPosition.row + 1,
-          endLine: node.endPosition.row + 1,
-        });
-      }
-      for (let i = 0; i < node.namedChildCount; i++) {
-        const c = node.namedChild(i);
-        if (c) stack.push(c);
-      }
-      // Also descend into anonymous children to find MISSING tokens.
-      for (let i = 0; i < node.childCount; i++) {
-        const c = node.child(i);
-        if (c && !c.isNamed) stack.push(c);
-      }
-    }
-    return { errors, missing };
-  } finally {
-    tree.delete();
-  }
-}
-
-function dedupeSortLines(
-  ranges: Array<{ startLine: number; endLine: number }>,
-): string[] {
+function dedupeSortLines(diagnostics: ReadseekDiagnostic[]): string[] {
   const seen = new Set<string>();
   const out: Array<{ key: string; start: number }> = [];
-  for (const r of ranges) {
-    const key = r.startLine === r.endLine
-      ? String(r.startLine)
-      : `${r.startLine}-${r.endLine}`;
+  for (const diagnostic of diagnostics) {
+    const key =
+      diagnostic.start_line === diagnostic.end_line
+        ? String(diagnostic.start_line)
+        : `${diagnostic.start_line}-${diagnostic.end_line}`;
     if (!seen.has(key)) {
       seen.add(key);
-      out.push({ key, start: r.startLine });
+      out.push({ key, start: diagnostic.start_line });
     }
   }
   out.sort((a, b) => a.start - b.start);
   return out.map((o) => o.key);
 }
 
-const EXTENSION_TO_LANGUAGE: Record<string, WasmLanguageId> = {
-	".rs": "rust",
-	".c": "cpp",
-	".cc": "cpp",
-	".cpp": "cpp",
-	".cxx": "cpp",
-	".h": "c-header",
-	".hpp": "c-header",
-	".hxx": "c-header",
-	".java": "java",
-};
-
-function detectWasmLang(filePath: string): WasmLanguageId | null {
-	for (const [ext, langId] of Object.entries(EXTENSION_TO_LANGUAGE)) {
-		if (filePath.toLowerCase().endsWith(ext)) return langId;
-	}
-	return null;
-}
+const EMPTY: ReadseekCheckOutput = { errorCount: 0, missingCount: 0, diagnostics: [] };
 
+/**
+ * Compare parse diagnostics between `before` and `after` and report any newly
+ * introduced syntax errors. Uses readseek's native `check`, so every language
+ * with a tree-sitter parser is validated.
+ *
+ * Returns `null` when nothing new appears or when readseek cannot parse the
+ * file, so a validator failure never blocks an edit.
+ */
 export async function validateSyntaxRegression(
-	input: ValidateInput,
+  input: ValidateInput,
 ): Promise<ValidateResult | null> {
-	const langId = detectWasmLang(input.filePath);
-	if (!langId) return null;
-	const parser = await getWasmParser(langId);
-  if (!parser) return null;
-
+  let before: ReadseekCheckOutput;
+  let after: ReadseekCheckOutput;
   try {
-    const beforeStats = input.before === undefined
-      ? { errors: [], missing: [] }
-      : countNodes(parser, input.before);
-    const afterStats = countNodes(parser, input.after);
+    before = input.before === undefined ? EMPTY : await readseekCheck(input.filePath, input.before);
+    after = await readseekCheck(input.filePath, input.after);
+  } catch {
+    return null;
+  }
 
-    // ±1 tolerance on ERROR count, no tolerance on MISSING.
-    const newErrorCount = Math.max(
-      0,
-      afterStats.errors.length - beforeStats.errors.length - 1,
-    );
-    const newMissingCount = Math.max(
-      0,
-      afterStats.missing.length - beforeStats.missing.length,
-    );
+  const newErrorCount = Math.max(0, after.errorCount - before.errorCount - 1);
+  const newMissingCount = Math.max(0, after.missingCount - before.missingCount);
 
-    if (newErrorCount === 0 && newMissingCount === 0) return null;
+  if (newErrorCount === 0 && newMissingCount === 0) return null;
 
-    const errorLines = dedupeSortLines([
-      ...afterStats.errors,
-      ...afterStats.missing,
-    ]);
-    return { errorLines, newErrorCount, newMissingCount };
-	} catch (err) {
-		reportParserError(`wasm:syntax-validate:${langId}:${err instanceof Error ? err.message : String(err)}`, err, {
-			context: `tree-sitter syntax validation failed for ${langId}`,
-		});
-		return null;
-	} finally {
-		parser.delete();
-  }
+  return {
+    errorLines: dedupeSortLines(after.diagnostics),
+    newErrorCount,
+    newMissingCount,
+  };
 }

package/src/readseek-client.ts

@@ -94,6 +94,18 @@ export interface ReadseekRefsOptions {
 	signal?: AbortSignal;
 }
 
+export interface ReadseekDiagnostic {
+	kind: "error" | "missing";
+	start_line: number;
+	end_line: number;
+}
+
+export interface ReadseekCheckOutput {
+	errorCount: number;
+	missingCount: number;
+	diagnostics: ReadseekDiagnostic[];
+}
+
 export interface ReadseekSearchOptions {
 	language?: string;
 	cached?: boolean;
@@ -472,3 +484,37 @@ export async function readseekRefs(
 	if (options.ignored) args.push("--ignored");
 	return parseRefsOutput(await runReadseek(args, { signal: options.signal })).references;
 }
+
+function parseDiagnosticKind(value: unknown): ReadseekDiagnostic["kind"] {
+	if (value === "error" || value === "missing") return value;
+	throw new Error("invalid readseek diagnostic.kind");
+}
+
+function parseCheckOutput(value: unknown): ReadseekCheckOutput {
+	if (!value || typeof value !== "object") throw new Error("invalid readseek check output");
+	const output = value as Record<string, unknown>;
+	if (!Array.isArray(output.diagnostics)) throw new Error("invalid readseek diagnostics");
+	return {
+		errorCount: requireNumber(output.error_count, "error_count"),
+		missingCount: requireNumber(output.missing_count, "missing_count"),
+		diagnostics: output.diagnostics.map((diagnostic) => {
+			if (!diagnostic || typeof diagnostic !== "object") throw new Error("invalid readseek diagnostic");
+			const item = diagnostic as Record<string, unknown>;
+			return {
+				kind: parseDiagnosticKind(item.kind),
+				start_line: requireNumber(item.start_line, "diagnostic.start_line"),
+				end_line: requireNumber(item.end_line, "diagnostic.end_line"),
+			};
+		}),
+	};
+}
+
+export async function readseekCheck(
+	filePath: string,
+	content: string,
+	options: { signal?: AbortSignal } = {},
+): Promise<ReadseekCheckOutput> {
+	return parseCheckOutput(
+		await runReadseek(["check", "--stdin", filePath], { signal: options.signal, stdin: content }),
+	);
+}

package/src/readseek/parser-errors.ts

@@ -1,19 +0,0 @@
-const emitted = new Set<string>();
-
-function causeMessage(err: unknown): string {
-  if (err instanceof Error) return err.message;
-  return String(err);
-}
-
-export function reportParserError(
-  onceKey: string,
-  err: unknown,
-  options: { context?: string } = {},
-): void {
-  if (!process.env.PI_READSEEK_DEBUG) return;
-  if (emitted.has(onceKey)) return;
-  emitted.add(onceKey);
-  const context = options.context ?? onceKey;
-  console.error(`[readseek] ${context}: ${causeMessage(err)}`);
-}
-

package/src/readseek/parser-loader.ts

@@ -1,78 +0,0 @@
-import { createRequire } from "node:module";
-import { dirname, join } from "node:path";
-import { Language, Parser } from "web-tree-sitter";
-import { reportParserError } from "./parser-errors.js";
-
-export type WasmLanguageId = "rust" | "cpp" | "c-header" | "java";
-export type WasmParser = Parser;
-
-const require_ = createRequire(import.meta.url);
-const wasmNames: Record<WasmLanguageId, string> = {
-  rust: "rust",
-  cpp: "cpp",
-  "c-header": "cpp",
-  java: "java",
-};
-let initPromise: Promise<void> | null = null;
-const languages = new Map<WasmLanguageId, Language>();
-const languageLoads = new Map<WasmLanguageId, Promise<Language | null>>();
-
-function isBun(): boolean {
-  return typeof (globalThis as { Bun?: unknown }).Bun !== "undefined";
-}
-
-function wasmPath(langId: WasmLanguageId): string {
-  const pkg = require_.resolve("tree-sitter-wasms/package.json");
-  return join(dirname(pkg), "out", `tree-sitter-${wasmNames[langId]}.wasm`);
-}
-
-async function init(): Promise<void> {
-  initPromise ??= Parser.init().catch((err: unknown) => {
-    initPromise = null;
-    reportParserError("wasm:init", err, { context: "web-tree-sitter initialization failed" });
-    throw err;
-  });
-  return initPromise;
-}
-
-async function language(langId: WasmLanguageId): Promise<Language | null> {
-  const loaded = languages.get(langId);
-  if (loaded) return loaded;
-
-  const inFlight = languageLoads.get(langId);
-  if (inFlight) return inFlight;
-
-  const loadPromise = (async () => {
-    try {
-      await init();
-      const lang = await Language.load(wasmPath(langId));
-      languages.set(langId, lang);
-      return lang;
-    } catch (err) {
-      reportParserError(`wasm:load:${langId}`, err, {
-        context: `tree-sitter WASM grammar load failed for ${langId}`,
-      });
-      return null;
-    } finally {
-      languageLoads.delete(langId);
-    }
-  })();
-
-  languageLoads.set(langId, loadPromise);
-  return loadPromise;
-}
-
-export async function getWasmParser(langId: WasmLanguageId): Promise<WasmParser | null> {
-  if (isBun()) return null;
-  const lang = await language(langId);
-  if (!lang) return null;
-  try {
-    const parser = new Parser();
-    parser.setLanguage(lang);
-    return parser;
-  } catch (err) {
-    reportParserError(`wasm:parser:${langId}`, err, { context: `tree-sitter WASM parser creation failed for ${langId}` });
-    return null;
-  }
-}
-