ragcode-context-engine 0.1.0

package/dist/src/graph/sqlite-statements.d.ts

@@ -0,0 +1,36 @@
+import type { DatabaseSync } from "node:sqlite";
+/**
+ * Prepared statement pool for SQLiteGraphStore.
+ * All SQL lives here — single source of truth for schema access patterns.
+ */
+export declare class SqliteStatements {
+    readonly upsertProject: any;
+    readonly selectProjectByRoot: any;
+    readonly listProjects: any;
+    readonly selectFiles: any;
+    readonly selectFile: any;
+    readonly insertFile: any;
+    readonly deleteFilesNotIn: any;
+    readonly selectSymbols: any;
+    readonly selectSymbolsByFile: any;
+    readonly selectSymbolByNameLike: any;
+    readonly insertSymbol: any;
+    readonly deleteSymbols: any;
+    readonly selectEdges: any;
+    readonly selectEdgesByKind: any;
+    readonly insertEdge: any;
+    readonly deleteEdges: any;
+    readonly selectChunks: any;
+    readonly selectChunksByFile: any;
+    readonly insertChunk: any;
+    readonly deleteChunks: any;
+    readonly searchFts: any;
+    readonly insertFts: any;
+    readonly deleteFts: any;
+    readonly selectSkippedFiles: any;
+    readonly insertSkippedFile: any;
+    readonly deleteSkippedFiles: any;
+    readonly deleteProjectData: any;
+    readonly selectFilePaths: any;
+    constructor(db: DatabaseSync);
+}

package/dist/src/graph/sqlite-statements.js

