pi-readseek 0.1.0

package/src/edit-render-helpers.ts

@@ -0,0 +1,141 @@
+const VARIANT_KEYS = ["set_line", "replace_lines", "insert_after", "replace"] as const;
+
+export type EditTypeCounts = {
+  set_line: number;
+  replace_lines: number;
+  insert_after: number;
+  replace: number;
+  total: number;
+};
+
+export function countEditTypes(edits: unknown[] | undefined): EditTypeCounts {
+  const counts: EditTypeCounts = {
+    set_line: 0,
+    replace_lines: 0,
+    insert_after: 0,
+    replace: 0,
+    total: 0,
+  };
+  if (!edits) return counts;
+  for (const edit of edits) {
+    counts.total++;
+    if (edit && typeof edit === "object") {
+      for (const key of VARIANT_KEYS) {
+        if (key in edit) {
+          counts[key]++;
+          break;
+        }
+      }
+    }
+  }
+  return counts;
+}
+
+export interface DiffStats {
+  added: number;
+  removed: number;
+}
+
+export function parseDiffStats(diff: string | undefined): DiffStats {
+  if (!diff) return { added: 0, removed: 0 };
+  let added = 0;
+  let removed = 0;
+  for (const line of diff.split("\n")) {
+    if (line.startsWith("+++") || line.startsWith("---")) continue;
+    if (line.startsWith("+")) added++;
+    else if (line.startsWith("-")) removed++;
+  }
+  return { added, removed };
+}
+
+export interface EditCallTextResult {
+  path: string | null;
+  suffix: string | undefined;
+}
+
+export function formatEditCallText(
+  args: Record<string, unknown> | undefined,
+  argsComplete: boolean,
+): EditCallTextResult {
+  const rawPath = typeof args?.path === "string" ? args.path : null;
+
+  if (!argsComplete) {
+    return { path: rawPath, suffix: undefined };
+  }
+
+  const edits = args?.edits;
+  if (!Array.isArray(edits) || edits.length === 0) {
+    return { path: rawPath, suffix: undefined };
+  }
+
+  const counts = countEditTypes(edits);
+  const parts: string[] = [];
+  for (const key of VARIANT_KEYS) {
+    if (counts[key] > 0) {
+      parts.push(`${counts[key]} ${key}`);
+    }
+  }
+  const word = counts.total === 1 ? "edit" : "edits";
+  const suffix = `${counts.total} ${word} (${parts.join(", ")})`;
+  return { path: rawPath, suffix };
+}
+
+export interface EditResultTextInput {
+  isError: boolean;
+  diff: string;
+  warnings: string[];
+  noopEdits: unknown[];
+  errorText: string;
+  semanticClassification?: "no-op" | "whitespace-only" | "semantic" | "mixed";
+}
+
+export interface EditResultTextOutput {
+  diffStats: string | undefined;
+  noOp: boolean;
+  warningsBadge: string | undefined;
+  errorText: string | undefined;
+  semanticBadge: string | undefined;
+}
+
+export function formatEditResultText(input: EditResultTextInput): EditResultTextOutput {
+  const { isError, diff, warnings, noopEdits, errorText } = input;
+
+  // No-op detection: error + noopEdits present OR error text contains "No changes made"
+  const isNoOp = isError && (
+    (Array.isArray(noopEdits) && noopEdits.length > 0) ||
+    errorText.includes("No changes made")
+  );
+
+  // Diff stats
+  const stats = parseDiffStats(diff);
+  const hasDiffStats = stats.added > 0 || stats.removed > 0;
+  const diffStats = hasDiffStats ? `+${stats.added} / -${stats.removed}` : undefined;
+
+  // Warnings badge
+  let warningsBadge: string | undefined;
+  if (warnings.length === 1) {
+    warningsBadge = "\u26a0 1 warning";
+  } else if (warnings.length > 1) {
+    warningsBadge = `\u26a0 ${warnings.length} warnings`;
+  }
+
+  // Error text (only for errors)
+  const showErrorText = isError ? errorText : undefined;
+
+  // Semantic classification badge (success only)
+  let semanticBadge: string | undefined;
+  if (!isError && !isNoOp && input.semanticClassification) {
+    switch (input.semanticClassification) {
+      case "whitespace-only": semanticBadge = "ws-only"; break;
+      case "semantic": semanticBadge = "\u2713 semantic"; break;
+      case "mixed": semanticBadge = "mixed"; break;
+    }
+  }
+  return {
+    diffStats,
+    noOp: isNoOp,
+    warningsBadge,
+    errorText: showErrorText,
+    semanticBadge,
+  };
+}

package/src/edit-syntax-validate.ts

@@ -0,0 +1,120 @@
+import type { Node as SyntaxNode, Parser as WasmParser, Tree } from "web-tree-sitter";
+import { detectLanguage } from "./readseek/language-detect.js";
+import { getWasmParser } from "./readseek/parser-loader.js";
+import { reportParserError } from "./readseek/parser-errors.js";
+
+export interface ValidateInput {
+  filePath: string;
+  before: string | undefined;
+  after: string;
+}
+
+export interface ValidateResult {
+  errorLines: string[];
+  newErrorCount: number;
+  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[] {
+  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}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      out.push({ key, start: r.startLine });
+    }
+  }
+  out.sort((a, b) => a.start - b.start);
+  return out.map((o) => o.key);
+}
+
+export async function validateSyntaxRegression(
+  input: ValidateInput,
+): Promise<ValidateResult | null> {
+  const lang = detectLanguage(input.filePath);
+  if (!lang) return null;
+  if (lang.id !== "rust" && lang.id !== "cpp" && lang.id !== "c-header" && lang.id !== "java") {
+    return null;
+  }
+  const parser = await getWasmParser(lang.id);
+  if (!parser) return null;
+
+  try {
+    const beforeStats = input.before === undefined
+      ? { errors: [], missing: [] }
+      : countNodes(parser, input.before);
+    const afterStats = countNodes(parser, input.after);
+
+    // ±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,
+    );
+
+    if (newErrorCount === 0 && newMissingCount === 0) return null;
+
+    const errorLines = dedupeSortLines([
+      ...afterStats.errors,
+      ...afterStats.missing,
+    ]);
+    return { errorLines, newErrorCount, newMissingCount };
+  } catch (err) {
+    reportParserError(`wasm:syntax-validate:${lang.id}:${err instanceof Error ? err.message : String(err)}`, err, {
+      context: `tree-sitter syntax validation failed for ${lang.id}`,
+    });
+    return null;
+  } finally {
+    parser.delete();
+  }
+}