@ashx-j/lunr 0.1.0

package/dist/builtin-extensions/pi-lsp-extension/src/tree-sitter/pattern-compiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pattern-compiler.d.ts","sourceRoot":"","sources":["../../../../../src/builtin-extensions/pi-lsp-extension/src/tree-sitter/pattern-compiler.ts"],"names":[],"mappings":"AACA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAM7D,MAAM,MAAM,WAAW,GACnB,kBAAkB,GAClB,kBAAkB,GAClB,mBAAmB,CAAC;AAExB,mGAAiG;AACjG,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,SAAS,CAAC;IAChB,6EAA6E;IAC7E,QAAQ,EAAE,MAAM,CAAC;IACjB,iDAAiD;IACjD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,sEAAsE;IACtE,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,kFAAkF;IAClF,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,wDAAwD;AACxD,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,SAAS,CAAC;IAChB,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb,kDAAkD;IAClD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,qDAAqD;AACrD,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,UAAU,CAAC;IACjB,gFAAgF;IAChF,IAAI,EAAE,MAAM,CAAC;IACb,yBAAyB;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,eAAe;IAC9B,mFAAmF;IACnF,IAAI,EAAE,WAAW,CAAC;IAClB,kDAAkD;IAClD,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,iDAAiD;IACjD,UAAU,EAAE,MAAM,CAAC;CACpB;AA4DD;;;;;;;;;GASG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,iBAAiB,GAC5B,OAAO,CAAC,eAAe,CAAC,CAgC1B","sourcesContent":["// @ts-nocheck\n/**\n * Pattern Compiler — parse metavariable patterns into matchable pattern trees.\n *\n * User-facing patterns use `$NAME` for single-node wildcards and `$$$NAME` for\n * variadic (zero-or-more) wildcards. The pattern string is parsed as code using\n * tree-sitter, then the AST is walked to build a PatternNode tree where\n * metavariable identifiers are replaced with wildcard matchers.\n */\n\nimport type Parser from \"web-tree-sitter\";\nimport type { TreeSitterManager } from \"./parser-manager.js\";\n\ntype SyntaxNode = Parser.SyntaxNode;\n\n// ── Pattern node types ──────────────────────────────────────────────────────\n\nexport type PatternNode =\n  | LiteralPatternNode\n  | MetavarPatternNode\n  | VariadicPatternNode;\n\n/** Matches a concrete AST node — type must match, and either text (leaf) or children (branch) */\nexport interface LiteralPatternNode {\n  kind: \"literal\";\n  /** tree-sitter node type to match (e.g., \"identifier\", \"call_expression\") */\n  nodeType: string;\n  /** For leaf nodes: exact text that must match */\n  text?: string;\n  /** For branch nodes: child patterns to match (named children only) */\n  children: PatternNode[];\n  /** Field name this node occupies in its parent (e.g., \"function\", \"arguments\") */\n  fieldName?: string;\n}\n\n/** Matches any single AST node and captures its text */\nexport interface MetavarPatternNode {\n  kind: \"metavar\";\n  /** Capture name (e.g., \"ARG\" from \"$ARG\") */\n  name: string;\n  /** Field name this node occupies in its parent */\n  fieldName?: string;\n}\n\n/** Matches zero or more consecutive sibling nodes */\nexport interface VariadicPatternNode {\n  kind: \"variadic\";\n  /** Capture name (e.g., \"PARAMS\" from \"$$$PARAMS\", or \"\" for anonymous \"$$$\") */\n  name: string;\n  /** Field name context */\n  fieldName?: string;\n}\n\nexport interface CompiledPattern {\n  /** The root pattern node (unwrapped from program/expression_statement wrappers) */\n  root: PatternNode;\n  /** All metavariable names found in the pattern */\n  metavars: string[];\n  /** The language this pattern was compiled for */\n  languageId: string;\n}\n\n// ── Metavariable detection ──────────────────────────────────────────────────\n\nconst VARIADIC_RE = /^\\$\\$\\$([A-Z_][A-Z0-9_]*)?$/;\nconst METAVAR_RE = /^\\$([A-Z_][A-Z0-9_]*)$/;\n\nfunction isVariadic(text: string): string | null {\n  const m = VARIADIC_RE.exec(text);\n  return m ? (m[1] ?? \"\") : null;\n}\n\nfunction isMetavar(text: string): string | null {\n  const m = METAVAR_RE.exec(text);\n  return m ? m[1] : null;\n}\n\n// ── Metavar placeholder encoding ────────────────────────────────────────────\n\nconst META_PREFIX = \"__META_\";\nconst VMETA_PREFIX = \"__VMETA_\";\nconst META_SUFFIX = \"__\";\n\n/**\n * Replace `$$$NAME` and `$NAME` with placeholder identifiers valid in any language.\n * Returns the preprocessed source and a map from placeholder to {kind, name}.\n */\nfunction preprocessMetavars(source: string): {\n  preprocessed: string;\n  placeholders: Map<string, { kind: \"metavar\" | \"variadic\"; name: string }>;\n} {\n  const placeholders = new Map<string, { kind: \"metavar\" | \"variadic\"; name: string }>();\n\n  // Replace variadic first (longer prefix) to avoid $$ matching $\n  let preprocessed = source.replace(/\\$\\$\\$([A-Z_][A-Z0-9_]*)?/g, (_match, name) => {\n    const n = name ?? \"\";\n    const placeholder = `${VMETA_PREFIX}${n || \"ANON\"}${META_SUFFIX}`;\n    placeholders.set(placeholder, { kind: \"variadic\", name: n });\n    return placeholder;\n  });\n\n  preprocessed = preprocessed.replace(/\\$([A-Z_][A-Z0-9_]*)/g, (_match, name) => {\n    const placeholder = `${META_PREFIX}${name}${META_SUFFIX}`;\n    placeholders.set(placeholder, { kind: \"metavar\", name });\n    return placeholder;\n  });\n\n  return { preprocessed, placeholders };\n}\n\n/** Check if a text is a metavar placeholder */\nfunction decodePlaceholder(\n  text: string,\n  placeholders: Map<string, { kind: \"metavar\" | \"variadic\"; name: string }>,\n): { kind: \"metavar\" | \"variadic\"; name: string } | null {\n  return placeholders.get(text) ?? null;\n}\n\n// ── Compile ─────────────────────────────────────────────────────────────────\n\n/**\n * Compile a user-facing pattern string into a matchable PatternNode tree.\n *\n * Metavariables ($NAME, $$$NAME) are replaced with placeholder identifiers\n * before parsing, so patterns work in any language regardless of whether `$`\n * is a valid identifier character.\n *\n * Tries parsing the pattern as-is first, then with wrapper contexts if it\n * contains syntax errors (e.g., an expression fragment that isn't a valid program).\n */\nexport async function compilePattern(\n  source: string,\n  languageId: string,\n  treeSitter: TreeSitterManager,\n): Promise<CompiledPattern> {\n  await treeSitter.init();\n\n  const { preprocessed, placeholders } = preprocessMetavars(source);\n\n  // Language-specific wrappers for fragments that aren't full programs\n  const wrappers = getWrappersForLanguage(languageId);\n\n  for (const { wrap, unwrap } of wrappers) {\n    const wrapped = wrap(preprocessed);\n    const tree = await treeSitter.parseWithLanguage(\n      `__pattern__${Date.now()}`,\n      wrapped,\n      languageId,\n    );\n    if (!tree) continue;\n\n    const root = tree.rootNode;\n    if (hasErrors(root)) continue;\n\n    const unwrapped = unwrap(root);\n    if (!unwrapped) continue;\n\n    const metavars: string[] = [];\n    const patternNode = buildPatternNode(unwrapped, metavars, undefined, placeholders);\n    return { root: patternNode, metavars: [...new Set(metavars)], languageId };\n  }\n\n  throw new Error(\n    `Failed to parse pattern as ${languageId}. The pattern may have syntax errors ` +\n    `or may not be a valid code fragment in this language.`,\n  );\n}\n\n/** Get wrapper strategies appropriate for a language */\nfunction getWrappersForLanguage(languageId: string): Array<{\n  wrap: (s: string) => string;\n  unwrap: (root: SyntaxNode) => SyntaxNode | null;\n}> {\n  const common = [\n    { wrap: (s: string) => s, unwrap: unwrapProgram },\n    { wrap: (s: string) => `${s};`, unwrap: unwrapProgram },\n    { wrap: (s: string) => `(${s})`, unwrap: unwrapExpression },\n  ];\n\n  switch (languageId) {\n    case \"python\":\n      return [\n        { wrap: (s: string) => s, unwrap: unwrapModule },\n        { wrap: (s: string) => `(${s})`, unwrap: unwrapExpression },\n        { wrap: (s: string) => `def _():\\n  ${s}`, unwrap: unwrapPythonFunctionBody },\n      ];\n    default:\n      return [\n        ...common,\n        { wrap: (s: string) => `function _() { ${s} }`, unwrap: unwrapFunctionBody },\n      ];\n  }\n}\n\n// ── AST → PatternNode conversion ────────────────────────────────────────────\n\nfunction buildPatternNode(\n  node: SyntaxNode,\n  metavars: string[],\n  fieldName: string | undefined,\n  placeholders: Map<string, { kind: \"metavar\" | \"variadic\"; name: string }>,\n): PatternNode {\n  const text = node.text;\n\n  // Check for placeholder-based metavar/variadic (new: language-agnostic)\n  if (node.namedChildCount === 0) {\n    const decoded = decodePlaceholder(text, placeholders);\n    if (decoded) {\n      if (decoded.name) metavars.push(decoded.name);\n      if (decoded.kind === \"variadic\") {\n        return { kind: \"variadic\", name: decoded.name, fieldName };\n      }\n      return { kind: \"metavar\", name: decoded.name, fieldName };\n    }\n  }\n\n  // Also check legacy $-prefixed metavars (for languages where $ is valid)\n  if (node.namedChildCount === 0) {\n    const variadicName = isVariadic(text);\n    if (variadicName !== null) {\n      if (variadicName) metavars.push(variadicName);\n      return { kind: \"variadic\", name: variadicName, fieldName };\n    }\n    const metavarName = isMetavar(text);\n    if (metavarName !== null) {\n      metavars.push(metavarName);\n      return { kind: \"metavar\", name: metavarName, fieldName };\n    }\n  }\n\n  // Branch node with a single child that is a placeholder → unwrap\n  if (node.namedChildCount === 1) {\n    const onlyChild = node.namedChildren[0];\n    if (onlyChild.namedChildCount === 0) {\n      const decoded = decodePlaceholder(onlyChild.text, placeholders);\n      if (decoded) {\n        if (decoded.name) metavars.push(decoded.name);\n        if (decoded.kind === \"variadic\") {\n          return { kind: \"variadic\", name: decoded.name, fieldName };\n        }\n        return { kind: \"metavar\", name: decoded.name, fieldName };\n      }\n      // Legacy $ check\n      const childMeta = isMetavar(onlyChild.text);\n      if (childMeta !== null) {\n        metavars.push(childMeta);\n        return { kind: \"metavar\", name: childMeta, fieldName };\n      }\n      const childVariadic = isVariadic(onlyChild.text);\n      if (childVariadic !== null) {\n        if (childVariadic) metavars.push(childVariadic);\n        return { kind: \"variadic\", name: childVariadic, fieldName };\n      }\n    }\n  }\n\n  // Leaf node — literal match\n  if (node.namedChildCount === 0) {\n    return { kind: \"literal\", nodeType: node.type, text, children: [], fieldName };\n  }\n\n  // Branch node — recurse into named children\n  const children: PatternNode[] = [];\n  for (const child of node.namedChildren) {\n    const childFieldName = getFieldName(node, child);\n    children.push(buildPatternNode(child, metavars, childFieldName, placeholders));\n  }\n\n  return { kind: \"literal\", nodeType: node.type, children, fieldName };\n}\n\n/** Get the field name for a child node relative to its parent */\nfunction getFieldName(parent: SyntaxNode, child: SyntaxNode): string | undefined {\n  // Walk parent's children to find the field name for this child\n  for (let i = 0; i < parent.childCount; i++) {\n    const c = parent.child(i);\n    if (c && c.id === child.id) {\n      return parent.fieldNameForChild(i) ?? undefined;\n    }\n  }\n  return undefined;\n}\n\n// ── Unwrap helpers ──────────────────────────────────────────────────────────\n\n/** Unwrap from program → first meaningful child */\nfunction unwrapProgram(root: SyntaxNode): SyntaxNode | null {\n  if (root.type !== \"program\" || root.namedChildCount === 0) return null;\n  const child = root.namedChildren[0];\n  // Unwrap expression_statement wrapper if present\n  if (child.type === \"expression_statement\" && child.namedChildCount === 1) {\n    return child.namedChildren[0];\n  }\n  return child;\n}\n\n/** Unwrap from module → first meaningful child (Python uses \"module\" as root) */\nfunction unwrapModule(root: SyntaxNode): SyntaxNode | null {\n  if (root.type !== \"module\" || root.namedChildCount === 0) return null;\n  const child = root.namedChildren[0];\n  if (child.type === \"expression_statement\" && child.namedChildCount === 1) {\n    return child.namedChildren[0];\n  }\n  return child;\n}\n\n/** Unwrap from program → expression_statement → parenthesized_expression → inner */\nfunction unwrapExpression(root: SyntaxNode): SyntaxNode | null {\n  if (root.type !== \"program\" || root.namedChildCount === 0) return null;\n  let node = root.namedChildren[0];\n  if (node.type === \"expression_statement\") node = node.namedChildren[0];\n  if (node.type === \"parenthesized_expression\" && node.namedChildCount === 1) {\n    return node.namedChildren[0];\n  }\n  return node;\n}\n\n/** Unwrap from program → function_declaration → body → first statement */\nfunction unwrapFunctionBody(root: SyntaxNode): SyntaxNode | null {\n  if (root.type !== \"program\" || root.namedChildCount === 0) return null;\n  const fn = root.namedChildren[0];\n  if (!fn.type.includes(\"function\")) return null;\n  const body = fn.childForFieldName(\"body\");\n  if (!body || body.namedChildCount === 0) return null;\n  const stmt = body.namedChildren[0];\n  if (stmt.type === \"expression_statement\" && stmt.namedChildCount === 1) {\n    return stmt.namedChildren[0];\n  }\n  return stmt;\n}\n\n/** Unwrap from module → function_definition → body → first statement (Python) */\nfunction unwrapPythonFunctionBody(root: SyntaxNode): SyntaxNode | null {\n  if (root.type !== \"module\" || root.namedChildCount === 0) return null;\n  const fn = root.namedChildren[0];\n  if (fn.type !== \"function_definition\") return null;\n  const body = fn.childForFieldName(\"body\");\n  if (!body || body.namedChildCount === 0) return null;\n  const stmt = body.namedChildren[0];\n  if (stmt.type === \"expression_statement\" && stmt.namedChildCount === 1) {\n    return stmt.namedChildren[0];\n  }\n  return stmt;\n}\n\n/** Check if an AST node contains any ERROR nodes */\nfunction hasErrors(node: SyntaxNode): boolean {\n  if (node.type === \"ERROR\" || node.isMissing) return true;\n  for (let i = 0; i < node.childCount; i++) {\n    const child = node.child(i);\n    if (child && hasErrors(child)) return true;\n  }\n  return false;\n}\n"]}

