ragcode-context-engine 0.1.0

package/dist/src/indexing/chunker.js

@@ -0,0 +1,157 @@
+import fs from "node:fs/promises";
+import { resolveCallDefinitionsWithTypeScript } from "../lsp/definition-resolver.js";
+import { buildFrameworkTopologyEdges } from "../topology/framework-topology.js";
+import { buildOrmTopologyEdges } from "../topology/orm-topology.js";
+import { buildRuntimeTopologyEdges } from "../topology/runtime-topology.js";
+import { resolveGraphEdges } from "../topology/symbol-resolver.js";
+import { buildTestTopologyEdges } from "../topology/test-topology.js";
+import { analyzeFile } from "./ast-analyzer.js";
+export async function chunkFiles(repoRoot, files, options = {}) {
+    const analyzed = await analyzeFiles(repoRoot, files);
+    return {
+        chunks: analyzed.chunks,
+        symbols: analyzed.symbols,
+        edges: resolveChunkEdges(repoRoot, files, analyzed.sources, analyzed.symbols, analyzed.edges)
+    };
+}
+export async function chunkFilesIncremental(repoRoot, files, filesToAnalyze, cached, options = {}) {
+    const analyzedPaths = new Set(filesToAnalyze.map((file) => file.path));
+    const currentPaths = new Set(files.map((file) => file.path));
+    const currentCached = filterCachedChunking(cached, currentPaths, analyzedPaths);
+    if (analyzedPaths.size === 0)
+        return currentCached;
+    const analyzed = await analyzeFiles(repoRoot, filesToAnalyze);
+    const chunks = [
+        ...currentCached.chunks,
+        ...analyzed.chunks
+    ];
+    const symbols = [
+        ...currentCached.symbols,
+        ...analyzed.symbols
+    ];
+    const refreshedEdges = resolveChunkEdges(repoRoot, files, analyzed.sources, symbols, analyzed.edges, routeCatalogEdges(cached.edges, currentPaths, analyzedPaths))
+        .filter((edge) => {
+        const sourceFile = edgeSourceFile(edge);
+        return sourceFile ? analyzedPaths.has(sourceFile) : false;
+    });
+    return { chunks, symbols, edges: dedupeEdges([...currentCached.edges, ...refreshedEdges]) };
+}
+async function analyzeFiles(repoRoot, files) {
+    const chunks = [];
+    const symbols = [];
+    const edges = [];
+    const sources = [];
+    for (const file of files) {
+        const content = await fs.readFile(file.absolutePath, "utf8");
+        if (file.language === "typescript" || file.language === "javascript") {
+            sources.push({ filePath: file.path, absolutePath: file.absolutePath, content });
+        }
+        const analysis = analyzeFile(repoRoot, file, content);
+        chunks.push(...analysis.chunks);
+        symbols.push(...analysis.symbols);
+        edges.push(...analysis.edges);
+    }
+    return { chunks, symbols, edges, sources };
+}
+function resolveChunkEdges(repoRoot, files, sources, symbols, edges, priorEdges = []) {
+    const importResolvedEdges = resolveGraphEdges(files, symbols, edges);
+    const lspResolvedEdges = resolveCallDefinitionsWithTypeScript(repoRoot, sources, symbols, importResolvedEdges);
+    const testEdges = buildTestTopologyEdges(symbols, lspResolvedEdges);
+    const frameworkEdges = buildFrameworkTopologyEdges(files, sources, symbols, lspResolvedEdges, priorEdges);
+    const runtimeEdges = buildRuntimeTopologyEdges(repoRoot, files, sources, symbols);
+    const ormEdges = buildOrmTopologyEdges(repoRoot, files, sources, symbols);
+    return [...lspResolvedEdges, ...testEdges, ...frameworkEdges, ...runtimeEdges, ...ormEdges];
+}
+function edgeSourceFile(edge) {
+    return typeof edge.metadata?.sourceFile === "string" ? edge.metadata.sourceFile : undefined;
+}
+function routeCatalogEdges(edges, currentPaths, analyzedPaths) {
+    return edges.filter((edge) => {
+        if (edge.kind !== "calls_api" && edge.kind !== "routes_to" && edge.kind !== "handles_webhook")
+            return false;
+        const routeFile = stringMetadata(edge, "routeFile") ?? stringMetadata(edge, "targetFile");
+        if (!routeFile || !currentPaths.has(routeFile))
+            return false;
+        return !analyzedPaths.has(routeFile);
+    });
+}
+function filterCachedChunking(cached, currentPaths, analyzedPaths) {
+    return {
+        chunks: cached.chunks.filter((chunk) => currentPaths.has(chunk.filePath) && !analyzedPaths.has(chunk.filePath)),
+        symbols: cached.symbols.filter((symbol) => currentPaths.has(symbol.filePath) && !analyzedPaths.has(symbol.filePath)),
+        edges: cached.edges.filter((edge) => {
+            const sourceFile = edgeSourceFile(edge);
+            return Boolean(sourceFile && currentPaths.has(sourceFile) && !analyzedPaths.has(sourceFile));
+        })
+    };
+}
+function dedupeEdges(edges) {
+    const seen = new Set();
+    const unique = [];
+    for (const edge of edges) {
+        const key = edgeDedupeKey(edge);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        unique.push(edge);
+    }
+    return unique;
+}
+function edgeDedupeKey(edge) {
+    const metadata = edge.metadata;
+    return [
+        edge.projectId,
+        edge.sourceId,
+        edge.targetId,
+        edge.kind,
+        scalarMetadata(metadata, "sourceFile"),
+        scalarMetadata(metadata, "targetFile"),
+        scalarMetadata(metadata, "targetName"),
+        scalarMetadata(metadata, "source"),
+        scalarMetadata(metadata, "name"),
+        scalarMetadata(metadata, "line"),
+        scalarMetadata(metadata, "position"),
+        scalarMetadata(metadata, "resolution"),
+        scalarMetadata(metadata, "importedName"),
+        scalarMetadata(metadata, "localName"),
+        scalarMetadata(metadata, "route"),
+        scalarMetadata(metadata, "requestPath"),
+        scalarMetadata(metadata, "framework"),
+        scalarMetadata(metadata, "resource"),
+        scalarMetadata(metadata, "operation"),
+        scalarMetadata(metadata, "event"),
+        scalarMetadata(metadata, "handler"),
+        scalarMetadata(metadata, "testFile"),
+        scalarMetadata(metadata, "colocated"),
+        bindingsMetadata(metadata)
+    ].map(escapeKeyPart).join("\u001f");
+}
+function scalarMetadata(metadata, key) {
+    const value = metadata?.[key];
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean")
+        return String(value);
+    return "";
+}
+function stringMetadata(edge, key) {
+    const value = edge.metadata?.[key];
+    return typeof value === "string" ? value : undefined;
+}
+function bindingsMetadata(metadata) {
+    const value = metadata?.bindings;
+    if (!Array.isArray(value))
+        return "";
+    return value
+        .map((entry) => {
+        if (!entry || typeof entry !== "object")
+            return "";
+        const binding = entry;
+        const imported = typeof binding.imported === "string" ? binding.imported : "";
+        const local = typeof binding.local === "string" ? binding.local : "";
+        return `${imported}->${local}`;
+    })
+        .sort()
+        .join("|");
+}
+function escapeKeyPart(value) {
+    return value.replaceAll("\\", "\\\\").replaceAll("\u001f", "\\u001f");
+}

