@zuvia-software-solutions/code-mapper 1.4.0 → 2.0.0

package/dist/core/ingestion/cluster-enricher.d.ts

@@ -1,5 +1,5 @@
 /** @file cluster-enricher.ts @description LLM-based enrichment for community clusters, generating semantic names, keywords, and descriptions */
-import { CommunityNode } from './community-processor.js';
+import type { CommunityNode } from './community-processor.js';
 export interface ClusterEnrichment {
     name: string;
     keywords: string[];

package/dist/core/ingestion/cluster-enricher.js

@@ -50,6 +50,8 @@ export const enrichClusters = async (communities, memberMap, llmClient, onProgre
     let tokensUsed = 0;
     for (let i = 0; i < communities.length; i++) {
         const community = communities[i];
+        if (community === undefined)
+            continue;
         const members = memberMap.get(community.id) || [];
         onProgress?.(i + 1, communities.length);
         if (members.length === 0) {

package/dist/core/ingestion/community-processor.d.ts

@@ -1,5 +1,5 @@
 /** @file community-processor.ts @description Detects code communities using the Leiden algorithm on CALLS/EXTENDS/IMPLEMENTS edges, grouping symbols by functional area */
-import { KnowledgeGraph } from '../graph/types.js';
+import type { KnowledgeGraph } from '../graph/types.js';
 export interface CommunityNode {
     id: string;
     label: string;

package/dist/core/ingestion/community-processor.js

@@ -28,7 +28,10 @@ export const COMMUNITY_COLORS = [
     '#84cc16', // lime
 ];
 export const getCommunityColor = (communityIndex) => {
-    return COMMUNITY_COLORS[communityIndex % COMMUNITY_COLORS.length];
+    const color = COMMUNITY_COLORS[communityIndex % COMMUNITY_COLORS.length];
+    if (color === undefined)
+        return '#888888';
+    return color;
 };
 /** Detect communities in the knowledge graph using the Leiden algorithm on CALLS/EXTENDS/IMPLEMENTS edges */
 export const processCommunities = async (knowledgeGraph, onProgress) => {
@@ -149,7 +152,7 @@ const buildGraphologyGraph = (knowledgeGraph, isLarge) => {
     return graph;
 };
 /** Create Community nodes with auto-generated labels based on member file paths */
-const createCommunityNodes = (communities, communityCount, graph, knowledgeGraph) => {
+const createCommunityNodes = (communities, _communityCount, graph, knowledgeGraph) => {
     // Group node IDs by community number
     const communityMembers = new Map();
     Object.entries(communities).forEach(([nodeId, commNum]) => {
@@ -195,7 +198,7 @@ const generateHeuristicLabel = (memberIds, nodePathMap, graph, commNum) => {
         if (parts.length >= 2) {
             const folder = parts[parts.length - 2];
             // Skip generic folders
-            if (!['src', 'lib', 'core', 'utils', 'common', 'shared', 'helpers'].includes(folder.toLowerCase())) {
+            if (folder !== undefined && !['src', 'lib', 'core', 'utils', 'common', 'shared', 'helpers'].includes(folder.toLowerCase())) {
                 folderCounts.set(folder, (folderCounts.get(folder) || 0) + 1);
             }
         }
@@ -237,6 +240,8 @@ const findCommonPrefix = (strings) => {
     const sorted = strings.slice().sort();
     const first = sorted[0];
     const last = sorted[sorted.length - 1];
+    if (first === undefined || last === undefined)
+        return '';
     let i = 0;
     while (i < first.length && first[i] === last[i]) {
         i++;

package/dist/core/ingestion/export-detection.d.ts

@@ -1,5 +1,5 @@
 /** @file export-detection.ts @description Per-language detection of whether a symbol is exported/public, pure function safe for worker threads */
-import { SyntaxNode } from './utils.js';
+import { type SyntaxNode } from './utils.js';
 import { SupportedLanguages } from '../../config/supported-languages.js';
 /**
  * Check if a tree-sitter node is exported/public in its language

package/dist/core/ingestion/export-detection.js

@@ -74,7 +74,7 @@ const csharpExportChecker = (node, _name) => {
 const goExportChecker = (_node, name) => {
     if (name.length === 0)
         return false;
-    const first = name[0];
+    const first = name.charAt(0);
     return first === first.toUpperCase() && first !== first.toLowerCase();
 };
 // Rust declaration node types for visibility_modifier scanning

package/dist/core/ingestion/filesystem-walker.js

@@ -30,7 +30,7 @@ export const walkRepositoryPaths = async (repoPath, onProgress) => {
                 onProgress?.(processed, filtered.length, result.value.path);
             }
             else {
-                onProgress?.(processed, filtered.length, batch[results.indexOf(result)]);
+                onProgress?.(processed, filtered.length, batch[results.indexOf(result)] ?? '');
             }
         }
     }

package/dist/core/ingestion/heritage-processor.d.ts

@@ -1,6 +1,6 @@
 /** @file heritage-processor.ts @description Extracts class inheritance relationships (EXTENDS/IMPLEMENTS) from AST matches. Resolves the correct edge type via symbol table lookup, falling back to language-gated heuristics for unresolved symbols: C#/Java use I[A-Z] convention, Swift defaults to IMPLEMENTS, all others default to EXTENDS */
-import { KnowledgeGraph } from '../graph/types.js';
-import { ASTCache } from './ast-cache.js';
+import type { KnowledgeGraph } from '../graph/types.js';
+import type { ASTCache } from './ast-cache.js';
 import type { ExtractedHeritage } from './workers/parse-worker.js';
 import type { ResolutionContext } from './resolution-context.js';
 export declare const processHeritage: (graph: KnowledgeGraph, files: {

package/dist/core/ingestion/heritage-processor.js

@@ -4,6 +4,7 @@ import Parser from 'tree-sitter';
 import { isLanguageAvailable, loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
 import { LANGUAGE_QUERIES } from './tree-sitter-queries.js';
 import { generateId } from '../../lib/utils.js';
+import { toNodeId, toEdgeId } from '../db/schema.js';
 import { getLanguageFromFilename, isVerboseIngestionEnabled, yieldToEventLoop } from './utils.js';
 import { SupportedLanguages } from '../../config/supported-languages.js';
 import { getTreeSitterBufferSize } from './constants.js';
@@ -18,7 +19,10 @@ const INTERFACE_NAME_RE = /^I[A-Z]/;
 const resolveExtendsType = (parentName, currentFilePath, ctx, language) => {
     const resolved = ctx.resolve(parentName, currentFilePath);
     if (resolved && resolved.candidates.length > 0) {
-        const isInterface = resolved.candidates[0].type === 'Interface';
+        const topCandidate = resolved.candidates[0];
+        if (!topCandidate)
+            return { type: 'EXTENDS', idPrefix: 'Class' };
+        const isInterface = topCandidate.type === 'Interface';
         return isInterface
             ? { type: 'IMPLEMENTS', idPrefix: 'Interface' }
             : { type: 'EXTENDS', idPrefix: 'Class' };
@@ -47,7 +51,10 @@ const resolveHeritageId = (name, filePath, ctx, fallbackLabel, fallbackKey) => {
         if (resolved.tier === 'global' && resolved.candidates.length > 1) {
             return generateId(fallbackLabel, fallbackKey ?? name);
         }
-        return resolved.candidates[0].nodeId;
+        const topCandidate = resolved.candidates[0];
+        if (!topCandidate)
+            return generateId(fallbackLabel, fallbackKey ?? name);
+        return toNodeId(topCandidate.nodeId);
     }
     return generateId(fallbackLabel, fallbackKey ?? name);
 };
@@ -57,6 +64,8 @@ export const processHeritage = async (graph, files, astCache, ctx, onProgress) =
     const skippedByLang = logSkipped ? new Map() : null;
     for (let i = 0; i < files.length; i++) {
         const file = files[i];
+        if (!file)
+            continue;
         onProgress?.(i + 1, files.length);
         if (i % 20 === 0)
             await yieldToEventLoop();
@@ -81,7 +90,7 @@ export const processHeritage = async (graph, files, astCache, ctx, onProgress) =
             try {
                 tree = parser.parse(file.content, undefined, { bufferSize: getTreeSitterBufferSize(file.content.length) });
             }
-            catch (parseError) {
+            catch {
                 // Skip files that can't be parsed
                 continue;
             }
@@ -91,8 +100,8 @@ export const processHeritage = async (graph, files, astCache, ctx, onProgress) =
         let query;
         let matches;
         try {
-            const language = parser.getLanguage();
-            query = new Parser.Query(language, queryStr);
+            const tsLang = parser.getLanguage();
+            query = new Parser.Query(tsLang, queryStr);
             matches = query.matches(tree.rootNode);
         }
         catch (queryError) {
@@ -121,7 +130,7 @@ export const processHeritage = async (graph, files, astCache, ctx, onProgress) =
                 const parentId = resolveHeritageId(parentClassName, file.path, ctx, idPrefix);
                 if (childId && parentId && childId !== parentId) {
                     graph.addRelationship({
-                        id: generateId(relType, `${childId}->${parentId}`),
+                        id: toEdgeId(`${relType}:${childId}->${parentId}`),
                         sourceId: childId,
                         targetId: parentId,
                         type: relType,
@@ -138,7 +147,7 @@ export const processHeritage = async (graph, files, astCache, ctx, onProgress) =
                 const interfaceId = resolveHeritageId(interfaceName, file.path, ctx, 'Interface');
                 if (classId && interfaceId) {
                     graph.addRelationship({
-                        id: generateId('IMPLEMENTS', `${classId}->${interfaceId}`),
+                        id: toEdgeId(`IMPLEMENTS:${classId}->${interfaceId}`),
                         sourceId: classId,
                         targetId: interfaceId,
                         type: 'IMPLEMENTS',
@@ -155,7 +164,7 @@ export const processHeritage = async (graph, files, astCache, ctx, onProgress) =
                 const traitId = resolveHeritageId(traitName, file.path, ctx, 'Trait');
                 if (structId && traitId) {
                     graph.addRelationship({
-                        id: generateId('IMPLEMENTS', `${structId}->${traitId}`),
+                        id: toEdgeId(`IMPLEMENTS:${structId}->${traitId}`),
                         sourceId: structId,
                         targetId: traitId,
                         type: 'IMPLEMENTS',
@@ -186,6 +195,8 @@ export const processHeritageFromExtracted = async (graph, extractedHeritage, ctx
             await yieldToEventLoop();
         }
         const h = extractedHeritage[i];
+        if (!h)
+            continue;
         if (h.kind === 'extends') {
             const fileLanguage = getLanguageFromFilename(h.filePath);
             if (!fileLanguage)
@@ -195,7 +206,7 @@ export const processHeritageFromExtracted = async (graph, extractedHeritage, ctx
             const parentId = resolveHeritageId(h.parentName, h.filePath, ctx, idPrefix);
             if (childId && parentId && childId !== parentId) {
                 graph.addRelationship({
-                    id: generateId(relType, `${childId}->${parentId}`),
+                    id: toEdgeId(`${relType}:${childId}->${parentId}`),
                     sourceId: childId,
                     targetId: parentId,
                     type: relType,
@@ -209,7 +220,7 @@ export const processHeritageFromExtracted = async (graph, extractedHeritage, ctx
             const interfaceId = resolveHeritageId(h.parentName, h.filePath, ctx, 'Interface');
             if (classId && interfaceId) {
                 graph.addRelationship({
-                    id: generateId('IMPLEMENTS', `${classId}->${interfaceId}`),
+                    id: toEdgeId(`IMPLEMENTS:${classId}->${interfaceId}`),
                     sourceId: classId,
                     targetId: interfaceId,
                     type: 'IMPLEMENTS',
@@ -223,7 +234,7 @@ export const processHeritageFromExtracted = async (graph, extractedHeritage, ctx
             const traitId = resolveHeritageId(h.parentName, h.filePath, ctx, 'Trait');
             if (structId && traitId) {
                 graph.addRelationship({
-                    id: generateId('IMPLEMENTS', `${structId}->${traitId}:${h.kind}`),
+                    id: toEdgeId(`IMPLEMENTS:${structId}->${traitId}:${h.kind}`),
                     sourceId: structId,
                     targetId: traitId,
                     type: 'IMPLEMENTS',

package/dist/core/ingestion/import-processor.d.ts

@@ -1,6 +1,6 @@
 /** @file import-processor.ts @description Resolves import statements across all supported languages, builds the ImportMap/PackageMap/NamedImportMap, and emits IMPORTS graph edges. Supports language-specific resolution for TS, Go, C#, PHP, Swift, Ruby, Rust, and JVM languages */
-import { KnowledgeGraph } from '../graph/types.js';
-import { ASTCache } from './ast-cache.js';
+import type { KnowledgeGraph } from '../graph/types.js';
+import type { ASTCache } from './ast-cache.js';
 import type { ExtractedImport } from './workers/parse-worker.js';
 import type { ResolutionContext } from './resolution-context.js';
 import type { SuffixIndex } from './resolvers/index.js';

package/dist/core/ingestion/import-processor.js

@@ -4,6 +4,7 @@ import Parser from 'tree-sitter';
 import { isLanguageAvailable, loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
 import { LANGUAGE_QUERIES } from './tree-sitter-queries.js';
 import { generateId } from '../../lib/utils.js';
+import { toEdgeId } from '../db/schema.js';
 import { getLanguageFromFilename, isVerboseIngestionEnabled, yieldToEventLoop } from './utils.js';
 import { SupportedLanguages } from '../../config/supported-languages.js';
 import { extractNamedBindings } from './named-binding-extraction.js';
@@ -11,7 +12,7 @@ import { getTreeSitterBufferSize } from './constants.js';
 import { loadTsconfigPaths, loadGoModulePath, loadComposerConfig, loadCSharpProjectConfig, loadSwiftPackageConfig, } from './language-config.js';
 import { buildSuffixIndex, resolveImportPath, appendKotlinWildcard, KOTLIN_EXTENSIONS, resolveJvmWildcard, resolveJvmMemberImport, resolveGoPackageDir, resolveGoPackage, resolveCSharpImport, resolveCSharpNamespaceDir, resolvePhpImport, resolveRustImport, resolveRubyImport, } from './resolvers/index.js';
 import { callRouters } from './call-routing.js';
-const isDev = process.env.NODE_ENV === 'development';
+const isDev = process.env['NODE_ENV'] === 'development';
 /** Check if a file path is directly inside a package directory identified by its suffix */
 export function isFileInPackageDir(filePath, dirSuffix) {
     // Prepend '/' so paths like "internal/auth/service.go" match suffix "/internal/auth/"
@@ -92,8 +93,10 @@ function resolveLanguageImport(filePath, rawImportPath, language, configs, ctx)
             const dirPrefix = targetDir + '/';
             const files = [];
             for (let i = 0; i < normalizedFileList.length; i++) {
-                if (normalizedFileList[i].startsWith(dirPrefix) && normalizedFileList[i].endsWith('.swift')) {
-                    files.push(allFileList[i]);
+                const normalizedPath = normalizedFileList[i];
+                const originalPath = allFileList[i];
+                if (normalizedPath && originalPath && normalizedPath.startsWith(dirPrefix) && normalizedPath.endsWith('.swift')) {
+                    files.push(originalPath);
                 }
             }
             if (files.length > 0)
@@ -123,7 +126,7 @@ function resolveLanguageImport(filePath, rawImportPath, language, configs, ctx)
     return resolvedPath ? { kind: 'files', files: [resolvedPath] } : null;
 }
 /** Apply an ImportResult — emit graph edges, update ImportMap/PackageMap and NamedImportMap */
-function applyImportResult(result, filePath, importMap, packageMap, addImportEdge, addImportGraphEdge, namedBindings, namedImportMap) {
+function applyImportResult(result, filePath, _importMap, packageMap, addImportEdge, addImportGraphEdge, namedBindings, namedImportMap) {
     if (!result)
         return;
     if (result.kind === 'package' && packageMap) {
@@ -133,7 +136,9 @@ function applyImportResult(result, filePath, importMap, packageMap, addImportEdg
         }
         if (!packageMap.has(filePath))
             packageMap.set(filePath, new Set());
-        packageMap.get(filePath).add(result.dirSuffix);
+        const pkgSet = packageMap.get(filePath);
+        if (pkgSet)
+            pkgSet.add(result.dirSuffix);
     }
     else {
         // 'files' kind or 'package' without PackageMap — use ImportMap directly
@@ -144,9 +149,13 @@ function applyImportResult(result, filePath, importMap, packageMap, addImportEdg
         // Record named bindings for precise Tier 2a resolution
         if (namedBindings && namedImportMap && files.length === 1) {
             const resolvedFile = files[0];
+            if (!resolvedFile)
+                return;
             if (!namedImportMap.has(filePath))
                 namedImportMap.set(filePath, new Map());
             const fileBindings = namedImportMap.get(filePath);
+            if (!fileBindings)
+                return;
             for (const binding of namedBindings) {
                 fileBindings.set(binding.local, { sourcePath: resolvedFile, exportedName: binding.exported });
             }
@@ -220,7 +229,7 @@ export const processImports = async (graph, files, astCache, ctx, onProgress, re
     const addImportGraphEdge = (filePath, resolvedPath) => {
         const sourceId = generateId('File', filePath);
         const targetId = generateId('File', resolvedPath);
-        const relId = generateId('IMPORTS', `${filePath}->${resolvedPath}`);
+        const relId = toEdgeId(`IMPORTS:${filePath}->${resolvedPath}`);
         totalImportsResolved++;
         graph.addRelationship({
             id: relId,
@@ -237,10 +246,14 @@ export const processImports = async (graph, files, astCache, ctx, onProgress, re
         if (!importMap.has(filePath)) {
             importMap.set(filePath, new Set());
         }
-        importMap.get(filePath).add(resolvedPath);
+        const fileImports = importMap.get(filePath);
+        if (fileImports)
+            fileImports.add(resolvedPath);
     };
     for (let i = 0; i < files.length; i++) {
         const file = files[i];
+        if (!file)
+            continue;
         onProgress?.(i + 1, files.length);
         if (i % 20 === 0)
             await yieldToEventLoop();
@@ -364,7 +377,7 @@ export const processImportsFromExtracted = async (graph, files, extractedImports
     const addImportGraphEdge = (filePath, resolvedPath) => {
         const sourceId = generateId('File', filePath);
         const targetId = generateId('File', resolvedPath);
-        const relId = generateId('IMPORTS', `${filePath}->${resolvedPath}`);
+        const relId = toEdgeId(`IMPORTS:${filePath}->${resolvedPath}`);
         totalImportsResolved++;
         graph.addRelationship({
             id: relId,
@@ -381,7 +394,9 @@ export const processImportsFromExtracted = async (graph, files, extractedImports
         if (!importMap.has(filePath)) {
             importMap.set(filePath, new Set());
         }
-        importMap.get(filePath).add(resolvedPath);
+        const fileImports = importMap.get(filePath);
+        if (fileImports)
+            fileImports.add(resolvedPath);
     };
     // Group by file for progress reporting
     const importsByFile = new Map();

package/dist/core/ingestion/language-config.js

@@ -2,7 +2,7 @@
 /** @file language-config.ts @description Loads language-specific project configuration (tsconfig.json, go.mod, composer.json, .csproj, Package.swift) for import path resolution */
 import fs from 'fs/promises';
 import path from 'path';
-const isDev = process.env.NODE_ENV === 'development';
+const isDev = process.env['NODE_ENV'] === 'development';
 /**
  * Parse tsconfig.json to extract path aliases
  *
@@ -50,7 +50,7 @@ export async function loadGoModulePath(repoRoot) {
         const goModPath = path.join(repoRoot, 'go.mod');
         const content = await fs.readFile(goModPath, 'utf-8');
         const match = content.match(/^module\s+(\S+)/m);
-        if (match) {
+        if (match && match[1]) {
             if (isDev) {
                 console.log(`📦 Loaded Go module path: ${match[1]}`);
             }
@@ -95,7 +95,10 @@ export async function loadCSharpProjectConfig(repoRoot) {
     const maxDirs = 100;
     let dirsScanned = 0;
     while (scanQueue.length > 0 && dirsScanned < maxDirs) {
-        const { dir, depth } = scanQueue.shift();
+        const entry = scanQueue.shift();
+        if (!entry)
+            break;
+        const { dir, depth } = entry;
         dirsScanned++;
         try {
             const entries = await fs.readdir(dir, { withFileTypes: true });
@@ -111,7 +114,7 @@ export async function loadCSharpProjectConfig(repoRoot) {
                         const csprojPath = path.join(dir, entry.name);
                         const content = await fs.readFile(csprojPath, 'utf-8');
                         const nsMatch = content.match(/<RootNamespace>\s*([^<]+)\s*<\/RootNamespace>/);
-                        const rootNamespace = nsMatch
+                        const rootNamespace = nsMatch?.[1]
                             ? nsMatch[1].trim()
                             : entry.name.replace(/\.csproj$/, '');
                         const projectDir = path.relative(repoRoot, dir).replace(/\\/g, '/');

package/dist/core/ingestion/mro-processor.d.ts

@@ -5,7 +5,7 @@
  * resolution rules (C++ leftmost base, C#/Java class-over-interface, Python C3 linearization,
  * Rust requires qualified syntax). OVERRIDES edge direction: Class -> winning ancestor Method
  */
-import { KnowledgeGraph } from '../graph/types.js';
+import type { KnowledgeGraph } from '../graph/types.js';
 import { SupportedLanguages } from '../../config/supported-languages.js';
 export interface MROEntry {
     classId: string;

package/dist/core/ingestion/mro-processor.js

@@ -6,7 +6,7 @@
  * resolution rules (C++ leftmost base, C#/Java class-over-interface, Python C3 linearization,
  * Rust requires qualified syntax). OVERRIDES edge direction: Class -> winning ancestor Method
  */
-import { generateId } from '../../lib/utils.js';
+import { toEdgeId } from '../db/schema.js';
 import { SupportedLanguages } from '../../config/supported-languages.js';
 /** Collect EXTENDS, IMPLEMENTS, and HAS_METHOD adjacency from the graph */
 function buildAdjacency(graph) {
@@ -105,6 +105,8 @@ function c3Linearize(classId, parentMap, cache, inProgress) {
             if (seq.length === 0)
                 continue;
             const candidate = seq[0];
+            if (candidate === undefined)
+                continue;
             const inTail = sequences.some(other => other.length > 1 && other.indexOf(candidate, 1) !== -1);
             if (!inTail) {
                 head = candidate;
@@ -140,7 +142,11 @@ function resolveByMroOrder(methodName, defs, mroOrder, reasonPrefix) {
             };
         }
     }
-    return { resolvedTo: defs[0].methodId, reason: `${reasonPrefix} fallback: first definition` };
+    const first = defs[0];
+    if (first === undefined) {
+        return { resolvedTo: null, reason: `${reasonPrefix}: no definitions found` };
+    }
+    return { resolvedTo: first.methodId, reason: `${reasonPrefix} fallback: first definition` };
 }
 function resolveCsharpJava(methodName, defs, parentEdgeTypes) {
     const classDefs = [];
@@ -155,10 +161,13 @@ function resolveCsharpJava(methodName, defs, parentEdgeTypes) {
         }
     }
     if (classDefs.length > 0) {
-        return {
-            resolvedTo: classDefs[0].methodId,
-            reason: `class method wins: ${classDefs[0].className}::${methodName}`,
-        };
+        const winner = classDefs[0];
+        if (winner !== undefined) {
+            return {
+                resolvedTo: winner.methodId,
+                reason: `class method wins: ${winner.className}::${methodName}`,
+            };
+        }
     }
     if (interfaceDefs.length > 1) {
         return {
@@ -167,10 +176,13 @@ function resolveCsharpJava(methodName, defs, parentEdgeTypes) {
         };
     }
     if (interfaceDefs.length === 1) {
-        return {
-            resolvedTo: interfaceDefs[0].methodId,
-            reason: `single interface default: ${interfaceDefs[0].className}::${methodName}`,
-        };
+        const single = interfaceDefs[0];
+        if (single !== undefined) {
+            return {
+                resolvedTo: single.methodId,
+                reason: `single interface default: ${single.className}::${methodName}`,
+            };
+        }
     }
     return { resolvedTo: null, reason: 'no resolution found' };
 }
@@ -288,7 +300,7 @@ export function computeMRO(graph) {
             // Emit OVERRIDES edge if resolution found
             if (resolution.resolvedTo !== null) {
                 graph.addRelationship({
-                    id: generateId('OVERRIDES', `${classId}->${resolution.resolvedTo}`),
+                    id: toEdgeId(`OVERRIDES:${classId}->${resolution.resolvedTo}`),
                     sourceId: classId,
                     targetId: resolution.resolvedTo,
                     type: 'OVERRIDES',

package/dist/core/ingestion/named-binding-extraction.js

@@ -84,10 +84,10 @@ export function extractTsNamedBindings(importNode) {
                 if (child?.type === 'identifier')
                     identifiers.push(child.text);
             }
-            if (identifiers.length === 1) {
+            if (identifiers.length === 1 && identifiers[0] !== undefined) {
                 bindings.push({ local: identifiers[0], exported: identifiers[0] });
             }
-            else if (identifiers.length === 2) {
+            else if (identifiers.length === 2 && identifiers[0] !== undefined && identifiers[1] !== undefined) {
                 // import { Foo as Bar } -> exported='Foo', local='Bar'
                 bindings.push({ local: identifiers[1], exported: identifiers[0] });
             }
@@ -108,10 +108,10 @@ export function extractTsNamedBindings(importNode) {
                 if (child?.type === 'identifier')
                     identifiers.push(child.text);
             }
-            if (identifiers.length === 1) {
+            if (identifiers.length === 1 && identifiers[0] !== undefined) {
                 bindings.push({ local: identifiers[0], exported: identifiers[0] });
             }
-            else if (identifiers.length === 2) {
+            else if (identifiers.length === 2 && identifiers[0] !== undefined && identifiers[1] !== undefined) {
                 // export { Repo as Repository } -> first is source name, second is exported alias
                 bindings.push({ local: identifiers[1], exported: identifiers[0] });
             }
@@ -198,7 +198,7 @@ function collectRustBindings(node, bindings) {
                     idents.push(nameNode.text);
             }
         }
-        if (idents.length === 2) {
+        if (idents.length === 2 && idents[0] !== undefined && idents[1] !== undefined) {
             bindings.push({ local: idents[1], exported: idents[0] });
         }
         return;

package/dist/core/ingestion/parsing-processor.d.ts

@@ -1,8 +1,8 @@
 /** @file parsing-processor.ts @description Parses source files via tree-sitter, extracts code structure nodes (classes, functions, methods, etc), populates the symbol table, and emits DEFINES/HAS_METHOD graph relationships. Supports parallel worker pools with sequential fallback */
-import { KnowledgeGraph } from '../graph/types.js';
-import { SymbolTable } from './symbol-table.js';
-import { ASTCache } from './ast-cache.js';
-import { WorkerPool } from './workers/worker-pool.js';
+import type { KnowledgeGraph } from '../graph/types.js';
+import type { SymbolTable } from './symbol-table.js';
+import type { ASTCache } from './ast-cache.js';
+import type { WorkerPool } from './workers/worker-pool.js';
 import type { ExtractedImport, ExtractedCall, ExtractedHeritage, ExtractedRoute, FileConstructorBindings } from './workers/parse-worker.js';
 export type FileProgressCallback = (current: number, total: number, filePath: string) => void;
 export interface WorkerExtractedData {

package/dist/core/ingestion/parsing-processor.js

@@ -4,6 +4,7 @@ import Parser from 'tree-sitter';
 import { loadParser, loadLanguage, isLanguageAvailable } from '../tree-sitter/parser-loader.js';
 import { LANGUAGE_QUERIES } from './tree-sitter-queries.js';
 import { generateId } from '../../lib/utils.js';
+import { toNodeId, toEdgeId } from '../db/schema.js';
 import { getLanguageFromFilename, yieldToEventLoop, getDefinitionNodeFromCaptures, findEnclosingClassId, extractMethodSignature } from './utils.js';
 import { isNodeExported } from './export-detection.js';
 import { detectFrameworkFromAST } from './framework-detection.js';
@@ -11,7 +12,7 @@ import { typeConfigs } from './type-extractors/index.js';
 import { getTreeSitterBufferSize, TREE_SITTER_MAX_BUFFER } from './constants.js';
 export { isNodeExported } from './export-detection.js';
 // Worker-based parallel parsing
-const processParsingWithWorkers = async (graph, files, symbolTable, astCache, workerPool, onFileProgress) => {
+const processParsingWithWorkers = async (graph, files, symbolTable, _astCache, workerPool, onFileProgress) => {
     // Filter to parseable files only
     const parseableFiles = [];
     for (const file of files) {
@@ -35,20 +36,27 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
     for (const result of chunkResults) {
         for (const node of result.nodes) {
             graph.addNode({
-                id: node.id,
+                id: toNodeId(node.id),
                 label: node.label,
                 properties: node.properties,
             });
         }
         for (const rel of result.relationships) {
-            graph.addRelationship(rel);
+            graph.addRelationship({
+                id: toEdgeId(rel.id),
+                sourceId: toNodeId(rel.sourceId),
+                targetId: toNodeId(rel.targetId),
+                type: rel.type,
+                confidence: rel.confidence,
+                reason: rel.reason,
+            });
         }
         for (const sym of result.symbols) {
             symbolTable.add(sym.filePath, sym.name, sym.nodeId, sym.type, {
-                parameterCount: sym.parameterCount,
-                returnType: sym.returnType,
-                ownerId: sym.ownerId,
-                parameterTypes: sym.parameterTypes,
+                ...(sym.parameterCount !== undefined ? { parameterCount: sym.parameterCount } : {}),
+                ...(sym.returnType !== undefined ? { returnType: sym.returnType } : {}),
+                ...(sym.ownerId !== undefined ? { ownerId: sym.ownerId } : {}),
+                ...(sym.parameterTypes !== undefined ? { parameterTypes: sym.parameterTypes } : {}),
             });
         }
         allImports.push(...result.imports);
@@ -81,6 +89,8 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
     const skippedLanguages = new Map();
     for (let i = 0; i < files.length; i++) {
         const file = files[i];
+        if (!file)
+            continue;
         onFileProgress?.(i + 1, total, file.path);
         if (i % 20 === 0)
             await yieldToEventLoop();
@@ -218,10 +228,8 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
                         astFrameworkMultiplier: frameworkHint.entryPointMultiplier,
                         astFrameworkReason: frameworkHint.reason,
                     } : {}),
-                    ...(methodSig ? {
-                        parameterCount: methodSig.parameterCount,
-                        returnType: methodSig.returnType,
-                    } : {}),
+                    ...(methodSig?.parameterCount !== undefined ? { parameterCount: methodSig.parameterCount } : {}),
+                    ...(methodSig?.returnType !== undefined ? { returnType: methodSig.returnType } : {}),
                 },
             };
             graph.addNode(node);
@@ -230,13 +238,13 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
             const needsOwner = nodeLabel === 'Method' || nodeLabel === 'Constructor' || nodeLabel === 'Property' || nodeLabel === 'Function';
             const enclosingClassId = needsOwner ? findEnclosingClassId(nameNode || definitionNodeForRange, file.path) : null;
             symbolTable.add(file.path, nodeName, nodeId, nodeLabel, {
-                parameterCount: methodSig?.parameterCount,
-                returnType: methodSig?.returnType,
-                parameterTypes: methodSig?.parameterTypes,
-                ownerId: enclosingClassId ?? undefined,
+                ...(methodSig?.parameterCount !== undefined ? { parameterCount: methodSig.parameterCount } : {}),
+                ...(methodSig?.returnType !== undefined ? { returnType: methodSig.returnType } : {}),
+                ...(methodSig?.parameterTypes !== undefined ? { parameterTypes: methodSig.parameterTypes } : {}),
+                ...(enclosingClassId !== null ? { ownerId: enclosingClassId } : {}),
             });
             const fileId = generateId('File', file.path);
-            const relId = generateId('DEFINES', `${fileId}->${nodeId}`);
+            const relId = toEdgeId(`DEFINES:${fileId}->${nodeId}`);
             const relationship = {
                 id: relId,
                 sourceId: fileId,
@@ -249,8 +257,8 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
             // HAS_METHOD: link method/constructor/property to enclosing class
             if (enclosingClassId) {
                 graph.addRelationship({
-                    id: generateId('HAS_METHOD', `${enclosingClassId}->${nodeId}`),
-                    sourceId: enclosingClassId,
+                    id: toEdgeId(`HAS_METHOD:${enclosingClassId}->${nodeId}`),
+                    sourceId: toNodeId(enclosingClassId),
                     targetId: nodeId,
                     type: 'HAS_METHOD',
                     confidence: 1.0,

package/dist/core/ingestion/pipeline.d.ts

@@ -1,3 +1,5 @@
 /** @file pipeline.ts @description Main ingestion pipeline that orchestrates scanning, parsing, resolution, community detection, and process detection across chunked file batches */
-import { PipelineProgress, PipelineResult } from '../../types/pipeline.js';
-export declare const runPipelineFromRepo: (repoPath: string, onProgress: (progress: PipelineProgress) => void) => Promise<PipelineResult>;
+import type { PipelineProgress, PipelineResult } from '../../types/pipeline.js';
+export declare const runPipelineFromRepo: (repoPath: string, onProgress: (progress: PipelineProgress) => void, opts?: {
+    tsgo?: boolean;
+}) => Promise<PipelineResult>;