package/dist/builtin-extensions/pi-lsp-extension/src/tree-sitter/pattern-compiler.js

@@ -0,0 +1,260 @@
+// @ts-nocheck
+/**
+ * Pattern Compiler — parse metavariable patterns into matchable pattern trees.
+ *
+ * User-facing patterns use `$NAME` for single-node wildcards and `$$$NAME` for
+ * variadic (zero-or-more) wildcards. The pattern string is parsed as code using
+ * tree-sitter, then the AST is walked to build a PatternNode tree where
+ * metavariable identifiers are replaced with wildcard matchers.
+ */
+// ── Metavariable detection ──────────────────────────────────────────────────
+const VARIADIC_RE = /^\$\$\$([A-Z_][A-Z0-9_]*)?$/;
+const METAVAR_RE = /^\$([A-Z_][A-Z0-9_]*)$/;
+function isVariadic(text) {
+    const m = VARIADIC_RE.exec(text);
+    return m ? (m[1] ?? "") : null;
+}
+function isMetavar(text) {
+    const m = METAVAR_RE.exec(text);
+    return m ? m[1] : null;
+}
+// ── Metavar placeholder encoding ────────────────────────────────────────────
+const META_PREFIX = "__META_";
+const VMETA_PREFIX = "__VMETA_";
+const META_SUFFIX = "__";
+/**
+ * Replace `$$$NAME` and `$NAME` with placeholder identifiers valid in any language.
+ * Returns the preprocessed source and a map from placeholder to {kind, name}.
+ */
+function preprocessMetavars(source) {
+    const placeholders = new Map();
+    // Replace variadic first (longer prefix) to avoid $$ matching $
+    let preprocessed = source.replace(/\$\$\$([A-Z_][A-Z0-9_]*)?/g, (_match, name) => {
+        const n = name ?? "";
+        const placeholder = `${VMETA_PREFIX}${n || "ANON"}${META_SUFFIX}`;
+        placeholders.set(placeholder, { kind: "variadic", name: n });
+        return placeholder;
+    });
+    preprocessed = preprocessed.replace(/\$([A-Z_][A-Z0-9_]*)/g, (_match, name) => {
+        const placeholder = `${META_PREFIX}${name}${META_SUFFIX}`;
+        placeholders.set(placeholder, { kind: "metavar", name });
+        return placeholder;
+    });
+    return { preprocessed, placeholders };
+}
+/** Check if a text is a metavar placeholder */
+function decodePlaceholder(text, placeholders) {
+    return placeholders.get(text) ?? null;
+}
+// ── Compile ─────────────────────────────────────────────────────────────────
+/**
+ * Compile a user-facing pattern string into a matchable PatternNode tree.
+ *
+ * Metavariables ($NAME, $$$NAME) are replaced with placeholder identifiers
+ * before parsing, so patterns work in any language regardless of whether `$`
+ * is a valid identifier character.
+ *
+ * Tries parsing the pattern as-is first, then with wrapper contexts if it
+ * contains syntax errors (e.g., an expression fragment that isn't a valid program).
+ */
+export async function compilePattern(source, languageId, treeSitter) {
+    await treeSitter.init();
+    const { preprocessed, placeholders } = preprocessMetavars(source);
+    // Language-specific wrappers for fragments that aren't full programs
+    const wrappers = getWrappersForLanguage(languageId);
+    for (const { wrap, unwrap } of wrappers) {
+        const wrapped = wrap(preprocessed);
+        const tree = await treeSitter.parseWithLanguage(`__pattern__${Date.now()}`, wrapped, languageId);
+        if (!tree)
+            continue;
+        const root = tree.rootNode;
+        if (hasErrors(root))
+            continue;
+        const unwrapped = unwrap(root);
+        if (!unwrapped)
+            continue;
+        const metavars = [];
+        const patternNode = buildPatternNode(unwrapped, metavars, undefined, placeholders);
+        return { root: patternNode, metavars: [...new Set(metavars)], languageId };
+    }
+    throw new Error(`Failed to parse pattern as ${languageId}. The pattern may have syntax errors ` +
+        `or may not be a valid code fragment in this language.`);
+}
+/** Get wrapper strategies appropriate for a language */
+function getWrappersForLanguage(languageId) {
+    const common = [
+        { wrap: (s) => s, unwrap: unwrapProgram },
+        { wrap: (s) => `${s};`, unwrap: unwrapProgram },
+        { wrap: (s) => `(${s})`, unwrap: unwrapExpression },
+    ];
+    switch (languageId) {
+        case "python":
+            return [
+                { wrap: (s) => s, unwrap: unwrapModule },
+                { wrap: (s) => `(${s})`, unwrap: unwrapExpression },
+                { wrap: (s) => `def _():\n  ${s}`, unwrap: unwrapPythonFunctionBody },
+            ];
+        default:
+            return [
+                ...common,
+                { wrap: (s) => `function _() { ${s} }`, unwrap: unwrapFunctionBody },
+            ];
+    }
+}
+// ── AST → PatternNode conversion ────────────────────────────────────────────
+function buildPatternNode(node, metavars, fieldName, placeholders) {
+    const text = node.text;
+    // Check for placeholder-based metavar/variadic (new: language-agnostic)
+    if (node.namedChildCount === 0) {
+        const decoded = decodePlaceholder(text, placeholders);
+        if (decoded) {
+            if (decoded.name)
+                metavars.push(decoded.name);
+            if (decoded.kind === "variadic") {
+                return { kind: "variadic", name: decoded.name, fieldName };
+            }
+            return { kind: "metavar", name: decoded.name, fieldName };
+        }
+    }
+    // Also check legacy $-prefixed metavars (for languages where $ is valid)
+    if (node.namedChildCount === 0) {
+        const variadicName = isVariadic(text);
+        if (variadicName !== null) {
+            if (variadicName)
+                metavars.push(variadicName);
+            return { kind: "variadic", name: variadicName, fieldName };
+        }
+        const metavarName = isMetavar(text);
+        if (metavarName !== null) {
+            metavars.push(metavarName);
+            return { kind: "metavar", name: metavarName, fieldName };
+        }
+    }
+    // Branch node with a single child that is a placeholder → unwrap
+    if (node.namedChildCount === 1) {
+        const onlyChild = node.namedChildren[0];
+        if (onlyChild.namedChildCount === 0) {
+            const decoded = decodePlaceholder(onlyChild.text, placeholders);
+            if (decoded) {
+                if (decoded.name)
+                    metavars.push(decoded.name);
+                if (decoded.kind === "variadic") {
+                    return { kind: "variadic", name: decoded.name, fieldName };
+                }
+                return { kind: "metavar", name: decoded.name, fieldName };
+            }
+            // Legacy $ check
+            const childMeta = isMetavar(onlyChild.text);
+            if (childMeta !== null) {
+                metavars.push(childMeta);
+                return { kind: "metavar", name: childMeta, fieldName };
+            }
+            const childVariadic = isVariadic(onlyChild.text);
+            if (childVariadic !== null) {
+                if (childVariadic)
+                    metavars.push(childVariadic);
+                return { kind: "variadic", name: childVariadic, fieldName };
+            }
+        }
+    }
+    // Leaf node — literal match
+    if (node.namedChildCount === 0) {
+        return { kind: "literal", nodeType: node.type, text, children: [], fieldName };
+    }
+    // Branch node — recurse into named children
+    const children = [];
+    for (const child of node.namedChildren) {
+        const childFieldName = getFieldName(node, child);
+        children.push(buildPatternNode(child, metavars, childFieldName, placeholders));
+    }
+    return { kind: "literal", nodeType: node.type, children, fieldName };
+}
+/** Get the field name for a child node relative to its parent */
+function getFieldName(parent, child) {
+    // Walk parent's children to find the field name for this child
+    for (let i = 0; i < parent.childCount; i++) {
+        const c = parent.child(i);
+        if (c && c.id === child.id) {
+            return parent.fieldNameForChild(i) ?? undefined;
+        }
+    }
+    return undefined;
+}
+// ── Unwrap helpers ──────────────────────────────────────────────────────────
+/** Unwrap from program → first meaningful child */
+function unwrapProgram(root) {
+    if (root.type !== "program" || root.namedChildCount === 0)
+        return null;
+    const child = root.namedChildren[0];
+    // Unwrap expression_statement wrapper if present
+    if (child.type === "expression_statement" && child.namedChildCount === 1) {
+        return child.namedChildren[0];
+    }
+    return child;
+}
+/** Unwrap from module → first meaningful child (Python uses "module" as root) */
+function unwrapModule(root) {
+    if (root.type !== "module" || root.namedChildCount === 0)
+        return null;
+    const child = root.namedChildren[0];
+    if (child.type === "expression_statement" && child.namedChildCount === 1) {
+        return child.namedChildren[0];
+    }
+    return child;
+}
+/** Unwrap from program → expression_statement → parenthesized_expression → inner */
+function unwrapExpression(root) {
+    if (root.type !== "program" || root.namedChildCount === 0)
+        return null;
+    let node = root.namedChildren[0];
+    if (node.type === "expression_statement")
+        node = node.namedChildren[0];
+    if (node.type === "parenthesized_expression" && node.namedChildCount === 1) {
+        return node.namedChildren[0];
+    }
+    return node;
+}
+/** Unwrap from program → function_declaration → body → first statement */
+function unwrapFunctionBody(root) {
+    if (root.type !== "program" || root.namedChildCount === 0)
+        return null;
+    const fn = root.namedChildren[0];
+    if (!fn.type.includes("function"))
+        return null;
+    const body = fn.childForFieldName("body");
+    if (!body || body.namedChildCount === 0)
+        return null;
+    const stmt = body.namedChildren[0];
+    if (stmt.type === "expression_statement" && stmt.namedChildCount === 1) {
+        return stmt.namedChildren[0];
+    }
+    return stmt;
+}
+/** Unwrap from module → function_definition → body → first statement (Python) */
+function unwrapPythonFunctionBody(root) {
+    if (root.type !== "module" || root.namedChildCount === 0)
+        return null;
+    const fn = root.namedChildren[0];
+    if (fn.type !== "function_definition")
+        return null;
+    const body = fn.childForFieldName("body");
+    if (!body || body.namedChildCount === 0)
+        return null;
+    const stmt = body.namedChildren[0];
+    if (stmt.type === "expression_statement" && stmt.namedChildCount === 1) {
+        return stmt.namedChildren[0];
+    }
+    return stmt;
+}
+/** Check if an AST node contains any ERROR nodes */
+function hasErrors(node) {
+    if (node.type === "ERROR" || node.isMissing)
+        return true;
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child && hasErrors(child))
+            return true;
+    }
+    return false;
+}
+//# sourceMappingURL=pattern-compiler.js.map