package/dist/src/indexing/ignore-policy.d.ts

@@ -0,0 +1,6 @@
+export interface IgnoreDecision {
+    ignored: boolean;
+    reason?: string;
+}
+export declare function shouldIgnoreDirectory(name: string): IgnoreDecision;
+export declare function shouldIgnoreFile(relativePath: string, maxFileBytes: number, sizeBytes: number): IgnoreDecision;

package/dist/src/indexing/ignore-policy.js

@@ -0,0 +1,40 @@
+const DEFAULT_IGNORED_DIRS = new Set([
+    ".git",
+    ".ragcode",
+    ".codegraph",
+    ".understand-anything",
+    ".omx",
+    "node_modules",
+    "dist",
+    "build",
+    "coverage",
+    "target",
+    ".next",
+    ".turbo"
+]);
+const SENSITIVE_FILE_PATTERNS = [
+    /^\.env(\..*)?$/i,
+    /(^|[\\/])id_rsa$/i,
+    /(^|[\\/])id_dsa$/i,
+    /(^|[\\/])credentials?(\..*)?$/i,
+    /(^|[\\/])secrets?(\..*)?$/i,
+    /\.pem$/i,
+    /\.key$/i,
+    /\.p12$/i,
+    /\.pfx$/i
+];
+export function shouldIgnoreDirectory(name) {
+    if (DEFAULT_IGNORED_DIRS.has(name))
+        return { ignored: true, reason: `ignored directory: ${name}` };
+    return { ignored: false };
+}
+export function shouldIgnoreFile(relativePath, maxFileBytes, sizeBytes) {
+    const normalized = relativePath.replaceAll("\\", "/");
+    const basename = normalized.split("/").pop() ?? normalized;
+    if (SENSITIVE_FILE_PATTERNS.some((pattern) => pattern.test(basename) || pattern.test(normalized))) {
+        return { ignored: true, reason: "sensitive file policy" };
+    }
+    if (sizeBytes > maxFileBytes)
+        return { ignored: true, reason: `file exceeds ${maxFileBytes} bytes` };
+    return { ignored: false };
+}