@@ -0,0 +1,105 @@
+/**
+ * Prepared statement pool for SQLiteGraphStore.
+ * All SQL lives here — single source of truth for schema access patterns.
+ */
+export class SqliteStatements {
+    // Projects
+    upsertProject;
+    selectProjectByRoot;
+    listProjects;
+    // Files
+    selectFiles;
+    selectFile;
+    insertFile;
+    deleteFilesNotIn;
+    // Symbols
+    selectSymbols;
+    selectSymbolsByFile;
+    selectSymbolByNameLike;
+    insertSymbol;
+    deleteSymbols;
+    // Edges
+    selectEdges;
+    selectEdgesByKind;
+    insertEdge;
+    deleteEdges;
+    // Chunks
+    selectChunks;
+    selectChunksByFile;
+    insertChunk;
+    deleteChunks;
+    // FTS
+    searchFts;
+    insertFts;
+    deleteFts;
+    // Skipped files
+    selectSkippedFiles;
+    insertSkippedFile;
+    deleteSkippedFiles;
+    // Cleanup
+    deleteProjectData;
+    selectFilePaths;
+    constructor(db) {
+        // Projects
+        this.upsertProject = db.prepare(`INSERT INTO projects(
+        project_id,
+        repo_root,
+        canonical_root,
+        display_name,
+        git_remote,
+        git_head,
+        created_at_ms,
+        last_indexed_at_ms,
+        indexed_at_ms,
+        index_generation
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(project_id) DO UPDATE SET
+        repo_root = excluded.repo_root,
+        canonical_root = excluded.canonical_root,
+        display_name = excluded.display_name,
+        git_remote = excluded.git_remote,
+        git_head = excluded.git_head,
+        created_at_ms = COALESCE(projects.created_at_ms, excluded.created_at_ms),
+        last_indexed_at_ms = excluded.last_indexed_at_ms,
+        indexed_at_ms = excluded.indexed_at_ms,
+        index_generation = excluded.index_generation`);
+        this.selectProjectByRoot = db.prepare("SELECT * FROM projects WHERE lower(repo_root) = lower(?) OR lower(COALESCE(canonical_root, repo_root)) = lower(?) ORDER BY indexed_at_ms DESC LIMIT 1");
+        this.listProjects = db.prepare("SELECT * FROM projects ORDER BY COALESCE(canonical_root, repo_root), project_id");
+        // Files
+        this.selectFiles = db.prepare("SELECT * FROM files WHERE project_id = ? ORDER BY path");
+        this.selectFile = db.prepare("SELECT * FROM files WHERE project_id = ? AND path = ?");
+        this.insertFile = db.prepare("INSERT INTO files(project_id, path, absolute_path, language, size_bytes, content_hash, modified_at_ms, indexed_at_ms, status, generation) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
+        this.selectFilePaths = db.prepare("SELECT path FROM files WHERE project_id = ?");
+        // Symbols
+        this.selectSymbols = db.prepare("SELECT * FROM symbols WHERE project_id = ? ORDER BY file_path, start_line");
+        this.selectSymbolsByFile = db.prepare("SELECT * FROM symbols WHERE project_id = ? AND file_path = ? ORDER BY start_line");
+        this.selectSymbolByNameLike = db.prepare("SELECT * FROM symbols WHERE project_id = ? AND lower(name) LIKE ? ESCAPE '\\' ORDER BY name");
+        this.insertSymbol = db.prepare("INSERT INTO symbols(project_id, id, file_path, name, kind, language, start_line, end_line, signature, exported, generation) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
+        this.deleteSymbols = db.prepare("DELETE FROM symbols WHERE project_id = ? AND file_path = ?");
+        // Edges
+        this.selectEdges = db.prepare("SELECT * FROM edges WHERE project_id = ? ORDER BY id");
+        this.selectEdgesByKind = db.prepare("SELECT * FROM edges WHERE project_id = ? AND kind = ? ORDER BY id");
+        this.insertEdge = db.prepare("INSERT INTO edges(project_id, source_id, target_id, kind, metadata_json, file_path, generation) VALUES (?, ?, ?, ?, ?, ?, ?)");
+        this.deleteEdges = db.prepare("DELETE FROM edges WHERE project_id = ? AND file_path = ?");
+        // Chunks
+        this.selectChunks = db.prepare("SELECT * FROM chunks WHERE project_id = ? ORDER BY file_path, start_line");
+        this.selectChunksByFile = db.prepare("SELECT * FROM chunks WHERE project_id = ? AND file_path = ? ORDER BY start_line");
+        this.insertChunk = db.prepare("INSERT INTO chunks(project_id, id, repo_root, file_path, language, kind, symbol_name, start_line, end_line, content, content_hash, generation) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
+        this.deleteChunks = db.prepare("DELETE FROM chunks WHERE project_id = ? AND file_path = ?");
+        // FTS
+        this.searchFts = db.prepare(`SELECT c.*, bm25(chunks_fts) AS rank
+       FROM chunks_fts
+       JOIN chunks c ON c.project_id = chunks_fts.project_id AND c.id = chunks_fts.id
+       WHERE chunks_fts.project_id = ? AND chunks_fts MATCH ?
+       ORDER BY rank, c.file_path, c.start_line
+       LIMIT ?`);
+        this.insertFts = db.prepare("INSERT INTO chunks_fts(project_id, id, file_path, symbol_name, content) VALUES (?, ?, ?, ?, ?)");
+        this.deleteFts = db.prepare("DELETE FROM chunks_fts WHERE project_id = ? AND file_path = ?");
+        // Skipped files
+        this.selectSkippedFiles = db.prepare("SELECT file_path, reason FROM skipped_files WHERE project_id = ? ORDER BY file_path");
+        this.insertSkippedFile = db.prepare("INSERT INTO skipped_files(project_id, file_path, reason) VALUES (?, ?, ?)");
+        this.deleteSkippedFiles = db.prepare("DELETE FROM skipped_files WHERE project_id = ?");
+        // Cleanup (used for table iteration in deleteProjectRows)
+        this.deleteProjectData = (table) => db.prepare(`DELETE FROM ${table} WHERE project_id = ?`);
+    }
+}

package/dist/src/graph/target-matcher.d.ts

@@ -0,0 +1,13 @@
+import type { GraphEdge, SymbolNode } from "../core/types.js";
+export interface ImpactTargetSpec {
+    raw: string;
+    normalized: string;
+    lowered: string;
+    filePath?: string;
+    symbolName?: string;
+    qualified: boolean;
+}
+export declare function parseImpactTarget(target: string): ImpactTargetSpec;
+export declare function matchesImpactTarget(symbol: SymbolNode, target: ImpactTargetSpec): boolean;
+export declare function isIncomingImpactEdge(edge: GraphEdge, matchedIds: Set<string>, target: ImpactTargetSpec): boolean;
+export declare function isOutgoingImpactEdge(edge: GraphEdge, matchedIds: Set<string>, target: ImpactTargetSpec): boolean;

package/dist/src/graph/target-matcher.js

@@ -0,0 +1,64 @@
+import { normalizeUserPath } from "../utils/path.js";
+export function parseImpactTarget(target) {
+    const normalized = normalizeUserPath(target.trim());
+    const qualified = parseQualifiedTarget(normalized);
+    if (qualified) {
+        return {
+            raw: target,
+            normalized,
+            lowered: normalized.toLowerCase(),
+            filePath: qualified.filePath,
+            symbolName: qualified.symbolName,
+            qualified: true
+        };
+    }
+    return {
+        raw: target,
+        normalized,
+        lowered: target.toLowerCase(),
+        qualified: false
+    };
+}
+export function matchesImpactTarget(symbol, target) {
+    if (target.qualified) {
+        return Boolean(target.filePath
+            && target.symbolName
+            && filePathMatches(symbol.filePath, target.filePath)
+            && symbol.name === target.symbolName);
+    }
+    return symbol.name.toLowerCase().includes(target.lowered)
+        || symbol.filePath === target.normalized
+        || symbol.filePath.includes(target.normalized);
+}
+export function isIncomingImpactEdge(edge, matchedIds, target) {
+    if (matchedIds.has(edge.targetId))
+        return true;
+    if (target.qualified)
+        return false;
+    return String(edge.metadata?.targetName ?? "").toLowerCase().includes(target.lowered);
+}
+export function isOutgoingImpactEdge(edge, matchedIds, target) {
+    if (matchedIds.has(edge.sourceId))
+        return true;
+    const sourceFile = typeof edge.metadata?.sourceFile === "string" ? edge.metadata.sourceFile : undefined;
+    if (!sourceFile)
+        return false;
+    const fileTarget = target.filePath ?? target.normalized;
+    return target.symbolName ? false : filePathMatches(sourceFile, fileTarget);
+}
+function parseQualifiedTarget(target) {
+    const separatorIndex = Math.max(target.lastIndexOf(":"), target.lastIndexOf("#"));
+    if (separatorIndex <= 0 || separatorIndex === target.length - 1)
+        return undefined;
+    const filePath = target.slice(0, separatorIndex);
+    const symbolName = target.slice(separatorIndex + 1);
+    if (!looksLikePath(filePath) || !symbolName)
+        return undefined;
+    return { filePath, symbolName };
+}
+function looksLikePath(value) {
+    return value.includes("/") || /\.[cm]?[jt]sx?$/.test(value) || /\.[a-z0-9]+$/i.test(value);
+}
+function filePathMatches(actual, expected) {
+    return actual === expected || actual.endsWith(`/${expected}`);
+}

package/dist/src/index.d.ts

@@ -0,0 +1,32 @@
+export * from "./core/contracts.js";
+export * from "./core/engine.js";
+export * from "./core/types.js";
+export * from "./config/graph-runtime.js";
+export * from "./config/semantic-runtime.js";
+export * from "./config/runtime-config.js";
+export * from "./config/dotenv.js";
+export * from "./graph/in-memory-graph-store.js";
+export * from "./graph/sqlite-graph-store.js";
+export * from "./project/project-identity.js";
+export * from "./project/project-registry.js";
+export * from "./project/workspace-resolver.js";
+export * from "./semantic/deterministic-embedding.js";
+export * from "./semantic/in-memory-semantic-store.js";
+export * from "./semantic/lance-semantic-store.js";
+export * from "./semantic/openai-compatible-embedding.js";
+export * from "./watch/file-event-coalescer.js";
+export * from "./watch/event-journal.js";
+export * from "./watch/index-scheduler.js";
+export * from "./watch/watch-daemon.js";
+export * from "./indexing/ast-analyzer.js";
+export * from "./subgraph/subgraph-builder.js";
+export * from "./subgraph/impact-explainer.js";
+export * from "./subgraph/node-expander.js";
+export * from "./subgraph/output-preset.js";
+export * from "./reuse/reuse-detector.js";
+export * from "./retrieval/hybrid-retriever.js";
+export * from "./retrieval/path-classification.js";
+export * from "./diagnostics/doctor.js";
+export * from "./diagnostics/embedding-test.js";
+export * from "./mcp/tools.js";
+export * from "./mcp/server.js";

package/dist/src/index.js

@@ -0,0 +1,32 @@
+export * from "./core/contracts.js";
+export * from "./core/engine.js";
+export * from "./core/types.js";
+export * from "./config/graph-runtime.js";
+export * from "./config/semantic-runtime.js";
+export * from "./config/runtime-config.js";
+export * from "./config/dotenv.js";
+export * from "./graph/in-memory-graph-store.js";
+export * from "./graph/sqlite-graph-store.js";
+export * from "./project/project-identity.js";
+export * from "./project/project-registry.js";
+export * from "./project/workspace-resolver.js";
+export * from "./semantic/deterministic-embedding.js";
+export * from "./semantic/in-memory-semantic-store.js";
+export * from "./semantic/lance-semantic-store.js";
+export * from "./semantic/openai-compatible-embedding.js";
+export * from "./watch/file-event-coalescer.js";
+export * from "./watch/event-journal.js";
+export * from "./watch/index-scheduler.js";
+export * from "./watch/watch-daemon.js";
+export * from "./indexing/ast-analyzer.js";
+export * from "./subgraph/subgraph-builder.js";
+export * from "./subgraph/impact-explainer.js";
+export * from "./subgraph/node-expander.js";
+export * from "./subgraph/output-preset.js";
+export * from "./reuse/reuse-detector.js";
+export * from "./retrieval/hybrid-retriever.js";
+export * from "./retrieval/path-classification.js";
+export * from "./diagnostics/doctor.js";
+export * from "./diagnostics/embedding-test.js";
+export * from "./mcp/tools.js";
+export * from "./mcp/server.js";

package/dist/src/indexing/analyzers/fallback-analyzer.d.ts

@@ -0,0 +1,6 @@
+import type { CodeFile, GraphEdge, SymbolNode } from "../../core/types.js";
+import type { AnalyzeFileInput, FileAnalysis, LanguageAnalyzer } from "./types.js";
+export declare const fallbackAnalyzer: LanguageAnalyzer;
+export declare function fallbackFileAnalysis(repoRoot: string, file: CodeFile, content: string, existingFileSymbol?: SymbolNode, existingEdges?: GraphEdge[]): FileAnalysis;
+export declare function createFileSymbol(repoRoot: string, file: CodeFile, lineCount: number): SymbolNode;
+export declare function analyzeFallbackFile(input: AnalyzeFileInput): FileAnalysis;

package/dist/src/indexing/analyzers/fallback-analyzer.js

@@ -0,0 +1,45 @@
+import { sha256, stableId } from "../../utils/hash.js";
+export const fallbackAnalyzer = {
+    language: "unknown",
+    capabilities: [],
+    analyzeFile: ({ repoRoot, file, content }) => fallbackFileAnalysis(repoRoot, file, content)
+};
+export function fallbackFileAnalysis(repoRoot, file, content, existingFileSymbol, existingEdges = []) {
+    const lines = content.split(/\r?\n/);
+    const fileSymbol = existingFileSymbol ?? createFileSymbol(repoRoot, file, lines.length);
+    const chunks = [];
+    for (let start = 0; start < lines.length; start += 80) {
+        const end = Math.min(lines.length, start + 80);
+        const chunkContent = lines.slice(start, end).join("\n");
+        if (!chunkContent.trim())
+            continue;
+        chunks.push({
+            id: stableId([repoRoot, file.path, start + 1, end, sha256(chunkContent)]),
+            projectId: file.projectId,
+            repoRoot,
+            filePath: file.path,
+            language: file.language,
+            kind: "block",
+            startLine: start + 1,
+            endLine: end,
+            content: chunkContent,
+            contentHash: sha256(chunkContent)
+        });
+    }
+    return { chunks, symbols: [fileSymbol], edges: existingEdges };
+}
+export function createFileSymbol(repoRoot, file, lineCount) {
+    return {
+        id: stableId([repoRoot, file.path, "file"]),
+        projectId: file.projectId,
+        filePath: file.path,
+        name: file.path,
+        kind: "file",
+        language: file.language,
+        startLine: 1,
+        endLine: Math.max(1, lineCount)
+    };
+}
+export function analyzeFallbackFile(input) {
+    return fallbackFileAnalysis(input.repoRoot, input.file, input.content);
+}

package/dist/src/indexing/analyzers/go-treesitter-analyzer.d.ts

@@ -0,0 +1,2 @@
+import type { LanguageAnalyzer } from "./types.js";
+export declare const goTreeSitterAnalyzer: LanguageAnalyzer;

package/dist/src/indexing/analyzers/go-treesitter-analyzer.js

@@ -0,0 +1,87 @@
+import Parser from "tree-sitter";
+// @ts-ignore - tree-sitter-go doesn't have TypeScript definitions
+import Go from "tree-sitter-go";
+import { analyzeWithTreeSitter } from "./tree-sitter-base.js";
+let parser = null;
+function getParser() {
+    if (!parser) {
+        parser = new Parser();
+        parser.setLanguage(Go);
+    }
+    return parser;
+}
+const goConfig = {
+    symbolPatterns: [
+        {
+            type: "function_declaration",
+            kind: "function",
+            nameField: "name",
+            exportModifierCheck: (node) => {
+                const name = node.childForFieldName("name")?.text;
+                return name ? /^[A-Z]/.test(name) : false;
+            }
+        },
+        {
+            type: "method_declaration",
+            kind: "method",
+            nameField: "name",
+            exportModifierCheck: (node) => {
+                const name = node.childForFieldName("name")?.text;
+                return name ? /^[A-Z]/.test(name) : false;
+            }
+        },
+        {
+            type: "type_declaration",
+            kind: "type",
+            nameExtractor: typeDeclarationName,
+            exportModifierCheck: (node) => {
+                const name = typeDeclarationName(node);
+                return name ? /^[A-Z]/.test(name) : false;
+            }
+        }
+    ],
+    importPatterns: [
+        {
+            type: "import_spec",
+            sourceField: "path",
+            bindingsExtractor: (node) => {
+                const pathNode = node.childForFieldName("path");
+                if (!pathNode)
+                    return [];
+                const path = pathNode.text.replace(/"/g, "");
+                const nameNode = node.childForFieldName("name");
+                const name = nameNode?.text ?? path.split("/").pop() ?? path;
+                return [{ imported: path, local: name }];
+            }
+        }
+    ],
+    callPatterns: [
+        {
+            type: "call_expression",
+            nameExtractor: (node) => {
+                const functionNode = node.childForFieldName("function");
+                if (!functionNode)
+                    return undefined;
+                if (functionNode.type === "identifier") {
+                    return functionNode.text;
+                }
+                else if (functionNode.type === "selector_expression") {
+                    const fieldNode = functionNode.childForFieldName("field");
+                    return fieldNode?.text;
+                }
+                return undefined;
+            }
+        }
+    ]
+};
+export const goTreeSitterAnalyzer = {
+    language: "go",
+    capabilities: ["symbols", "imports", "exports", "calls", "tests"],
+    analyzeFile: ({ repoRoot, file, content }) => {
+        return analyzeWithTreeSitter(getParser(), goConfig, repoRoot, file, content);
+    }
+};
+function typeDeclarationName(node) {
+    const specNode = node.children.find((child) => child.type === "type_spec");
+    return specNode?.childForFieldName("name")?.text;
+}

package/dist/src/indexing/analyzers/java-treesitter-analyzer.d.ts

@@ -0,0 +1,2 @@
+import type { LanguageAnalyzer } from "./types.js";
+export declare const javaTreeSitterAnalyzer: LanguageAnalyzer;

package/dist/src/indexing/analyzers/java-treesitter-analyzer.js

@@ -0,0 +1,88 @@
+import Parser from "tree-sitter";
+// @ts-ignore - tree-sitter-java doesn't have TypeScript definitions
+import Java from "tree-sitter-java";
+import { analyzeWithTreeSitter } from "./tree-sitter-base.js";
+let parser = null;
+function getParser() {
+    if (!parser) {
+        parser = new Parser();
+        parser.setLanguage(Java);
+    }
+    return parser;
+}
+const javaConfig = {
+    symbolPatterns: [
+        {
+            type: "class_declaration",
+            kind: "class",
+            nameField: "name",
+            exportModifierCheck: (node) => {
+                return node.children.some((child) => child.type === "modifiers" && child.text.includes("public"));
+            }
+        },
+        {
+            type: "interface_declaration",
+            kind: "type",
+            nameField: "name",
+            exportModifierCheck: (node) => {
+                return node.children.some((child) => child.type === "modifiers" && child.text.includes("public"));
+            }
+        },
+        {
+            type: "enum_declaration",
+            kind: "type",
+            nameField: "name",
+            exportModifierCheck: (node) => {
+                return node.children.some((child) => child.type === "modifiers" && child.text.includes("public"));
+            }
+        },
+        {
+            type: "method_declaration",
+            kind: "method",
+            nameField: "name",
+            exportModifierCheck: (node) => {
+                return node.children.some((child) => child.type === "modifiers" && child.text.includes("public"));
+            }
+        },
+        {
+            type: "constructor_declaration",
+            kind: "method",
+            nameField: "name",
+            exportModifierCheck: (node) => {
+                return node.children.some((child) => child.type === "modifiers" && child.text.includes("public"));
+            }
+        }
+    ],
+    importPatterns: [
+        {
+            type: "import_declaration",
+            sourceExtractor: javaImportName,
+            bindingsExtractor: (node) => {
+                const fullPath = javaImportName(node);
+                if (!fullPath)
+                    return [];
+                const className = fullPath.split(".").pop() ?? fullPath;
+                return [{ imported: fullPath, local: className }];
+            }
+        }
+    ],
+    callPatterns: [
+        {
+            type: "method_invocation",
+            nameExtractor: (node) => {
+                const nameNode = node.childForFieldName("name");
+                return nameNode?.text;
+            }
+        }
+    ]
+};
+export const javaTreeSitterAnalyzer = {
+    language: "java",
+    capabilities: ["symbols", "imports", "exports", "calls"],
+    analyzeFile: ({ repoRoot, file, content }) => {
+        return analyzeWithTreeSitter(getParser(), javaConfig, repoRoot, file, content);
+    }
+};
+function javaImportName(node) {
+    return node.children.find((child) => child.type === "scoped_identifier" || child.type === "identifier")?.text;
+}

package/dist/src/indexing/analyzers/python-treesitter-analyzer.d.ts

@@ -0,0 +1,2 @@
+import type { LanguageAnalyzer } from "./types.js";
+export declare const pythonTreeSitterAnalyzer: LanguageAnalyzer;

package/dist/src/indexing/analyzers/python-treesitter-analyzer.js

@@ -0,0 +1,96 @@
+import Parser from "tree-sitter";
+// @ts-ignore - tree-sitter-python doesn't have TypeScript definitions
+import Python from "tree-sitter-python";
+import { analyzeWithTreeSitter } from "./tree-sitter-base.js";
+let parser = null;
+function getParser() {
+    if (!parser) {
+        parser = new Parser();
+        parser.setLanguage(Python);
+    }
+    return parser;
+}
+const pythonConfig = {
+    symbolPatterns: [
+        {
+            type: "function_definition",
+            kind: "function",
+            nameField: "name",
+            exportModifierCheck: (node) => {
+                const name = node.childForFieldName("name")?.text;
+                return name ? !name.startsWith("_") : false;
+            }
+        },
+        {
+            type: "class_definition",
+            kind: "class",
+            nameField: "name",
+            exportModifierCheck: (node) => {
+                const name = node.childForFieldName("name")?.text;
+                return name ? !name.startsWith("_") : false;
+            }
+        }
+    ],
+    importPatterns: [
+        {
+            type: "import_statement",
+            sourceField: "name",
+            bindingsExtractor: (node) => {
+                const name = node.childForFieldName("name");
+                if (!name)
+                    return [];
+                const moduleName = name.text;
+                return [{ imported: moduleName, local: moduleName }];
+            }
+        },
+        {
+            type: "import_from_statement",
+            sourceField: "module_name",
+            bindingsExtractor: (node) => {
+                const bindings = [];
+                for (const child of node.children) {
+                    if (child.type === "dotted_name" || child.type === "identifier") {
+                        const name = child.text;
+                        bindings.push({ imported: name, local: name });
+                    }
+                    else if (child.type === "aliased_import") {
+                        const nameNode = child.childForFieldName("name");
+                        const aliasNode = child.childForFieldName("alias");
+                        if (nameNode) {
+                            bindings.push({
+                                imported: nameNode.text,
+                                local: aliasNode?.text ?? nameNode.text
+                            });
+                        }
+                    }
+                }
+                return bindings;
+            }
+        }
+    ],
+    callPatterns: [
+        {
+            type: "call",
+            nameExtractor: (node) => {
+                const functionNode = node.childForFieldName("function");
+                if (!functionNode)
+                    return undefined;
+                if (functionNode.type === "identifier") {
+                    return functionNode.text;
+                }
+                else if (functionNode.type === "attribute") {
+                    const attrNode = functionNode.childForFieldName("attribute");
+                    return attrNode?.text;
+                }
+                return undefined;
+            }
+        }
+    ]
+};
+export const pythonTreeSitterAnalyzer = {
+    language: "python",
+    capabilities: ["symbols", "imports", "exports", "calls"],
+    analyzeFile: ({ repoRoot, file, content }) => {
+        return analyzeWithTreeSitter(getParser(), pythonConfig, repoRoot, file, content);
+    }
+};

package/dist/src/indexing/analyzers/registry.d.ts

@@ -0,0 +1,5 @@
+import type { LanguageId } from "../../core/types.js";
+import type { AnalyzeFileInput, FileAnalysis, LanguageAnalyzer } from "./types.js";
+export declare function analyzerFor(language: LanguageId): LanguageAnalyzer;
+export declare function listAnalyzers(): LanguageAnalyzer[];
+export declare function analyzeFileWithRegistry(input: AnalyzeFileInput): FileAnalysis;

package/dist/src/indexing/analyzers/registry.js

@@ -0,0 +1,23 @@
+import { fallbackAnalyzer } from "./fallback-analyzer.js";
+import { javascriptAnalyzer, typescriptAnalyzer } from "./typescript-analyzer.js";
+import { pythonTreeSitterAnalyzer } from "./python-treesitter-analyzer.js";
+import { goTreeSitterAnalyzer } from "./go-treesitter-analyzer.js";
+import { rustTreeSitterAnalyzer } from "./rust-treesitter-analyzer.js";
+import { javaTreeSitterAnalyzer } from "./java-treesitter-analyzer.js";
+const analyzers = new Map([
+    ["typescript", typescriptAnalyzer],
+    ["javascript", javascriptAnalyzer],
+    ["python", pythonTreeSitterAnalyzer],
+    ["go", goTreeSitterAnalyzer],
+    ["rust", rustTreeSitterAnalyzer],
+    ["java", javaTreeSitterAnalyzer]
+]);
+export function analyzerFor(language) {
+    return analyzers.get(language) ?? fallbackAnalyzer;
+}
+export function listAnalyzers() {
+    return [...analyzers.values(), fallbackAnalyzer];
+}
+export function analyzeFileWithRegistry(input) {
+    return analyzerFor(input.file.language).analyzeFile(input);
+}

package/dist/src/indexing/analyzers/rust-treesitter-analyzer.d.ts

@@ -0,0 +1,2 @@
+import type { LanguageAnalyzer } from "./types.js";
+export declare const rustTreeSitterAnalyzer: LanguageAnalyzer;