package/dist/builtin-extensions/pi-lsp-extension/src/tree-sitter/pattern-compiler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pattern-compiler.js","sourceRoot":"","sources":["../../../../../src/builtin-extensions/pi-lsp-extension/src/tree-sitter/pattern-compiler.ts"],"names":[],"mappings":"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","sourcesContent":["// @ts-nocheck\n/**\n * Pattern Compiler — parse metavariable patterns into matchable pattern trees.\n *\n * User-facing patterns use `$NAME` for single-node wildcards and `$$$NAME` for\n * variadic (zero-or-more) wildcards. The pattern string is parsed as code using\n * tree-sitter, then the AST is walked to build a PatternNode tree where\n * metavariable identifiers are replaced with wildcard matchers.\n */\n\nimport type Parser from \"web-tree-sitter\";\nimport type { TreeSitterManager } from \"./parser-manager.js\";\n\ntype SyntaxNode = Parser.SyntaxNode;\n\n// ── Pattern node types ──────────────────────────────────────────────────────\n\nexport type PatternNode =\n  | LiteralPatternNode\n  | MetavarPatternNode\n  | VariadicPatternNode;\n\n/** Matches a concrete AST node — type must match, and either text (leaf) or children (branch) */\nexport interface LiteralPatternNode {\n  kind: \"literal\";\n  /** tree-sitter node type to match (e.g., \"identifier\", \"call_expression\") */\n  nodeType: string;\n  /** For leaf nodes: exact text that must match */\n  text?: string;\n  /** For branch nodes: child patterns to match (named children only) */\n  children: PatternNode[];\n  /** Field name this node occupies in its parent (e.g., \"function\", \"arguments\") */\n  fieldName?: string;\n}\n\n/** Matches any single AST node and captures its text */\nexport interface MetavarPatternNode {\n  kind: \"metavar\";\n  /** Capture name (e.g., \"ARG\" from \"$ARG\") */\n  name: string;\n  /** Field name this node occupies in its parent */\n  fieldName?: string;\n}\n\n/** Matches zero or more consecutive sibling nodes */\nexport interface VariadicPatternNode {\n  kind: \"variadic\";\n  /** Capture name (e.g., \"PARAMS\" from \"$$$PARAMS\", or \"\" for anonymous \"$$$\") */\n  name: string;\n  /** Field name context */\n  fieldName?: string;\n}\n\nexport interface CompiledPattern {\n  /** The root pattern node (unwrapped from program/expression_statement wrappers) */\n  root: PatternNode;\n  /** All metavariable names found in the pattern */\n  metavars: string[];\n  /** The language this pattern was compiled for */\n  languageId: string;\n}\n\n// ── Metavariable detection ──────────────────────────────────────────────────\n\nconst VARIADIC_RE = /^\\$\\$\\$([A-Z_][A-Z0-9_]*)?$/;\nconst METAVAR_RE = /^\\$([A-Z_][A-Z0-9_]*)$/;\n\nfunction isVariadic(text: string): string | null {\n  const m = VARIADIC_RE.exec(text);\n  return m ? (m[1] ?? \"\") : null;\n}\n\nfunction isMetavar(text: string): string | null {\n  const m = METAVAR_RE.exec(text);\n  return m ? m[1] : null;\n}\n\n// ── Metavar placeholder encoding ────────────────────────────────────────────\n\nconst META_PREFIX = \"__META_\";\nconst VMETA_PREFIX = \"__VMETA_\";\nconst META_SUFFIX = \"__\";\n\n/**\n * Replace `$$$NAME` and `$NAME` with placeholder identifiers valid in any language.\n * Returns the preprocessed source and a map from placeholder to {kind, name}.\n */\nfunction preprocessMetavars(source: string): {\n  preprocessed: string;\n  placeholders: Map<string, { kind: \"metavar\" | \"variadic\"; name: string }>;\n} {\n  const placeholders = new Map<string, { kind: \"metavar\" | \"variadic\"; name: string }>();\n\n  // Replace variadic first (longer prefix) to avoid $$ matching $\n  let preprocessed = source.replace(/\\$\\$\\$([A-Z_][A-Z0-9_]*)?/g, (_match, name) => {\n    const n = name ?? \"\";\n    const placeholder = `${VMETA_PREFIX}${n || \"ANON\"}${META_SUFFIX}`;\n    placeholders.set(placeholder, { kind: \"variadic\", name: n });\n    return placeholder;\n  });\n\n  preprocessed = preprocessed.replace(/\\$([A-Z_][A-Z0-9_]*)/g, (_match, name) => {\n    const placeholder = `${META_PREFIX}${name}${META_SUFFIX}`;\n    placeholders.set(placeholder, { kind: \"metavar\", name });\n    return placeholder;\n  });\n\n  return { preprocessed, placeholders };\n}\n\n/** Check if a text is a metavar placeholder */\nfunction decodePlaceholder(\n  text: string,\n  placeholders: Map<string, { kind: \"metavar\" | \"variadic\"; name: string }>,\n): { kind: \"metavar\" | \"variadic\"; name: string } | null {\n  return placeholders.get(text) ?? null;\n}\n\n// ── Compile ─────────────────────────────────────────────────────────────────\n\n/**\n * Compile a user-facing pattern string into a matchable PatternNode tree.\n *\n * Metavariables ($NAME, $$$NAME) are replaced with placeholder identifiers\n * before parsing, so patterns work in any language regardless of whether `$`\n * is a valid identifier character.\n *\n * Tries parsing the pattern as-is first, then with wrapper contexts if it\n * contains syntax errors (e.g., an expression fragment that isn't a valid program).\n */\nexport async function compilePattern(\n  source: string,\n  languageId: string,\n  treeSitter: TreeSitterManager,\n): Promise<CompiledPattern> {\n  await treeSitter.init();\n\n  const { preprocessed, placeholders } = preprocessMetavars(source);\n\n  // Language-specific wrappers for fragments that aren't full programs\n  const wrappers = getWrappersForLanguage(languageId);\n\n  for (const { wrap, unwrap } of wrappers) {\n    const wrapped = wrap(preprocessed);\n    const tree = await treeSitter.parseWithLanguage(\n      `__pattern__${Date.now()}`,\n      wrapped,\n      languageId,\n    );\n    if (!tree) continue;\n\n    const root = tree.rootNode;\n    if (hasErrors(root)) continue;\n\n    const unwrapped = unwrap(root);\n    if (!unwrapped) continue;\n\n    const metavars: string[] = [];\n    const patternNode = buildPatternNode(unwrapped, metavars, undefined, placeholders);\n    return { root: patternNode, metavars: [...new Set(metavars)], languageId };\n  }\n\n  throw new Error(\n    `Failed to parse pattern as ${languageId}. The pattern may have syntax errors ` +\n    `or may not be a valid code fragment in this language.`,\n  );\n}\n\n/** Get wrapper strategies appropriate for a language */\nfunction getWrappersForLanguage(languageId: string): Array<{\n  wrap: (s: string) => string;\n  unwrap: (root: SyntaxNode) => SyntaxNode | null;\n}> {\n  const common = [\n    { wrap: (s: string) => s, unwrap: unwrapProgram },\n    { wrap: (s: string) => `${s};`, unwrap: unwrapProgram },\n    { wrap: (s: string) => `(${s})`, unwrap: unwrapExpression },\n  ];\n\n  switch (languageId) {\n    case \"python\":\n      return [\n        { wrap: (s: string) => s, unwrap: unwrapModule },\n        { wrap: (s: string) => `(${s})`, unwrap: unwrapExpression },\n        { wrap: (s: string) => `def _():\\n  ${s}`, unwrap: unwrapPythonFunctionBody },\n      ];\n    default:\n      return [\n        ...common,\n        { wrap: (s: string) => `function _() { ${s} }`, unwrap: unwrapFunctionBody },\n      ];\n  }\n}\n\n// ── AST → PatternNode conversion ────────────────────────────────────────────\n\nfunction buildPatternNode(\n  node: SyntaxNode,\n  metavars: string[],\n  fieldName: string | undefined,\n  placeholders: Map<string, { kind: \"metavar\" | \"variadic\"; name: string }>,\n): PatternNode {\n  const text = node.text;\n\n  // Check for placeholder-based metavar/variadic (new: language-agnostic)\n  if (node.namedChildCount === 0) {\n    const decoded = decodePlaceholder(text, placeholders);\n    if (decoded) {\n      if (decoded.name) metavars.push(decoded.name);\n      if (decoded.kind === \"variadic\") {\n        return { kind: \"variadic\", name: decoded.name, fieldName };\n      }\n      return { kind: \"metavar\", name: decoded.name, fieldName };\n    }\n  }\n\n  // Also check legacy $-prefixed metavars (for languages where $ is valid)\n  if (node.namedChildCount === 0) {\n    const variadicName = isVariadic(text);\n    if (variadicName !== null) {\n      if (variadicName) metavars.push(variadicName);\n      return { kind: \"variadic\", name: variadicName, fieldName };\n    }\n    const metavarName = isMetavar(text);\n    if (metavarName !== null) {\n      metavars.push(metavarName);\n      return { kind: \"metavar\", name: metavarName, fieldName };\n    }\n  }\n\n  // Branch node with a single child that is a placeholder → unwrap\n  if (node.namedChildCount === 1) {\n    const onlyChild = node.namedChildren[0];\n    if (onlyChild.namedChildCount === 0) {\n      const decoded = decodePlaceholder(onlyChild.text, placeholders);\n      if (decoded) {\n        if (decoded.name) metavars.push(decoded.name);\n        if (decoded.kind === \"variadic\") {\n          return { kind: \"variadic\", name: decoded.name, fieldName };\n        }\n        return { kind: \"metavar\", name: decoded.name, fieldName };\n      }\n      // Legacy $ check\n      const childMeta = isMetavar(onlyChild.text);\n      if (childMeta !== null) {\n        metavars.push(childMeta);\n        return { kind: \"metavar\", name: childMeta, fieldName };\n      }\n      const childVariadic = isVariadic(onlyChild.text);\n      if (childVariadic !== null) {\n        if (childVariadic) metavars.push(childVariadic);\n        return { kind: \"variadic\", name: childVariadic, fieldName };\n      }\n    }\n  }\n\n  // Leaf node — literal match\n  if (node.namedChildCount === 0) {\n    return { kind: \"literal\", nodeType: node.type, text, children: [], fieldName };\n  }\n\n  // Branch node — recurse into named children\n  const children: PatternNode[] = [];\n  for (const child of node.namedChildren) {\n    const childFieldName = getFieldName(node, child);\n    children.push(buildPatternNode(child, metavars, childFieldName, placeholders));\n  }\n\n  return { kind: \"literal\", nodeType: node.type, children, fieldName };\n}\n\n/** Get the field name for a child node relative to its parent */\nfunction getFieldName(parent: SyntaxNode, child: SyntaxNode): string | undefined {\n  // Walk parent's children to find the field name for this child\n  for (let i = 0; i < parent.childCount; i++) {\n    const c = parent.child(i);\n    if (c && c.id === child.id) {\n      return parent.fieldNameForChild(i) ?? undefined;\n    }\n  }\n  return undefined;\n}\n\n// ── Unwrap helpers ──────────────────────────────────────────────────────────\n\n/** Unwrap from program → first meaningful child */\nfunction unwrapProgram(root: SyntaxNode): SyntaxNode | null {\n  if (root.type !== \"program\" || root.namedChildCount === 0) return null;\n  const child = root.namedChildren[0];\n  // Unwrap expression_statement wrapper if present\n  if (child.type === \"expression_statement\" && child.namedChildCount === 1) {\n    return child.namedChildren[0];\n  }\n  return child;\n}\n\n/** Unwrap from module → first meaningful child (Python uses \"module\" as root) */\nfunction unwrapModule(root: SyntaxNode): SyntaxNode | null {\n  if (root.type !== \"module\" || root.namedChildCount === 0) return null;\n  const child = root.namedChildren[0];\n  if (child.type === \"expression_statement\" && child.namedChildCount === 1) {\n    return child.namedChildren[0];\n  }\n  return child;\n}\n\n/** Unwrap from program → expression_statement → parenthesized_expression → inner */\nfunction unwrapExpression(root: SyntaxNode): SyntaxNode | null {\n  if (root.type !== \"program\" || root.namedChildCount === 0) return null;\n  let node = root.namedChildren[0];\n  if (node.type === \"expression_statement\") node = node.namedChildren[0];\n  if (node.type === \"parenthesized_expression\" && node.namedChildCount === 1) {\n    return node.namedChildren[0];\n  }\n  return node;\n}\n\n/** Unwrap from program → function_declaration → body → first statement */\nfunction unwrapFunctionBody(root: SyntaxNode): SyntaxNode | null {\n  if (root.type !== \"program\" || root.namedChildCount === 0) return null;\n  const fn = root.namedChildren[0];\n  if (!fn.type.includes(\"function\")) return null;\n  const body = fn.childForFieldName(\"body\");\n  if (!body || body.namedChildCount === 0) return null;\n  const stmt = body.namedChildren[0];\n  if (stmt.type === \"expression_statement\" && stmt.namedChildCount === 1) {\n    return stmt.namedChildren[0];\n  }\n  return stmt;\n}\n\n/** Unwrap from module → function_definition → body → first statement (Python) */\nfunction unwrapPythonFunctionBody(root: SyntaxNode): SyntaxNode | null {\n  if (root.type !== \"module\" || root.namedChildCount === 0) return null;\n  const fn = root.namedChildren[0];\n  if (fn.type !== \"function_definition\") return null;\n  const body = fn.childForFieldName(\"body\");\n  if (!body || body.namedChildCount === 0) return null;\n  const stmt = body.namedChildren[0];\n  if (stmt.type === \"expression_statement\" && stmt.namedChildCount === 1) {\n    return stmt.namedChildren[0];\n  }\n  return stmt;\n}\n\n/** Check if an AST node contains any ERROR nodes */\nfunction hasErrors(node: SyntaxNode): boolean {\n  if (node.type === \"ERROR\" || node.isMissing) return true;\n  for (let i = 0; i < node.childCount; i++) {\n    const child = node.child(i);\n    if (child && hasErrors(child)) return true;\n  }\n  return false;\n}\n"]}