package/dist/src/indexing/indexer.d.ts

@@ -0,0 +1,13 @@
+import type { GraphStore, Indexer, SemanticStore, EmbeddingProvider } from "../core/contracts.js";
+import type { IndexRefreshOptions, ProjectIdentity, RepoIndex } from "../core/types.js";
+export interface RepoIndexerOptions {
+    graphStore: GraphStore;
+    semanticStore: SemanticStore;
+    embeddingProvider: EmbeddingProvider;
+}
+export declare class RepoIndexer implements Indexer {
+    private readonly options;
+    constructor(options: RepoIndexerOptions);
+    indexRepo(repoRoot: string, projectId: string, project?: ProjectIdentity, options?: IndexRefreshOptions): Promise<RepoIndex>;
+    private updateSemanticIndex;
+}

package/dist/src/indexing/indexer.js

@@ -0,0 +1,189 @@
+import path from "node:path";
+import { resolveImportPath } from "../topology/import-resolver.js";
+import { chunkFiles, chunkFilesIncremental } from "./chunker.js";
+import { scanRepo } from "./scanner.js";
+export class RepoIndexer {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async indexRepo(repoRoot, projectId, project, options = {}) {
+        const absoluteRoot = path.resolve(repoRoot);
+        options.onProgress?.({ phase: "loading_existing_index", message: "Loading existing index" });
+        const existingFiles = await this.options.graphStore.getFiles(absoluteRoot).catch(() => []);
+        const fullReindex = existingFiles.length === 0;
+        const affectedPaths = fullReindex ? undefined : normalizedAffectedFiles(options.affectedFiles);
+        options.onProgress?.({ phase: "scanning", message: affectedPaths ? "Scanning affected files" : "Scanning repository" });
+        const scan = await scanRepo(absoluteRoot, projectId, affectedPaths ? { filePaths: [...affectedPaths] } : {});
+        const files = affectedPaths ? mergeAffectedScan(existingFiles, scan.files, affectedPaths) : scan.files;
+        const skippedFiles = affectedPaths
+            ? mergeSkippedFiles(await this.options.graphStore.getSkippedFiles(absoluteRoot).catch(() => []), scan.skippedFiles, affectedPaths)
+            : scan.skippedFiles;
+        const existingByPath = new Map(existingFiles.map((file) => [file.path, file]));
+        const currentPaths = new Set(files.map((file) => file.path));
+        const changedFiles = files.filter((file) => {
+            if (affectedPaths && !affectedPaths.has(file.path))
+                return false;
+            return existingByPath.get(file.path)?.contentHash !== file.contentHash;
+        });
+        const deletedFiles = existingFiles
+            .filter((file) => (!affectedPaths || affectedPaths.has(file.path)) && !currentPaths.has(file.path))
+            .map((file) => file.path)
+            .sort();
+        const currentGeneration = this.options.graphStore.getIndexGeneration
+            ? await this.options.graphStore.getIndexGeneration(absoluteRoot).catch(() => 0)
+            : 0;
+        const indexGeneration = currentGeneration + 1;
+        const changedFilePaths = changedFiles.map((file) => file.path);
+        // Incremental refresh loads the full prior graph into memory: chunkFilesIncremental needs the
+        // whole symbol/edge set to re-resolve cross-file references for the changed files. Peak memory
+        // therefore scales with total graph size, not the changed slice — an accepted trade-off for
+        // correctness; revisit with windowed loading if it becomes a ceiling (see todo.md D/L6).
+        const cached = fullReindex
+            ? undefined
+            : {
+                chunks: await this.options.graphStore.getChunks(absoluteRoot),
+                symbols: await this.options.graphStore.getSymbols(absoluteRoot),
+                edges: await this.options.graphStore.getEdges(absoluteRoot)
+            };
+        const refreshedFiles = cached
+            ? refreshedFilePaths(files, cached.edges, changedFilePaths, deletedFiles)
+            : changedFilePaths;
+        const filesToAnalyze = files.filter((file) => refreshedFiles.includes(file.path));
+        options.onProgress?.({
+            phase: "analyzing",
+            message: cached ? "Analyzing changed graph slice" : "Analyzing full repository",
+            scannedFiles: scan.files.length,
+            changedFiles: changedFilePaths.length,
+            deletedFiles: deletedFiles.length,
+            refreshedFiles: refreshedFiles.length
+        });
+        const { chunks, symbols, edges } = cached
+            ? await chunkFilesIncremental(absoluteRoot, files, filesToAnalyze, cached)
+            : await chunkFiles(absoluteRoot, files);
+        const indexedAtMs = Date.now();
+        const index = {
+            projectId,
+            project: project ? { ...project, lastIndexedAtMs: indexedAtMs } : undefined,
+            repoRoot: absoluteRoot,
+            indexedAtMs,
+            indexGeneration,
+            changedFiles: changedFilePaths,
+            deletedFiles,
+            affectedFiles: affectedPaths ? [...affectedPaths].sort() : undefined,
+            scannedFiles: scan.files.map((file) => file.path).sort(),
+            refreshedFiles,
+            fullReindex,
+            files,
+            chunks,
+            symbols,
+            edges,
+            skippedFiles
+        };
+        options.onProgress?.({
+            phase: "writing_graph",
+            message: "Writing graph index",
+            scannedFiles: index.scannedFiles?.length,
+            changedFiles: index.changedFiles.length,
+            deletedFiles: index.deletedFiles.length,
+            refreshedFiles: index.refreshedFiles?.length,
+            chunks: index.chunks.length,
+            symbols: index.symbols.length,
+            edges: index.edges.length
+        });
+        await this.options.graphStore.upsertIndex(index);
+        options.onProgress?.({
+            phase: "writing_semantic",
+            message: "Writing semantic index",
+            chunks: index.chunks.length,
+            symbols: index.symbols.length,
+            edges: index.edges.length
+        });
+        await this.updateSemanticIndex(absoluteRoot, projectId, index);
+        options.onProgress?.({
+            phase: "complete",
+            message: "Index complete",
+            scannedFiles: index.scannedFiles?.length,
+            changedFiles: index.changedFiles.length,
+            deletedFiles: index.deletedFiles.length,
+            refreshedFiles: index.refreshedFiles?.length,
+            chunks: index.chunks.length,
+            symbols: index.symbols.length,
+            edges: index.edges.length
+        });
+        return index;
+    }
+    async updateSemanticIndex(repoRoot, projectId, index) {
+        try {
+            const semanticNeedsRebuild = await this.options.semanticStore.needsRebuild?.(repoRoot, projectId) ?? false;
+            if (index.fullReindex || semanticNeedsRebuild || !this.options.semanticStore.deleteFile) {
+                await this.options.semanticStore.resetRepo(repoRoot);
+                await this.options.semanticStore.upsertChunks(index.chunks, this.options.embeddingProvider, index.indexGeneration);
+                return;
+            }
+            const changedOrDeleted = new Set([...index.changedFiles, ...index.deletedFiles]);
+            for (const filePath of changedOrDeleted) {
+                await this.options.semanticStore.deleteFile(repoRoot, projectId, filePath);
+            }
+            const changedChunks = index.chunks.filter((chunk) => changedOrDeleted.has(chunk.filePath) && !index.deletedFiles.includes(chunk.filePath));
+            await this.options.semanticStore.upsertChunks(changedChunks, this.options.embeddingProvider, index.indexGeneration);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`[ragcode] semantic index skipped: ${message}`);
+            // Semantic recall is optional cache acceleration. Graph rows remain the source of truth.
+        }
+    }
+}
+function normalizedAffectedFiles(filePaths) {
+    if (!filePaths?.length)
+        return undefined;
+    return new Set(filePaths.map((filePath) => filePath.replaceAll("\\", "/")).filter(Boolean));
+}
+function mergeAffectedScan(existingFiles, scannedFiles, affectedPaths) {
+    const merged = new Map();
+    for (const file of existingFiles) {
+        if (!affectedPaths.has(file.path))
+            merged.set(file.path, file);
+    }
+    for (const file of scannedFiles)
+        merged.set(file.path, file);
+    return [...merged.values()].sort((a, b) => a.path.localeCompare(b.path));
+}
+function mergeSkippedFiles(existingSkippedFiles, scannedSkippedFiles, affectedPaths) {
+    const merged = new Map();
+    for (const skipped of existingSkippedFiles) {
+        if (!affectedPaths.has(skipped.filePath))
+            merged.set(skipped.filePath, skipped);
+    }
+    for (const skipped of scannedSkippedFiles)
+        merged.set(skipped.filePath, skipped);
+    return [...merged.values()].sort((a, b) => a.filePath.localeCompare(b.filePath));
+}
+function refreshedFilePaths(files, previousEdges, changedFiles, deletedFiles) {
+    const currentPaths = new Set(files.map((file) => file.path));
+    const touchedPaths = new Set([...changedFiles, ...deletedFiles]);
+    const refreshed = new Set(changedFiles.filter((filePath) => currentPaths.has(filePath)));
+    for (const edge of previousEdges) {
+        const sourceFile = stringMetadata(edge, "sourceFile");
+        if (!sourceFile || !currentPaths.has(sourceFile))
+            continue;
+        // Any edge whose recorded target file was touched invalidates its source. This is uniform
+        // across imports, resolved calls, and framework edges (calls_api/routes_to/uses_middleware):
+        // they all carry targetFile metadata, so this single pass covers them — no per-kind reverse pass.
+        const previousTargetFile = stringMetadata(edge, "targetFile");
+        if (previousTargetFile && touchedPaths.has(previousTargetFile)) {
+            refreshed.add(sourceFile);
+            continue;
+        }
+        const importSource = edge.kind === "imports" ? stringMetadata(edge, "source") : undefined;
+        const nextTargetFile = importSource ? resolveImportPath(sourceFile, importSource, files) : undefined;
+        if (nextTargetFile && touchedPaths.has(nextTargetFile))
+            refreshed.add(sourceFile);
+    }
+    return [...refreshed].sort();
+}
+function stringMetadata(edge, key) {
+    const value = edge.metadata?.[key];
+    return typeof value === "string" ? value : undefined;
+}

