@ashx-j/lunr 0.1.0

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

@@ -0,0 +1,276 @@
+// @ts-nocheck
+/**
+ * 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 { resolve } from "node:path";
+import { readdir, readFile, stat } from "node:fs/promises";
+import { SKIP_DIRS, MAX_FILE_SIZE, MAX_INDEX_FILES } from "../shared/constants.js";
+// ── Directories to skip ─────────────────────────────────────────────────────
+// Shared constants imported from ../shared/constants.ts
+// ── Public API ──────────────────────────────────────────────────────────────
+/**
+ * Search files for matches against a compiled pattern.
+ */
+export async function searchFiles(pattern, rootDir, treeSitter, options = {}) {
+    const searchRoot = options.path ? resolve(rootDir, options.path) : rootDir;
+    const maxResults = options.maxResults ?? 50;
+    // Determine if searchRoot is a file or directory
+    const stats = await stat(searchRoot);
+    let files;
+    if (stats.isFile()) {
+        files = [searchRoot];
+    }
+    else {
+        files = await collectFilesByLanguage(searchRoot, pattern.languageId, treeSitter);
+    }
+    const matches = [];
+    for (const file of files) {
+        if (matches.length >= maxResults)
+            break;
+        try {
+            const content = await readFile(file, "utf-8");
+            const tree = await treeSitter.parseWithLanguage(file, content, pattern.languageId);
+            if (!tree)
+                continue;
+            const fileMatches = findMatches(tree.rootNode, pattern.root);
+            for (const m of fileMatches) {
+                if (matches.length >= maxResults)
+                    break;
+                matches.push({
+                    file,
+                    line: m.node.startPosition.row + 1,
+                    column: m.node.startPosition.column + 1,
+                    matchedText: m.node.text,
+                    startIndex: m.node.startIndex,
+                    endIndex: m.node.endIndex,
+                    captures: m.captures,
+                });
+            }
+        }
+        catch {
+            // Skip unreadable files
+        }
+    }
+    return matches;
+}
+// ── File collection ─────────────────────────────────────────────────────────
+/**
+ * Collect all files matching a given language under a directory.
+ */
+export async function collectFilesByLanguage(dir, languageId, treeSitter, collected = [], maxFiles = MAX_INDEX_FILES) {
+    if (collected.length >= maxFiles)
+        return collected;
+    try {
+        const entries = await readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (collected.length >= maxFiles)
+                break;
+            if (entry.isDirectory()) {
+                if (SKIP_DIRS.has(entry.name) || entry.name.startsWith("."))
+                    continue;
+                await collectFilesByLanguage(resolve(dir, entry.name), languageId, treeSitter, collected, maxFiles);
+            }
+            else if (entry.isFile()) {
+                const fileLang = treeSitter.getLanguageId(entry.name);
+                if (fileLang === languageId) {
+                    const filePath = resolve(dir, entry.name);
+                    try {
+                        const s = await stat(filePath);
+                        if (s.size <= MAX_FILE_SIZE) {
+                            collected.push(filePath);
+                        }
+                    }
+                    catch { }
+                }
+            }
+        }
+    }
+    catch {
+        // Permission denied or other IO error — skip
+    }
+    return collected;
+}
+/**
+ * Find all non-overlapping matches of the pattern in the target AST.
+ * Walks the tree depth-first, attempting to match at each node.
+ */
+function findMatches(root, pattern) {
+    const matches = [];
+    const visited = new Set(); // node ids already part of a match
+    function walk(node) {
+        if (visited.has(node.id))
+            return;
+        const captures = {};
+        if (matchNode(node, pattern, captures)) {
+            matches.push({ node, captures });
+            // Mark all descendant nodes as visited to prevent overlapping matches
+            markDescendants(node, visited);
+            return; // Don't recurse into matched subtree
+        }
+        // Recurse into children
+        for (const child of node.namedChildren) {
+            walk(child);
+        }
+    }
+    walk(root);
+    return matches;
+}
+function markDescendants(node, visited) {
+    visited.add(node.id);
+    for (const child of node.namedChildren) {
+        markDescendants(child, visited);
+    }
+}
+/**
+ * Try to match a target AST node against a pattern node.
+ * Returns true if matched, populating `captures` with metavariable bindings.
+ */
+function matchNode(target, pattern, captures) {
+    switch (pattern.kind) {
+        case "metavar": {
+            // A metavar matches any single node
+            const name = pattern.name;
+            if (name in captures) {
+                // Already captured — must match same text
+                return captures[name] === target.text;
+            }
+            captures[name] = target.text;
+            return true;
+        }
+        case "variadic": {
+            // Variadic at the top level matches any single node
+            // (variadic is really only meaningful in a children-list context)
+            const name = pattern.name;
+            if (name && name in captures) {
+                return captures[name] === target.text;
+            }
+            if (name)
+                captures[name] = target.text;
+            return true;
+        }
+        case "literal": {
+            // Must match node type
+            if (target.type !== pattern.nodeType)
+                return false;
+            // Leaf node: must match text exactly
+            if (pattern.text !== undefined) {
+                return target.text === pattern.text;
+            }
+            // Branch node: use field-aware matching
+            // Pattern children that have field names → match against target children with same field name
+            // This allows the target to have extra children not mentioned in the pattern
+            return matchChildrenFieldAware(target, pattern.children, captures);
+        }
+    }
+}
+/**
+ * Match pattern children against target node's children using field-name-aware matching.
+ *
+ * Strategy:
+ * 1. Pattern children WITH field names: find the target child with the same field name and match
+ * 2. Pattern children WITHOUT field names: match positionally against unmatched target children
+ * 3. Extra target children not mentioned in the pattern are allowed (implicit wildcards)
+ */
+function matchChildrenFieldAware(targetNode, patternChildren, captures) {
+    // Separate pattern children into field-named and positional
+    const fieldPatterns = [];
+    const positionalPatterns = [];
+    for (const pc of patternChildren) {
+        if (pc.fieldName) {
+            fieldPatterns.push(pc);
+        }
+        else {
+            positionalPatterns.push(pc);
+        }
+    }
+    // First, match all field-named pattern children
+    for (const fp of fieldPatterns) {
+        const targetChild = targetNode.childForFieldName(fp.fieldName);
+        if (!targetChild)
+            return false;
+        if (!matchNode(targetChild, fp, captures))
+            return false;
+    }
+    // If there are positional patterns, match them against the remaining unnamed target children
+    if (positionalPatterns.length > 0) {
+        // Get target children that aren't already matched by field names
+        const matchedFieldNames = new Set(fieldPatterns.map(fp => fp.fieldName));
+        const remainingTargets = [];
+        for (const child of targetNode.namedChildren) {
+            const childField = getChildFieldName(targetNode, child);
+            if (!childField || !matchedFieldNames.has(childField)) {
+                remainingTargets.push(child);
+            }
+        }
+        return matchChildrenPositional(remainingTargets, 0, positionalPatterns, 0, captures);
+    }
+    return true;
+}
+/** Get the field name of a child node within its parent */
+function getChildFieldName(parent, child) {
+    for (let i = 0; i < parent.childCount; i++) {
+        const c = parent.child(i);
+        if (c && c.id === child.id) {
+            return parent.fieldNameForChild(i);
+        }
+    }
+    return null;
+}
+/**
+ * Match pattern children positionally against target children.
+ * Handles variadic patterns that can match zero or more consecutive children.
+ * Extra target children at the end are allowed (pattern doesn't need to cover all children).
+ */
+function matchChildrenPositional(targets, ti, patterns, pi, captures) {
+    // All patterns consumed — success (extra targets are OK)
+    if (pi >= patterns.length)
+        return true;
+    const pat = patterns[pi];
+    // Variadic pattern: try matching 0, 1, 2, ... consecutive target nodes
+    if (pat.kind === "variadic") {
+        const isLast = pi === patterns.length - 1;
+        // Optimization: if this is the last pattern, consume all remaining
+        if (isLast) {
+            const remainingText = targets.slice(ti).map(t => t.text).join(", ");
+            if (pat.name) {
+                if (pat.name in captures && captures[pat.name] !== remainingText)
+                    return false;
+                captures[pat.name] = remainingText;
+            }
+            return true;
+        }
+        // Try consuming 0..N target nodes
+        for (let take = 0; take <= targets.length - ti; take++) {
+            const captureSnapshot = { ...captures };
+            const consumedText = targets.slice(ti, ti + take).map(t => t.text).join(", ");
+            if (pat.name) {
+                if (pat.name in captureSnapshot && captureSnapshot[pat.name] !== consumedText)
+                    continue;
+                captureSnapshot[pat.name] = consumedText;
+            }
+            if (matchChildrenPositional(targets, ti + take, patterns, pi + 1, captureSnapshot)) {
+                // Success — commit captures
+                Object.assign(captures, captureSnapshot);
+                return true;
+            }
+        }
+        return false;
+    }
+    // Non-variadic pattern: must match the current target
+    if (ti >= targets.length)
+        return false;
+    const captureSnapshot = { ...captures };
+    if (matchNode(targets[ti], pat, captureSnapshot)) {
+        if (matchChildrenPositional(targets, ti + 1, patterns, pi + 1, captureSnapshot)) {
+            Object.assign(captures, captureSnapshot);
+            return true;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=search-engine.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"search-engine.js","sourceRoot":"","sources":["../../../../../src/builtin-extensions/pi-lsp-extension/src/tree-sitter/search-engine.ts"],"names":[],"mappings":"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","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"]}

package/dist/builtin-extensions/pi-lsp-extension/src/tree-sitter/symbol-extractor.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Symbol Extractor — extracts symbols from tree-sitter ASTs.
+ *
+ * Per-language node type mappings for functions, classes, methods, interfaces, etc.
+ * Output format matches LSP DocumentSymbol shape for compatibility.
+ */
+import type Parser from "web-tree-sitter";
+type Tree = Parser.Tree;
+type Node = Parser.SyntaxNode;
+/** Symbol kinds matching LSP SymbolKind values */
+export declare const SymbolKind: {
+    readonly File: 1;
+    readonly Module: 2;
+    readonly Namespace: 3;
+    readonly Package: 4;
+    readonly Class: 5;
+    readonly Method: 6;
+    readonly Property: 7;
+    readonly Field: 8;
+    readonly Constructor: 9;
+    readonly Enum: 10;
+    readonly Interface: 11;
+    readonly Function: 12;
+    readonly Variable: 13;
+    readonly Constant: 14;
+    readonly String: 15;
+    readonly Number: 16;
+    readonly Boolean: 17;
+    readonly Array: 18;
+    readonly Object: 19;
+    readonly Struct: 22;
+};
+export type SymbolKindValue = typeof SymbolKind[keyof typeof SymbolKind];
+export interface SymbolInfo {
+    name: string;
+    kind: SymbolKindValue;
+    line: number;
+    endLine: number;
+    children?: SymbolInfo[];
+}
+/**
+ * Extract symbols from a parsed tree.
+ */
+export declare function extractSymbols(tree: Tree, languageId: string): SymbolInfo[];
+/**
+ * Get the named node at a specific position in the tree.
+ * Returns the smallest named node that contains the position.
+ */
+export declare function getNodeAtPosition(tree: Tree, line: number, character: number): Node | null;
+/**
+ * Find definition(s) of a symbol name within a tree.
+ * Searches for declaration nodes whose name matches.
+ */
+export declare function findDefinition(tree: Tree, symbolName: string, languageId: string): SymbolInfo[];
+/**
+ * Get syntax errors from a parsed tree.
+ * Returns ERROR and MISSING nodes as diagnostic-like objects.
+ */
+export declare function getSyntaxErrors(tree: Tree): Array<{
+    line: number;
+    character: number;
+    endLine: number;
+    endCharacter: number;
+    message: string;
+}>;
+/**
+ * Get the signature text for a node (for hover info).
+ * Extracts the first line of the declaration.
+ */
+export declare function getSignatureText(node: Node): string;
+/**
+ * Get the enclosing declaration node for a position.
+ * Walks up from the node at position to find the nearest declaration.
+ */
+export declare function getEnclosingDeclaration(tree: Tree, line: number, character: number): Node | null;
+export {};
+//# sourceMappingURL=symbol-extractor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"symbol-extractor.d.ts","sourceRoot":"","sources":["../../../../../src/builtin-extensions/pi-lsp-extension/src/tree-sitter/symbol-extractor.ts"],"names":[],"mappings":"AACA;;;;;GAKG;AAEH,OAAO,KAAK,MAAM,MAAM,iBAAiB,CAAC;AAE1C,KAAK,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;AACxB,KAAK,IAAI,GAAG,MAAM,CAAC,UAAU,CAAC;AAE9B,kDAAkD;AAClD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;CAKb,CAAC;AAEX,MAAM,MAAM,eAAe,GAAG,OAAO,UAAU,CAAC,MAAM,OAAO,UAAU,CAAC,CAAC;AAEzE,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,UAAU,EAAE,CAAC;CACzB;AA6FD;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,GAAG,UAAU,EAAE,CAI3E;AA6JD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAI1F;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,UAAU,EAAE,CAG/F;AAWD;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,GAAG,KAAK,CAAC;IACjD,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC,CAoCD;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAKnD;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAqBhG","sourcesContent":["// @ts-nocheck\n/**\n * Symbol Extractor — extracts symbols from tree-sitter ASTs.\n *\n * Per-language node type mappings for functions, classes, methods, interfaces, etc.\n * Output format matches LSP DocumentSymbol shape for compatibility.\n */\n\nimport type Parser from \"web-tree-sitter\";\n\ntype Tree = Parser.Tree;\ntype Node = Parser.SyntaxNode;\n\n/** Symbol kinds matching LSP SymbolKind values */\nexport const SymbolKind = {\n  File: 1, Module: 2, Namespace: 3, Package: 4, Class: 5, Method: 6,\n  Property: 7, Field: 8, Constructor: 9, Enum: 10, Interface: 11,\n  Function: 12, Variable: 13, Constant: 14, String: 15, Number: 16,\n  Boolean: 17, Array: 18, Object: 19, Struct: 22,\n} as const;\n\nexport type SymbolKindValue = typeof SymbolKind[keyof typeof SymbolKind];\n\nexport interface SymbolInfo {\n  name: string;\n  kind: SymbolKindValue;\n  line: number;      // 1-indexed\n  endLine: number;   // 1-indexed\n  children?: SymbolInfo[];\n}\n\n/** Node types that represent symbol declarations, per language family */\ninterface SymbolMapping {\n  nodeType: string;\n  kind: SymbolKindValue;\n  /** Field name to extract the symbol name from (default: \"name\") */\n  nameField?: string;\n  /** Whether to recurse into children for nested symbols */\n  recurse?: boolean;\n}\n\nconst TS_JS_SYMBOLS: SymbolMapping[] = [\n  { nodeType: \"function_declaration\", kind: SymbolKind.Function },\n  { nodeType: \"class_declaration\", kind: SymbolKind.Class, recurse: true },\n  { nodeType: \"interface_declaration\", kind: SymbolKind.Interface, recurse: true },\n  { nodeType: \"enum_declaration\", kind: SymbolKind.Enum, recurse: true },\n  { nodeType: \"type_alias_declaration\", kind: SymbolKind.Variable },\n  { nodeType: \"method_definition\", kind: SymbolKind.Method },\n  { nodeType: \"public_field_definition\", kind: SymbolKind.Field },\n  { nodeType: \"abstract_method_signature\", kind: SymbolKind.Method },\n  { nodeType: \"lexical_declaration\", kind: SymbolKind.Variable },\n  { nodeType: \"variable_declaration\", kind: SymbolKind.Variable },\n];\n\nconst PYTHON_SYMBOLS: SymbolMapping[] = [\n  { nodeType: \"function_definition\", kind: SymbolKind.Function },\n  { nodeType: \"class_definition\", kind: SymbolKind.Class, recurse: true },\n  { nodeType: \"decorated_definition\", kind: SymbolKind.Function },\n];\n\nconst RUST_SYMBOLS: SymbolMapping[] = [\n  { nodeType: \"function_item\", kind: SymbolKind.Function },\n  { nodeType: \"struct_item\", kind: SymbolKind.Struct },\n  { nodeType: \"enum_item\", kind: SymbolKind.Enum, recurse: true },\n  { nodeType: \"impl_item\", kind: SymbolKind.Class, recurse: true },\n  { nodeType: \"trait_item\", kind: SymbolKind.Interface, recurse: true },\n  { nodeType: \"mod_item\", kind: SymbolKind.Module, recurse: true },\n  { nodeType: \"type_item\", kind: SymbolKind.Variable },\n  { nodeType: \"const_item\", kind: SymbolKind.Constant },\n  { nodeType: \"static_item\", kind: SymbolKind.Constant },\n  { nodeType: \"macro_definition\", kind: SymbolKind.Function },\n];\n\nconst GO_SYMBOLS: SymbolMapping[] = [\n  { nodeType: \"function_declaration\", kind: SymbolKind.Function },\n  { nodeType: \"method_declaration\", kind: SymbolKind.Method },\n  { nodeType: \"type_declaration\", kind: SymbolKind.Class },\n  { nodeType: \"type_spec\", kind: SymbolKind.Class },\n  { nodeType: \"const_declaration\", kind: SymbolKind.Constant },\n  { nodeType: \"var_declaration\", kind: SymbolKind.Variable },\n];\n\nconst JAVA_SYMBOLS: SymbolMapping[] = [\n  { nodeType: \"class_declaration\", kind: SymbolKind.Class, recurse: true },\n  { nodeType: \"interface_declaration\", kind: SymbolKind.Interface, recurse: true },\n  { nodeType: \"enum_declaration\", kind: SymbolKind.Enum, recurse: true },\n  { nodeType: \"method_declaration\", kind: SymbolKind.Method },\n  { nodeType: \"constructor_declaration\", kind: SymbolKind.Constructor },\n  { nodeType: \"field_declaration\", kind: SymbolKind.Field },\n  { nodeType: \"annotation_type_declaration\", kind: SymbolKind.Interface },\n];\n\nconst C_CPP_SYMBOLS: SymbolMapping[] = [\n  { nodeType: \"function_definition\", kind: SymbolKind.Function },\n  { nodeType: \"declaration\", kind: SymbolKind.Variable },\n  { nodeType: \"struct_specifier\", kind: SymbolKind.Struct },\n  { nodeType: \"enum_specifier\", kind: SymbolKind.Enum },\n  { nodeType: \"class_specifier\", kind: SymbolKind.Class, recurse: true },\n  { nodeType: \"namespace_definition\", kind: SymbolKind.Namespace, recurse: true },\n];\n\nconst RUBY_SYMBOLS: SymbolMapping[] = [\n  { nodeType: \"method\", kind: SymbolKind.Method },\n  { nodeType: \"singleton_method\", kind: SymbolKind.Method },\n  { nodeType: \"class\", kind: SymbolKind.Class, recurse: true },\n  { nodeType: \"module\", kind: SymbolKind.Module, recurse: true },\n];\n\nconst LANGUAGE_SYMBOLS: Record<string, SymbolMapping[]> = {\n  typescript: TS_JS_SYMBOLS,\n  typescriptreact: TS_JS_SYMBOLS,\n  javascript: TS_JS_SYMBOLS,\n  javascriptreact: TS_JS_SYMBOLS,\n  python: PYTHON_SYMBOLS,\n  rust: RUST_SYMBOLS,\n  go: GO_SYMBOLS,\n  java: JAVA_SYMBOLS,\n  c: C_CPP_SYMBOLS,\n  cpp: C_CPP_SYMBOLS,\n  ruby: RUBY_SYMBOLS,\n};\n\n/**\n * Extract symbols from a parsed tree.\n */\nexport function extractSymbols(tree: Tree, languageId: string): SymbolInfo[] {\n  const mappings = LANGUAGE_SYMBOLS[languageId];\n  if (!mappings) return extractGenericSymbols(tree);\n  return extractFromNode(tree.rootNode, mappings, languageId);\n}\n\nfunction extractFromNode(node: Node, mappings: SymbolMapping[], languageId: string, deep = false): SymbolInfo[] {\n  const symbols: SymbolInfo[] = [];\n\n  for (const child of node.namedChildren) {\n    const mapping = mappings.find((m) => m.nodeType === child.type);\n    if (mapping) {\n      const name = extractName(child, mapping, languageId);\n      if (name) {\n        const sym: SymbolInfo = {\n          name,\n          kind: mapping.kind,\n          line: child.startPosition.row + 1,\n          endLine: child.endPosition.row + 1,\n        };\n        if (mapping.recurse) {\n          const children = extractFromNode(child, mappings, languageId, true);\n          if (children.length > 0) sym.children = children;\n        }\n        symbols.push(sym);\n      }\n    } else if (child.type === \"export_statement\" && (languageId.startsWith(\"typescript\") || languageId.startsWith(\"javascript\"))) {\n      // Unwrap export statements to find the actual declaration\n      const inner = extractFromNode(child, mappings, languageId, deep);\n      symbols.push(...inner);\n    } else if (deep && child.namedChildCount > 0) {\n      // Walk through container nodes (class_body, interface_body, etc.)\n      // to find nested declarations when recursing inside a parent\n      symbols.push(...extractFromNode(child, mappings, languageId, true));\n    }\n  }\n\n  return symbols;\n}\n\n/** Extract the name of a symbol from a node */\nfunction extractName(node: Node, mapping: SymbolMapping, languageId: string): string | null {\n  // Try the \"name\" field first (works for most declarations)\n  const nameNode = node.childForFieldName(mapping.nameField ?? \"name\");\n  if (nameNode) return nameNode.text;\n\n  // Language-specific fallbacks\n  switch (node.type) {\n    case \"lexical_declaration\":\n    case \"variable_declaration\": {\n      // const foo = ..., let bar = ...\n      const declarator = node.namedChildren.find(\n        (c) => c.type === \"variable_declarator\" || c.type === \"init_declarator\"\n      );\n      if (declarator) {\n        const n = declarator.childForFieldName(\"name\");\n        return n?.text ?? null;\n      }\n      return null;\n    }\n    case \"decorated_definition\": {\n      // Python: @decorator \\n def foo(): ...\n      const inner = node.namedChildren.find(\n        (c) => c.type === \"function_definition\" || c.type === \"class_definition\"\n      );\n      if (inner) {\n        const n = inner.childForFieldName(\"name\");\n        return n?.text ?? null;\n      }\n      return null;\n    }\n    case \"impl_item\": {\n      // Rust: impl Foo { ... } or impl Trait for Foo { ... }\n      const typeNode = node.childForFieldName(\"type\");\n      if (typeNode) return `impl ${typeNode.text}`;\n      return null;\n    }\n    case \"type_declaration\": {\n      // Go: type Foo struct { ... }\n      const spec = node.namedChildren.find((c) => c.type === \"type_spec\");\n      if (spec) {\n        const n = spec.childForFieldName(\"name\");\n        return n?.text ?? null;\n      }\n      return null;\n    }\n    case \"const_declaration\":\n    case \"var_declaration\": {\n      // Go: const/var declarations\n      const spec = node.namedChildren.find(\n        (c) => c.type === \"const_spec\" || c.type === \"var_spec\"\n      );\n      if (spec) {\n        const n = spec.childForFieldName(\"name\");\n        return n?.text ?? null;\n      }\n      return null;\n    }\n    case \"field_declaration\": {\n      // Java: field declarations\n      const declarator = node.namedChildren.find((c) => c.type === \"variable_declarator\");\n      if (declarator) {\n        const n = declarator.childForFieldName(\"name\");\n        return n?.text ?? null;\n      }\n      return null;\n    }\n    case \"declaration\": {\n      // C/C++: declarations\n      const declarator = node.namedChildren.find(\n        (c) => c.type === \"init_declarator\" || c.type === \"function_declarator\"\n      );\n      if (declarator) {\n        const n = declarator.childForFieldName(\"declarator\") ?? declarator.childForFieldName(\"name\");\n        return n?.text ?? null;\n      }\n      return null;\n    }\n    default:\n      break;\n  }\n\n  // Last resort: first named child's text (truncated)\n  const first = node.firstNamedChild;\n  if (first && first.text.length < 60) return first.text;\n  return null;\n}\n\n/** Generic fallback for languages without specific mappings */\nfunction extractGenericSymbols(tree: Tree): SymbolInfo[] {\n  const symbols: SymbolInfo[] = [];\n  const root = tree.rootNode;\n\n  for (const child of root.namedChildren) {\n    // Look for common declaration patterns\n    if (child.type.includes(\"function\") || child.type.includes(\"method\")) {\n      const name = child.childForFieldName(\"name\")?.text;\n      if (name) {\n        symbols.push({\n          name,\n          kind: SymbolKind.Function,\n          line: child.startPosition.row + 1,\n          endLine: child.endPosition.row + 1,\n        });\n      }\n    } else if (child.type.includes(\"class\") || child.type.includes(\"struct\")) {\n      const name = child.childForFieldName(\"name\")?.text;\n      if (name) {\n        symbols.push({\n          name,\n          kind: SymbolKind.Class,\n          line: child.startPosition.row + 1,\n          endLine: child.endPosition.row + 1,\n        });\n      }\n    }\n  }\n\n  return symbols;\n}\n\n/**\n * Get the named node at a specific position in the tree.\n * Returns the smallest named node that contains the position.\n */\nexport function getNodeAtPosition(tree: Tree, line: number, character: number): Node | null {\n  // tree-sitter uses 0-indexed positions\n  const point = { row: line, column: character };\n  return tree.rootNode.namedDescendantForPosition(point);\n}\n\n/**\n * Find definition(s) of a symbol name within a tree.\n * Searches for declaration nodes whose name matches.\n */\nexport function findDefinition(tree: Tree, symbolName: string, languageId: string): SymbolInfo[] {\n  const allSymbols = extractSymbols(tree, languageId);\n  return findSymbolByName(allSymbols, symbolName);\n}\n\nfunction findSymbolByName(symbols: SymbolInfo[], name: string): SymbolInfo[] {\n  const results: SymbolInfo[] = [];\n  for (const sym of symbols) {\n    if (sym.name === name) results.push(sym);\n    if (sym.children) results.push(...findSymbolByName(sym.children, name));\n  }\n  return results;\n}\n\n/**\n * Get syntax errors from a parsed tree.\n * Returns ERROR and MISSING nodes as diagnostic-like objects.\n */\nexport function getSyntaxErrors(tree: Tree): Array<{\n  line: number;\n  character: number;\n  endLine: number;\n  endCharacter: number;\n  message: string;\n}> {\n  const errors: Array<{\n    line: number;\n    character: number;\n    endLine: number;\n    endCharacter: number;\n    message: string;\n  }> = [];\n\n  function walk(node: Node): void {\n    if (node.isError) {\n      errors.push({\n        line: node.startPosition.row,\n        character: node.startPosition.column,\n        endLine: node.endPosition.row,\n        endCharacter: node.endPosition.column,\n        message: `Syntax error: unexpected \"${node.text.slice(0, 50)}${node.text.length > 50 ? \"...\" : \"\"}\"`,\n      });\n    } else if (node.isMissing) {\n      errors.push({\n        line: node.startPosition.row,\n        character: node.startPosition.column,\n        endLine: node.endPosition.row,\n        endCharacter: node.endPosition.column,\n        message: `Missing ${node.type}`,\n      });\n    } else if (node.hasError) {\n      // Recurse into children only if this node contains errors\n      for (const child of node.children) {\n        walk(child);\n      }\n    }\n  }\n\n  walk(tree.rootNode);\n  return errors;\n}\n\n/**\n * Get the signature text for a node (for hover info).\n * Extracts the first line of the declaration.\n */\nexport function getSignatureText(node: Node): string {\n  const text = node.text;\n  const firstLine = text.split(\"\\n\")[0];\n  // Trim trailing { or : for cleaner display\n  return firstLine.replace(/\\s*[{:]\\s*$/, \"\").trim();\n}\n\n/**\n * Get the enclosing declaration node for a position.\n * Walks up from the node at position to find the nearest declaration.\n */\nexport function getEnclosingDeclaration(tree: Tree, line: number, character: number): Node | null {\n  const point = { row: line, column: character };\n  let node: Node | null = tree.rootNode.namedDescendantForPosition(point);\n\n  const declarationTypes = new Set([\n    \"function_declaration\", \"function_definition\", \"function_item\",\n    \"method_declaration\", \"method_definition\",\n    \"class_declaration\", \"class_definition\", \"class_specifier\",\n    \"interface_declaration\", \"enum_declaration\", \"enum_item\",\n    \"struct_item\", \"impl_item\", \"trait_item\", \"mod_item\",\n    \"type_alias_declaration\", \"type_declaration\",\n    \"variable_declarator\", \"lexical_declaration\",\n    \"const_item\", \"static_item\",\n    \"decorated_definition\",\n  ]);\n\n  while (node) {\n    if (declarationTypes.has(node.type)) return node;\n    node = node.parent;\n  }\n  return null;\n}\n"]}