package/dist/builtin-extensions/pi-lsp-extension/src/tree-sitter/rewrite-engine.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Rewrite Engine — apply structural replacements using matched patterns.
+ *
+ * Takes search matches and a replacement template with metavariable references,
+ * substitutes captured values, and applies the text changes.
+ */
+import type { SearchMatch } from "./search-engine.js";
+export interface RewriteChange {
+    file: string;
+    line: number;
+    column: number;
+    before: string;
+    after: string;
+}
+export interface RewriteResult {
+    changes: RewriteChange[];
+    filesModified: number;
+}
+/**
+ * Substitute metavariable references in a replacement template with captured values.
+ */
+export declare function substituteCaptures(template: string, captures: Record<string, string>): string;
+/**
+ * Compute rewrite changes from matches and a replacement template.
+ * Returns the list of changes without applying them.
+ */
+export declare function computeRewrites(matches: SearchMatch[], replacementTemplate: string): RewriteChange[];
+/**
+ * Apply rewrite changes to files. Modifies files in-place.
+ * Applies changes bottom-up (last offset first) within each file to preserve byte offsets.
+ */
+export declare function applyRewrites(matches: SearchMatch[], replacementTemplate: string): Promise<RewriteResult>;
+//# sourceMappingURL=rewrite-engine.d.ts.map