package/dist/src/indexing/language.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageId } from "../core/types.js";
+export declare function detectLanguage(filePath: string): LanguageId;
+export declare function isIndexableLanguage(language: LanguageId): boolean;

package/dist/src/indexing/language.js

@@ -0,0 +1,24 @@
+const EXTENSION_LANGUAGE = {
+    ".ts": "typescript",
+    ".tsx": "typescript",
+    ".js": "javascript",
+    ".jsx": "javascript",
+    ".mjs": "javascript",
+    ".cjs": "javascript",
+    ".py": "python",
+    ".rs": "rust",
+    ".go": "go",
+    ".java": "java",
+    ".md": "markdown",
+    ".mdx": "markdown",
+    ".json": "json"
+};
+export function detectLanguage(filePath) {
+    const dot = filePath.lastIndexOf(".");
+    if (dot === -1)
+        return "unknown";
+    return EXTENSION_LANGUAGE[filePath.slice(dot).toLowerCase()] ?? "unknown";
+}
+export function isIndexableLanguage(language) {
+    return language !== "unknown";
+}

package/dist/src/indexing/scanner.d.ts

@@ -0,0 +1,13 @@
+import type { CodeFile } from "../core/types.js";
+export interface ScanOptions {
+    maxFileBytes?: number;
+    filePaths?: string[];
+}
+export interface ScanResult {
+    files: CodeFile[];
+    skippedFiles: Array<{
+        filePath: string;
+        reason: string;
+    }>;
+}
+export declare function scanRepo(repoRoot: string, projectId: string, options?: ScanOptions): Promise<ScanResult>;