package/dist/builtin-extensions/pi-lsp-extension/src/tree-sitter/rewrite-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rewrite-engine.d.ts","sourceRoot":"","sources":["../../../../../src/builtin-extensions/pi-lsp-extension/src/tree-sitter/rewrite-engine.ts"],"names":[],"mappings":"AACA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAItD,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,aAAa,EAAE,MAAM,CAAC;CACvB;AAMD;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC/B,MAAM,CAMR;AAiBD;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,WAAW,EAAE,EACtB,mBAAmB,EAAE,MAAM,GAC1B,aAAa,EAAE,CAYjB;AAED;;;GAGG;AACH,wBAAsB,aAAa,CACjC,OAAO,EAAE,WAAW,EAAE,EACtB,mBAAmB,EAAE,MAAM,GAC1B,OAAO,CAAC,aAAa,CAAC,CAmDxB","sourcesContent":["// @ts-nocheck\n/**\n * Rewrite Engine — apply structural replacements using matched patterns.\n *\n * Takes search matches and a replacement template with metavariable references,\n * substitutes captured values, and applies the text changes.\n */\n\nimport { readFile, writeFile } from \"node:fs/promises\";\nimport type { SearchMatch } from \"./search-engine.js\";\n\n// ── Result types ────────────────────────────────────────────────────────────\n\nexport interface RewriteChange {\n  file: string;\n  line: number;\n  column: number;\n  before: string;\n  after: string;\n}\n\nexport interface RewriteResult {\n  changes: RewriteChange[];\n  filesModified: number;\n}\n\n// ── Replacement template substitution ───────────────────────────────────────\n\nconst METAVAR_REF_RE = /\\$\\$\\$([A-Z_][A-Z0-9_]*)|\\$([A-Z_][A-Z0-9_]*)/g;\n\n/**\n * Substitute metavariable references in a replacement template with captured values.\n */\nexport function substituteCaptures(\n  template: string,\n  captures: Record<string, string>,\n): string {\n  return template.replace(METAVAR_REF_RE, (match, variadicName, singleName) => {\n    const name = variadicName ?? singleName;\n    if (name in captures) return captures[name];\n    return match; // Leave unmatched references as-is\n  });\n}\n\n/**\n * If the original matched text ends with a semicolon (possibly preceded by whitespace)\n * and the replacement doesn't, append the semicolon. This preserves statement terminators\n * that are part of the AST node but not part of the pattern/replacement.\n */\nfunction preserveTrailingSemicolon(original: string, replacement: string): string {\n  const trailingMatch = original.match(/(\\s*;)\\s*$/);\n  if (trailingMatch && !replacement.trimEnd().endsWith(\";\")) {\n    return replacement + trailingMatch[1];\n  }\n  return replacement;\n}\n\n// ── Rewrite application ─────────────────────────────────────────────────────\n\n/**\n * Compute rewrite changes from matches and a replacement template.\n * Returns the list of changes without applying them.\n */\nexport function computeRewrites(\n  matches: SearchMatch[],\n  replacementTemplate: string,\n): RewriteChange[] {\n  return matches.map((m) => {\n    const raw = substituteCaptures(replacementTemplate, m.captures);\n    const after = preserveTrailingSemicolon(m.matchedText, raw);\n    return {\n      file: m.file,\n      line: m.line,\n      column: m.column,\n      before: m.matchedText,\n      after,\n    };\n  });\n}\n\n/**\n * Apply rewrite changes to files. Modifies files in-place.\n * Applies changes bottom-up (last offset first) within each file to preserve byte offsets.\n */\nexport async function applyRewrites(\n  matches: SearchMatch[],\n  replacementTemplate: string,\n): Promise<RewriteResult> {\n  // Group matches by file\n  const byFile = new Map<string, SearchMatch[]>();\n  for (const m of matches) {\n    const existing = byFile.get(m.file);\n    if (existing) {\n      existing.push(m);\n    } else {\n      byFile.set(m.file, [m]);\n    }\n  }\n\n  const changes: RewriteChange[] = [];\n  let filesModified = 0;\n\n  for (const [file, fileMatches] of byFile) {\n    // Sort by startIndex descending — apply from bottom to top\n    const sorted = [...fileMatches].sort((a, b) => b.startIndex - a.startIndex);\n\n    let content = await readFile(file, \"utf-8\");\n    let modified = false;\n\n    for (const m of sorted) {\n      const raw = substituteCaptures(replacementTemplate, m.captures);\n      const replacement = preserveTrailingSemicolon(m.matchedText, raw);\n      if (replacement !== m.matchedText) {\n        content =\n          content.slice(0, m.startIndex) +\n          replacement +\n          content.slice(m.endIndex);\n        modified = true;\n      }\n      changes.push({\n        file,\n        line: m.line,\n        column: m.column,\n        before: m.matchedText,\n        after: replacement,\n      });\n    }\n\n    if (modified) {\n      await writeFile(file, content, \"utf-8\");\n      filesModified++;\n    }\n  }\n\n  // Reverse so changes appear top-to-bottom\n  changes.reverse();\n\n  return { changes, filesModified };\n}\n"]}

package/dist/builtin-extensions/pi-lsp-extension/src/tree-sitter/rewrite-engine.js

@@ -0,0 +1,102 @@
+// @ts-nocheck
+/**
+ * Rewrite Engine — apply structural replacements using matched patterns.
+ *
+ * Takes search matches and a replacement template with metavariable references,
+ * substitutes captured values, and applies the text changes.
+ */
+import { readFile, writeFile } from "node:fs/promises";
+// ── Replacement template substitution ───────────────────────────────────────
+const METAVAR_REF_RE = /\$\$\$([A-Z_][A-Z0-9_]*)|\$([A-Z_][A-Z0-9_]*)/g;
+/**
+ * Substitute metavariable references in a replacement template with captured values.
+ */
+export function substituteCaptures(template, captures) {
+    return template.replace(METAVAR_REF_RE, (match, variadicName, singleName) => {
+        const name = variadicName ?? singleName;
+        if (name in captures)
+            return captures[name];
+        return match; // Leave unmatched references as-is
+    });
+}
+/**
+ * If the original matched text ends with a semicolon (possibly preceded by whitespace)
+ * and the replacement doesn't, append the semicolon. This preserves statement terminators
+ * that are part of the AST node but not part of the pattern/replacement.
+ */
+function preserveTrailingSemicolon(original, replacement) {
+    const trailingMatch = original.match(/(\s*;)\s*$/);
+    if (trailingMatch && !replacement.trimEnd().endsWith(";")) {
+        return replacement + trailingMatch[1];
+    }
+    return replacement;
+}
+// ── Rewrite application ─────────────────────────────────────────────────────
+/**
+ * Compute rewrite changes from matches and a replacement template.
+ * Returns the list of changes without applying them.
+ */
+export function computeRewrites(matches, replacementTemplate) {
+    return matches.map((m) => {
+        const raw = substituteCaptures(replacementTemplate, m.captures);
+        const after = preserveTrailingSemicolon(m.matchedText, raw);
+        return {
+            file: m.file,
+            line: m.line,
+            column: m.column,
+            before: m.matchedText,
+            after,
+        };
+    });
+}
+/**
+ * Apply rewrite changes to files. Modifies files in-place.
+ * Applies changes bottom-up (last offset first) within each file to preserve byte offsets.
+ */
+export async function applyRewrites(matches, replacementTemplate) {
+    // Group matches by file
+    const byFile = new Map();
+    for (const m of matches) {
+        const existing = byFile.get(m.file);
+        if (existing) {
+            existing.push(m);
+        }
+        else {
+            byFile.set(m.file, [m]);
+        }
+    }
+    const changes = [];
+    let filesModified = 0;
+    for (const [file, fileMatches] of byFile) {
+        // Sort by startIndex descending — apply from bottom to top
+        const sorted = [...fileMatches].sort((a, b) => b.startIndex - a.startIndex);
+        let content = await readFile(file, "utf-8");
+        let modified = false;
+        for (const m of sorted) {
+            const raw = substituteCaptures(replacementTemplate, m.captures);
+            const replacement = preserveTrailingSemicolon(m.matchedText, raw);
+            if (replacement !== m.matchedText) {
+                content =
+                    content.slice(0, m.startIndex) +
+                        replacement +
+                        content.slice(m.endIndex);
+                modified = true;
+            }
+            changes.push({
+                file,
+                line: m.line,
+                column: m.column,
+                before: m.matchedText,
+                after: replacement,
+            });
+        }
+        if (modified) {
+            await writeFile(file, content, "utf-8");
+            filesModified++;
+        }
+    }
+    // Reverse so changes appear top-to-bottom
+    changes.reverse();
+    return { changes, filesModified };
+}
+//# sourceMappingURL=rewrite-engine.js.map