package/dist/src/indexing/scanner.js

@@ -0,0 +1,87 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { sha256 } from "../utils/hash.js";
+import { normalizeRepoPath } from "../utils/path.js";
+import { detectLanguage, isIndexableLanguage } from "./language.js";
+import { shouldIgnoreDirectory, shouldIgnoreFile } from "./ignore-policy.js";
+export async function scanRepo(repoRoot, projectId, options = {}) {
+    const absoluteRoot = path.resolve(repoRoot);
+    const maxFileBytes = options.maxFileBytes ?? 512_000;
+    const files = [];
+    const skippedFiles = [];
+    if (options.filePaths?.length) {
+        for (const filePath of [...new Set(options.filePaths.map((candidate) => candidate.replaceAll("\\", "/")))].sort()) {
+            await scanOne(filePath);
+        }
+        return {
+            files: files.sort((a, b) => a.path.localeCompare(b.path)),
+            skippedFiles: skippedFiles.sort((a, b) => a.filePath.localeCompare(b.filePath))
+        };
+    }
+    async function walk(dir) {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const absolutePath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                const decision = shouldIgnoreDirectory(entry.name);
+                if (decision.ignored) {
+                    skippedFiles.push({ filePath: normalizeRepoPath(absoluteRoot, absolutePath), reason: decision.reason ?? "ignored directory" });
+                }
+                else {
+                    await walk(absolutePath);
+                }
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            const relativePath = normalizeRepoPath(absoluteRoot, absolutePath);
+            await scanFile(absolutePath, relativePath);
+        }
+    }
+    await walk(absoluteRoot);
+    return {
+        files: files.sort((a, b) => a.path.localeCompare(b.path)),
+        skippedFiles: skippedFiles.sort((a, b) => a.filePath.localeCompare(b.filePath))
+    };
+    async function scanOne(relativePath) {
+        if (!relativePath || relativePath === "." || relativePath.startsWith("..") || path.isAbsolute(relativePath))
+            return;
+        const parts = relativePath.split("/");
+        const ignoredDirectory = parts.find((part) => shouldIgnoreDirectory(part).ignored);
+        if (ignoredDirectory) {
+            skippedFiles.push({ filePath: relativePath, reason: shouldIgnoreDirectory(ignoredDirectory).reason ?? "ignored directory" });
+            return;
+        }
+        await scanFile(path.join(absoluteRoot, relativePath), relativePath);
+    }
+    async function scanFile(absolutePath, relativePath) {
+        const stat = await fs.stat(absolutePath).catch((error) => {
+            if (isNotFound(error))
+                return undefined;
+            throw error;
+        });
+        if (!stat?.isFile())
+            return;
+        const fileDecision = shouldIgnoreFile(relativePath, maxFileBytes, stat.size);
+        if (fileDecision.ignored) {
+            skippedFiles.push({ filePath: relativePath, reason: fileDecision.reason ?? "ignored file" });
+            return;
+        }
+        const language = detectLanguage(path.basename(relativePath));
+        if (!isIndexableLanguage(language))
+            return;
+        const content = await fs.readFile(absolutePath, "utf8");
+        files.push({
+            projectId,
+            path: relativePath,
+            absolutePath,
+            language,
+            sizeBytes: stat.size,
+            contentHash: sha256(content),
+            modifiedAtMs: stat.mtimeMs
+        });
+    }
+}
+function isNotFound(error) {
+    return Boolean(error && typeof error === "object" && "code" in error && error.code === "ENOENT");
+}