package/dist/builtin-extensions/pi-lsp-extension/src/tree-sitter/rewrite-engine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rewrite-engine.js","sourceRoot":"","sources":["../../../../../src/builtin-extensions/pi-lsp-extension/src/tree-sitter/rewrite-engine.ts"],"names":[],"mappings":"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","sourcesContent":["// @ts-nocheck\n/**\n * Rewrite Engine — apply structural replacements using matched patterns.\n *\n * Takes search matches and a replacement template with metavariable references,\n * substitutes captured values, and applies the text changes.\n */\n\nimport { readFile, writeFile } from \"node:fs/promises\";\nimport type { SearchMatch } from \"./search-engine.js\";\n\n// ── Result types ────────────────────────────────────────────────────────────\n\nexport interface RewriteChange {\n  file: string;\n  line: number;\n  column: number;\n  before: string;\n  after: string;\n}\n\nexport interface RewriteResult {\n  changes: RewriteChange[];\n  filesModified: number;\n}\n\n// ── Replacement template substitution ───────────────────────────────────────\n\nconst METAVAR_REF_RE = /\\$\\$\\$([A-Z_][A-Z0-9_]*)|\\$([A-Z_][A-Z0-9_]*)/g;\n\n/**\n * Substitute metavariable references in a replacement template with captured values.\n */\nexport function substituteCaptures(\n  template: string,\n  captures: Record<string, string>,\n): string {\n  return template.replace(METAVAR_REF_RE, (match, variadicName, singleName) => {\n    const name = variadicName ?? singleName;\n    if (name in captures) return captures[name];\n    return match; // Leave unmatched references as-is\n  });\n}\n\n/**\n * If the original matched text ends with a semicolon (possibly preceded by whitespace)\n * and the replacement doesn't, append the semicolon. This preserves statement terminators\n * that are part of the AST node but not part of the pattern/replacement.\n */\nfunction preserveTrailingSemicolon(original: string, replacement: string): string {\n  const trailingMatch = original.match(/(\\s*;)\\s*$/);\n  if (trailingMatch && !replacement.trimEnd().endsWith(\";\")) {\n    return replacement + trailingMatch[1];\n  }\n  return replacement;\n}\n\n// ── Rewrite application ─────────────────────────────────────────────────────\n\n/**\n * Compute rewrite changes from matches and a replacement template.\n * Returns the list of changes without applying them.\n */\nexport function computeRewrites(\n  matches: SearchMatch[],\n  replacementTemplate: string,\n): RewriteChange[] {\n  return matches.map((m) => {\n    const raw = substituteCaptures(replacementTemplate, m.captures);\n    const after = preserveTrailingSemicolon(m.matchedText, raw);\n    return {\n      file: m.file,\n      line: m.line,\n      column: m.column,\n      before: m.matchedText,\n      after,\n    };\n  });\n}\n\n/**\n * Apply rewrite changes to files. Modifies files in-place.\n * Applies changes bottom-up (last offset first) within each file to preserve byte offsets.\n */\nexport async function applyRewrites(\n  matches: SearchMatch[],\n  replacementTemplate: string,\n): Promise<RewriteResult> {\n  // Group matches by file\n  const byFile = new Map<string, SearchMatch[]>();\n  for (const m of matches) {\n    const existing = byFile.get(m.file);\n    if (existing) {\n      existing.push(m);\n    } else {\n      byFile.set(m.file, [m]);\n    }\n  }\n\n  const changes: RewriteChange[] = [];\n  let filesModified = 0;\n\n  for (const [file, fileMatches] of byFile) {\n    // Sort by startIndex descending — apply from bottom to top\n    const sorted = [...fileMatches].sort((a, b) => b.startIndex - a.startIndex);\n\n    let content = await readFile(file, \"utf-8\");\n    let modified = false;\n\n    for (const m of sorted) {\n      const raw = substituteCaptures(replacementTemplate, m.captures);\n      const replacement = preserveTrailingSemicolon(m.matchedText, raw);\n      if (replacement !== m.matchedText) {\n        content =\n          content.slice(0, m.startIndex) +\n          replacement +\n          content.slice(m.endIndex);\n        modified = true;\n      }\n      changes.push({\n        file,\n        line: m.line,\n        column: m.column,\n        before: m.matchedText,\n        after: replacement,\n      });\n    }\n\n    if (modified) {\n      await writeFile(file, content, \"utf-8\");\n      filesModified++;\n    }\n  }\n\n  // Reverse so changes appear top-to-bottom\n  changes.reverse();\n\n  return { changes, filesModified };\n}\n"]}

package/dist/builtin-extensions/pi-lsp-extension/src/tree-sitter/search-engine.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Search Engine — run compiled patterns against source files and collect matches.
+ *
+ * Uses a recursive AST matcher: the target file's tree-sitter AST is walked
+ * depth-first, and at each node we attempt to match the compiled pattern tree.
+ * Metavariable nodes capture any single AST node; variadic nodes capture
+ * zero-or-more siblings.
+ */
+import type { TreeSitterManager } from "./parser-manager.js";
+import type { CompiledPattern } from "./pattern-compiler.js";
+export interface SearchMatch {
+    /** Absolute file path */
+    file: string;
+    /** 1-indexed line number */
+    line: number;
+    /** 1-indexed column */
+    column: number;
+    /** The matched source text */
+    matchedText: string;
+    /** Byte offset of match start */
+    startIndex: number;
+    /** Byte offset of match end */
+    endIndex: number;
+    /** Metavariable bindings: name → captured text */
+    captures: Record<string, string>;
+}
+/**
+ * Search files for matches against a compiled pattern.
+ */
+export declare function searchFiles(pattern: CompiledPattern, rootDir: string, treeSitter: TreeSitterManager, options?: {
+    path?: string;
+    maxResults?: number;
+}): Promise<SearchMatch[]>;
+/**
+ * Collect all files matching a given language under a directory.
+ */
+export declare function collectFilesByLanguage(dir: string, languageId: string, treeSitter: TreeSitterManager, collected?: string[], maxFiles?: number): Promise<string[]>;
+//# sourceMappingURL=search-engine.d.ts.map

package/dist/builtin-extensions/pi-lsp-extension/src/tree-sitter/search-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-engine.d.ts","sourceRoot":"","sources":["../../../../../src/builtin-extensions/pi-lsp-extension/src/tree-sitter/search-engine.ts"],"names":[],"mappings":"AACA;;;;;;;GAOG;AAKH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,KAAK,EACV,eAAe,EAEhB,MAAM,uBAAuB,CAAC;AAO/B,MAAM,WAAW,WAAW;IAC1B,yBAAyB;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,4BAA4B;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,uBAAuB;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,8BAA8B;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,iCAAiC;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,+BAA+B;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,oDAAkD;IAClD,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC;AAQD;;GAEG;AACH,wBAAsB,WAAW,CAC/B,OAAO,EAAE,eAAe,EACxB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,iBAAiB,EAC7B,OAAO,GAAE;IACP,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;CAChB,GACL,OAAO,CAAC,WAAW,EAAE,CAAC,CA0CxB;AAID;;GAEG;AACH,wBAAsB,sBAAsB,CAC1C,GAAG,EAAE,MAAM,EACX,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,iBAAiB,EAC7B,SAAS,GAAE,MAAM,EAAO,EACxB,QAAQ,GAAE,MAAwB,GACjC,OAAO,CAAC,MAAM,EAAE,CAAC,CA6BnB","sourcesContent":["// @ts-nocheck\n/**\n * Search Engine — run compiled patterns against source files and collect matches.\n *\n * Uses a recursive AST matcher: the target file's tree-sitter AST is walked\n * depth-first, and at each node we attempt to match the compiled pattern tree.\n * Metavariable nodes capture any single AST node; variadic nodes capture\n * zero-or-more siblings.\n */\n\nimport { resolve } from \"node:path\";\nimport { readdir, readFile, stat } from \"node:fs/promises\";\nimport type Parser from \"web-tree-sitter\";\nimport type { TreeSitterManager } from \"./parser-manager.js\";\nimport type {\n  CompiledPattern,\n  PatternNode,\n} from \"./pattern-compiler.js\";\nimport { SKIP_DIRS, MAX_FILE_SIZE, MAX_INDEX_FILES } from \"../shared/constants.js\";\n\ntype SyntaxNode = Parser.SyntaxNode;\n\n// ── Result types ────────────────────────────────────────────────────────────\n\nexport interface SearchMatch {\n  /** Absolute file path */\n  file: string;\n  /** 1-indexed line number */\n  line: number;\n  /** 1-indexed column */\n  column: number;\n  /** The matched source text */\n  matchedText: string;\n  /** Byte offset of match start */\n  startIndex: number;\n  /** Byte offset of match end */\n  endIndex: number;\n  /** Metavariable bindings: name → captured text */\n  captures: Record<string, string>;\n}\n\n// ── Directories to skip ─────────────────────────────────────────────────────\n\n// Shared constants imported from ../shared/constants.ts\n\n// ── Public API ──────────────────────────────────────────────────────────────\n\n/**\n * Search files for matches against a compiled pattern.\n */\nexport async function searchFiles(\n  pattern: CompiledPattern,\n  rootDir: string,\n  treeSitter: TreeSitterManager,\n  options: {\n    path?: string;\n    maxResults?: number;\n  } = {},\n): Promise<SearchMatch[]> {\n  const searchRoot = options.path ? resolve(rootDir, options.path) : rootDir;\n  const maxResults = options.maxResults ?? 50;\n\n  // Determine if searchRoot is a file or directory\n  const stats = await stat(searchRoot);\n  let files: string[];\n  if (stats.isFile()) {\n    files = [searchRoot];\n  } else {\n    files = await collectFilesByLanguage(searchRoot, pattern.languageId, treeSitter);\n  }\n\n  const matches: SearchMatch[] = [];\n\n  for (const file of files) {\n    if (matches.length >= maxResults) break;\n\n    try {\n      const content = await readFile(file, \"utf-8\");\n      const tree = await treeSitter.parseWithLanguage(file, content, pattern.languageId);\n      if (!tree) continue;\n\n      const fileMatches = findMatches(tree.rootNode, pattern.root);\n      for (const m of fileMatches) {\n        if (matches.length >= maxResults) break;\n        matches.push({\n          file,\n          line: m.node.startPosition.row + 1,\n          column: m.node.startPosition.column + 1,\n          matchedText: m.node.text,\n          startIndex: m.node.startIndex,\n          endIndex: m.node.endIndex,\n          captures: m.captures,\n        });\n      }\n    } catch {\n      // Skip unreadable files\n    }\n  }\n\n  return matches;\n}\n\n// ── File collection ─────────────────────────────────────────────────────────\n\n/**\n * Collect all files matching a given language under a directory.\n */\nexport async function collectFilesByLanguage(\n  dir: string,\n  languageId: string,\n  treeSitter: TreeSitterManager,\n  collected: string[] = [],\n  maxFiles: number = MAX_INDEX_FILES,\n): Promise<string[]> {\n  if (collected.length >= maxFiles) return collected;\n\n  try {\n    const entries = await readdir(dir, { withFileTypes: true });\n    for (const entry of entries) {\n      if (collected.length >= maxFiles) break;\n\n      if (entry.isDirectory()) {\n        if (SKIP_DIRS.has(entry.name) || entry.name.startsWith(\".\")) continue;\n        await collectFilesByLanguage(resolve(dir, entry.name), languageId, treeSitter, collected, maxFiles);\n      } else if (entry.isFile()) {\n        const fileLang = treeSitter.getLanguageId(entry.name);\n        if (fileLang === languageId) {\n          const filePath = resolve(dir, entry.name);\n          try {\n            const s = await stat(filePath);\n            if (s.size <= MAX_FILE_SIZE) {\n              collected.push(filePath);\n            }\n          } catch {}\n        }\n      }\n    }\n  } catch {\n    // Permission denied or other IO error — skip\n  }\n\n  return collected;\n}\n\n// ── Matching engine ─────────────────────────────────────────────────────────\n\ninterface RawMatch {\n  node: SyntaxNode;\n  captures: Record<string, string>;\n}\n\n/**\n * Find all non-overlapping matches of the pattern in the target AST.\n * Walks the tree depth-first, attempting to match at each node.\n */\nfunction findMatches(root: SyntaxNode, pattern: PatternNode): RawMatch[] {\n  const matches: RawMatch[] = [];\n  const visited = new Set<number>(); // node ids already part of a match\n\n  function walk(node: SyntaxNode): void {\n    if (visited.has(node.id)) return;\n\n    const captures: Record<string, string> = {};\n    if (matchNode(node, pattern, captures)) {\n      matches.push({ node, captures });\n      // Mark all descendant nodes as visited to prevent overlapping matches\n      markDescendants(node, visited);\n      return; // Don't recurse into matched subtree\n    }\n\n    // Recurse into children\n    for (const child of node.namedChildren) {\n      walk(child);\n    }\n  }\n\n  walk(root);\n  return matches;\n}\n\nfunction markDescendants(node: SyntaxNode, visited: Set<number>): void {\n  visited.add(node.id);\n  for (const child of node.namedChildren) {\n    markDescendants(child, visited);\n  }\n}\n\n/**\n * Try to match a target AST node against a pattern node.\n * Returns true if matched, populating `captures` with metavariable bindings.\n */\nfunction matchNode(\n  target: SyntaxNode,\n  pattern: PatternNode,\n  captures: Record<string, string>,\n): boolean {\n  switch (pattern.kind) {\n    case \"metavar\": {\n      // A metavar matches any single node\n      const name = pattern.name;\n      if (name in captures) {\n        // Already captured — must match same text\n        return captures[name] === target.text;\n      }\n      captures[name] = target.text;\n      return true;\n    }\n\n    case \"variadic\": {\n      // Variadic at the top level matches any single node\n      // (variadic is really only meaningful in a children-list context)\n      const name = pattern.name;\n      if (name && name in captures) {\n        return captures[name] === target.text;\n      }\n      if (name) captures[name] = target.text;\n      return true;\n    }\n\n    case \"literal\": {\n      // Must match node type\n      if (target.type !== pattern.nodeType) return false;\n\n      // Leaf node: must match text exactly\n      if (pattern.text !== undefined) {\n        return target.text === pattern.text;\n      }\n\n      // Branch node: use field-aware matching\n      // Pattern children that have field names → match against target children with same field name\n      // This allows the target to have extra children not mentioned in the pattern\n      return matchChildrenFieldAware(target, pattern.children, captures);\n    }\n  }\n}\n\n/**\n * Match pattern children against target node's children using field-name-aware matching.\n *\n * Strategy:\n * 1. Pattern children WITH field names: find the target child with the same field name and match\n * 2. Pattern children WITHOUT field names: match positionally against unmatched target children\n * 3. Extra target children not mentioned in the pattern are allowed (implicit wildcards)\n */\nfunction matchChildrenFieldAware(\n  targetNode: SyntaxNode,\n  patternChildren: PatternNode[],\n  captures: Record<string, string>,\n): boolean {\n  // Separate pattern children into field-named and positional\n  const fieldPatterns: PatternNode[] = [];\n  const positionalPatterns: PatternNode[] = [];\n\n  for (const pc of patternChildren) {\n    if (pc.fieldName) {\n      fieldPatterns.push(pc);\n    } else {\n      positionalPatterns.push(pc);\n    }\n  }\n\n  // First, match all field-named pattern children\n  for (const fp of fieldPatterns) {\n    const targetChild = targetNode.childForFieldName(fp.fieldName!);\n    if (!targetChild) return false;\n    if (!matchNode(targetChild, fp, captures)) return false;\n  }\n\n  // If there are positional patterns, match them against the remaining unnamed target children\n  if (positionalPatterns.length > 0) {\n    // Get target children that aren't already matched by field names\n    const matchedFieldNames = new Set(fieldPatterns.map(fp => fp.fieldName));\n    const remainingTargets: SyntaxNode[] = [];\n    for (const child of targetNode.namedChildren) {\n      const childField = getChildFieldName(targetNode, child);\n      if (!childField || !matchedFieldNames.has(childField)) {\n        remainingTargets.push(child);\n      }\n    }\n\n    return matchChildrenPositional(remainingTargets, 0, positionalPatterns, 0, captures);\n  }\n\n  return true;\n}\n\n/** Get the field name of a child node within its parent */\nfunction getChildFieldName(parent: SyntaxNode, child: SyntaxNode): string | null {\n  for (let i = 0; i < parent.childCount; i++) {\n    const c = parent.child(i);\n    if (c && c.id === child.id) {\n      return parent.fieldNameForChild(i);\n    }\n  }\n  return null;\n}\n\n/**\n * Match pattern children positionally against target children.\n * Handles variadic patterns that can match zero or more consecutive children.\n * Extra target children at the end are allowed (pattern doesn't need to cover all children).\n */\nfunction matchChildrenPositional(\n  targets: SyntaxNode[],\n  ti: number,\n  patterns: PatternNode[],\n  pi: number,\n  captures: Record<string, string>,\n): boolean {\n  // All patterns consumed — success (extra targets are OK)\n  if (pi >= patterns.length) return true;\n\n  const pat = patterns[pi];\n\n  // Variadic pattern: try matching 0, 1, 2, ... consecutive target nodes\n  if (pat.kind === \"variadic\") {\n    const isLast = pi === patterns.length - 1;\n\n    // Optimization: if this is the last pattern, consume all remaining\n    if (isLast) {\n      const remainingText = targets.slice(ti).map(t => t.text).join(\", \");\n      if (pat.name) {\n        if (pat.name in captures && captures[pat.name] !== remainingText) return false;\n        captures[pat.name] = remainingText;\n      }\n      return true;\n    }\n\n    // Try consuming 0..N target nodes\n    for (let take = 0; take <= targets.length - ti; take++) {\n      const captureSnapshot = { ...captures };\n      const consumedText = targets.slice(ti, ti + take).map(t => t.text).join(\", \");\n\n      if (pat.name) {\n        if (pat.name in captureSnapshot && captureSnapshot[pat.name] !== consumedText) continue;\n        captureSnapshot[pat.name] = consumedText;\n      }\n\n      if (matchChildrenPositional(targets, ti + take, patterns, pi + 1, captureSnapshot)) {\n        // Success — commit captures\n        Object.assign(captures, captureSnapshot);\n        return true;\n      }\n    }\n    return false;\n  }\n\n  // Non-variadic pattern: must match the current target\n  if (ti >= targets.length) return false;\n\n  const captureSnapshot = { ...captures };\n  if (matchNode(targets[ti], pat, captureSnapshot)) {\n    if (matchChildrenPositional(targets, ti + 1, patterns, pi + 1, captureSnapshot)) {\n      Object.assign(captures, captureSnapshot);\n      return true;\n    }\n  }\n\n  return false;\n}\n"]}