package/dist/src/lsp/definition-resolver.d.ts

@@ -0,0 +1,6 @@
+import type { GraphEdge, SymbolNode } from "../core/types.js";
+import { TypeScriptLanguageService, type TypeScriptSourceFile } from "./typescript-language-service.js";
+export interface TypeScriptDefinitionResolverOptions {
+    createService?: (repoRoot: string, sources: TypeScriptSourceFile[]) => Pick<TypeScriptLanguageService, "getDefinitionAt">;
+}
+export declare function resolveCallDefinitionsWithTypeScript(repoRoot: string, sources: TypeScriptSourceFile[], symbols: SymbolNode[], edges: GraphEdge[], options?: TypeScriptDefinitionResolverOptions): GraphEdge[];

package/dist/src/lsp/definition-resolver.js

@@ -0,0 +1,60 @@
+import { TypeScriptLanguageService } from "./typescript-language-service.js";
+export function resolveCallDefinitionsWithTypeScript(repoRoot, sources, symbols, edges, options = {}) {
+    if (sources.length === 0)
+        return edges;
+    try {
+        const service = options.createService?.(repoRoot, sources) ?? new TypeScriptLanguageService(repoRoot, sources);
+        return edges.map((edge) => resolveCallEdge(service, symbols, edge));
+    }
+    catch {
+        return edges;
+    }
+}
+function resolveCallEdge(service, symbols, edge) {
+    if (edge.kind !== "calls" || edge.metadata?.resolution === "resolved")
+        return edge;
+    const sourceFile = stringMetadata(edge, "sourceFile");
+    const position = numberMetadata(edge, "position");
+    if (!sourceFile || position === undefined)
+        return unresolved(edge);
+    const definitions = service.getDefinitionAt(sourceFile, position);
+    const targetSymbol = findTargetSymbol(symbols, definitions, stringMetadata(edge, "targetName"));
+    if (!targetSymbol)
+        return unresolved(edge);
+    return {
+        ...edge,
+        targetId: targetSymbol.id,
+        metadata: {
+            ...edge.metadata,
+            resolution: "resolved_lsp",
+            targetFile: targetSymbol.filePath,
+            targetSymbol: targetSymbol.name
+        }
+    };
+}
+function findTargetSymbol(symbols, definitions, targetName) {
+    const candidates = definitions.flatMap((definition) => {
+        const containing = symbols.filter((symbol) => symbol.kind !== "file" &&
+            symbol.filePath === definition.filePath &&
+            symbol.startLine <= definition.startLine &&
+            symbol.endLine >= definition.startLine);
+        return containing.map((symbol) => ({ symbol, definition }));
+    });
+    return candidates.find(({ symbol }) => targetName && symbol.name === targetName)?.symbol
+        ?? candidates.find(({ symbol, definition }) => definition.name && symbol.name === definition.name)?.symbol
+        ?? candidates.sort((a, b) => symbolSpan(a.symbol) - symbolSpan(b.symbol))[0]?.symbol;
+}
+function unresolved(edge) {
+    return { ...edge, metadata: { ...edge.metadata, resolution: "unresolved" } };
+}
+function symbolSpan(symbol) {
+    return symbol.endLine - symbol.startLine;
+}
+function stringMetadata(edge, key) {
+    const value = edge.metadata?.[key];
+    return typeof value === "string" ? value : undefined;
+}
+function numberMetadata(edge, key) {
+    const value = edge.metadata?.[key];
+    return typeof value === "number" ? value : undefined;
+}

package/dist/src/lsp/typescript-language-service.d.ts

@@ -0,0 +1,21 @@
+export interface TypeScriptSourceFile {
+    filePath: string;
+    absolutePath: string;
+    content: string;
+}
+export interface TypeScriptDefinitionLocation {
+    filePath: string;
+    startLine: number;
+    endLine: number;
+    name?: string;
+}
+export declare class TypeScriptLanguageService {
+    private readonly repoRoot;
+    private readonly service;
+    private readonly absoluteByRepoPath;
+    private readonly contentByAbsolutePath;
+    constructor(repoRoot: string, sources: TypeScriptSourceFile[]);
+    getDefinitionAt(repoFilePath: string, position: number): TypeScriptDefinitionLocation[];
+    private createHost;
+    private toDefinitionLocation;
+}