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

package/dist/core/incremental/types.js

@@ -68,81 +68,79 @@ function assertArray(v, label) {
 export function parseParentMessage(raw) {
     if (!isObject(raw))
         throw new TypeError('IPC message must be an object');
-    assertString(raw.kind, 'kind');
-    if (raw.kind === 'shutdown')
+    assertString(raw['kind'], 'kind');
+    if (raw['kind'] === 'shutdown')
         return { kind: 'shutdown' };
-    if (raw.kind === 'refresh') {
-        if (!isObject(raw.payload))
+    if (raw['kind'] === 'refresh') {
+        if (!isObject(raw['payload']))
             throw new TypeError('refresh payload must be an object');
-        const p = raw.payload;
-        assertString(p.repoRoot, 'repoRoot');
-        assertString(p.dbPath, 'dbPath');
-        assertString(p.storagePath, 'storagePath');
-        assertArray(p.dirtyFiles, 'dirtyFiles');
+        const p = raw['payload'];
+        assertString(p['repoRoot'], 'repoRoot');
+        assertString(p['dbPath'], 'dbPath');
+        assertString(p['storagePath'], 'storagePath');
+        assertArray(p['dirtyFiles'], 'dirtyFiles');
         const dirtyFiles = [];
-        for (const entry of p.dirtyFiles) {
+        for (const entry of p['dirtyFiles']) {
             if (!isObject(entry))
                 throw new TypeError('dirtyFiles entry must be an object');
-            assertString(entry.relativePath, 'relativePath');
-            assertString(entry.changeKind, 'changeKind');
-            if (!FILE_CHANGE_KINDS.includes(entry.changeKind)) {
-                throw new TypeError(`Invalid changeKind: ${entry.changeKind}`);
+            assertString(entry['relativePath'], 'relativePath');
+            assertString(entry['changeKind'], 'changeKind');
+            if (!FILE_CHANGE_KINDS.includes(entry['changeKind'])) {
+                throw new TypeError(`Invalid changeKind: ${entry['changeKind']}`);
             }
             dirtyFiles.push({
-                relativePath: entry.relativePath,
-                changeKind: entry.changeKind,
+                relativePath: entry['relativePath'],
+                changeKind: entry['changeKind'],
             });
         }
         return {
             kind: 'refresh',
             payload: {
-                repoRoot: p.repoRoot,
-                dbPath: p.dbPath,
-                storagePath: p.storagePath,
+                repoRoot: p['repoRoot'],
+                dbPath: p['dbPath'],
+                storagePath: p['storagePath'],
                 dirtyFiles,
             },
         };
     }
-    throw new TypeError(`Unknown IPC message kind: ${raw.kind}`);
+    throw new TypeError(`Unknown IPC message kind: ${raw['kind']}`);
 }
 /** Validate and narrow an unknown IPC message from the child */
 export function parseChildMessage(raw) {
     if (!isObject(raw))
         throw new TypeError('IPC message must be an object');
-    assertString(raw.kind, 'kind');
-    if (raw.kind === 'progress') {
-        assertString(raw.phase, 'phase');
-        if (!REFRESH_PHASES.includes(raw.phase)) {
-            throw new TypeError(`Invalid refresh phase: ${raw.phase}`);
+    assertString(raw['kind'], 'kind');
+    if (raw['kind'] === 'progress') {
+        assertString(raw['phase'], 'phase');
+        if (!REFRESH_PHASES.includes(raw['phase'])) {
+            throw new TypeError(`Invalid refresh phase: ${raw['phase']}`);
         }
-        assertString(raw.detail, 'detail');
-        return { kind: 'progress', phase: raw.phase, detail: raw.detail };
+        assertString(raw['detail'], 'detail');
+        return { kind: 'progress', phase: raw['phase'], detail: raw['detail'] };
     }
-    if (raw.kind === 'success') {
-        if (!isObject(raw.payload))
+    if (raw['kind'] === 'success') {
+        if (!isObject(raw['payload']))
             throw new TypeError('success payload must be an object');
-        const p = raw.payload;
+        const p = raw['payload'];
         return {
             kind: 'success',
             payload: {
-                filesProcessed: Number(p.filesProcessed) || 0,
-                filesSkipped: Number(p.filesSkipped) || 0,
-                nodesDeleted: Number(p.nodesDeleted) || 0,
-                nodesInserted: Number(p.nodesInserted) || 0,
-                edgesInserted: Number(p.edgesInserted) || 0,
-                durationMs: Number(p.durationMs) || 0,
+                filesProcessed: Number(p['filesProcessed']) || 0,
+                filesSkipped: Number(p['filesSkipped']) || 0,
+                nodesDeleted: Number(p['nodesDeleted']) || 0,
+                nodesInserted: Number(p['nodesInserted']) || 0,
+                edgesInserted: Number(p['edgesInserted']) || 0,
+                durationMs: Number(p['durationMs']) || 0,
+                tsgoEnabled: Boolean(p['tsgoEnabled']),
             },
         };
     }
-    if (raw.kind === 'error') {
-        assertString(raw.message, 'message');
-        return {
-            kind: 'error',
-            message: raw.message,
-            stack: typeof raw.stack === 'string' ? raw.stack : undefined,
-        };
+    if (raw['kind'] === 'error') {
+        assertString(raw['message'], 'message');
+        const base = { kind: 'error', message: raw['message'] };
+        return typeof raw['stack'] === 'string' ? { ...base, stack: raw['stack'] } : base;
     }
-    throw new TypeError(`Unknown child message kind: ${raw.kind}`);
+    throw new TypeError(`Unknown child message kind: ${raw['kind']}`);
 }
 // ---------------------------------------------------------------------------
 // Exhaustiveness guard

package/dist/core/ingestion/ast-cache.js

@@ -1,6 +1,7 @@
 // code-mapper/src/core/ingestion/ast-cache.ts
 /** @file ast-cache.ts @description LRU cache for parsed tree-sitter AST trees with automatic WASM memory cleanup on eviction */
 import { LRUCache } from 'lru-cache';
+import Parser from 'tree-sitter';
 export const createASTCache = (maxSize = 50) => {
     const effectiveMax = Math.max(maxSize, 1);
     // Dispose handler runs automatically on eviction to free WASM memory

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

@@ -1,15 +1,16 @@
 /** @file call-processor.ts @description Resolves function/method call sites to target symbol nodes, supporting sequential AST-based and pre-extracted worker-based paths */
-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 { ResolutionContext } from './resolution-context.js';
 import type { ExtractedCall, ExtractedHeritage, ExtractedRoute, FileConstructorBindings } from './workers/parse-worker.js';
+import type { TsgoService } from '../semantic/tsgo-service.js';
 export declare const processCalls: (graph: KnowledgeGraph, files: {
     path: string;
     content: string;
 }[], astCache: ASTCache, ctx: ResolutionContext, onProgress?: (current: number, total: number) => void) => Promise<ExtractedHeritage[]>;
 export declare const extractReturnTypeName: (raw: string, depth?: number) => string | undefined;
 /** Resolve pre-extracted call sites from workers (no AST parsing needed) */
-export declare const processCallsFromExtracted: (graph: KnowledgeGraph, extractedCalls: ExtractedCall[], ctx: ResolutionContext, onProgress?: (current: number, total: number) => void, constructorBindings?: FileConstructorBindings[]) => Promise<void>;
+export declare const processCallsFromExtracted: (graph: KnowledgeGraph, extractedCalls: ExtractedCall[], ctx: ResolutionContext, onProgress?: (current: number, total: number) => void, constructorBindings?: FileConstructorBindings[], tsgoService?: TsgoService | null, repoPath?: string) => Promise<void>;
 /** Resolve pre-extracted Laravel routes to CALLS edges from route files to controller methods */
 export declare const processRoutesFromExtracted: (graph: KnowledgeGraph, extractedRoutes: ExtractedRoute[], ctx: ResolutionContext, onProgress?: (current: number, total: number) => void) => Promise<void>;
 /**
@@ -32,3 +33,14 @@ export declare const createDependsOnEdges: (graph: KnowledgeGraph, ctx: Resoluti
  * This captures @Bean factories, provider methods, and factory functions.
  */
 export declare const createProvidesEdges: (graph: KnowledgeGraph, ctx: ResolutionContext) => Promise<number>;
+/**
+ * Post-pass: connect interface method DECLARATIONS to their IMPLEMENTATIONS.
+ *
+ * For each interface Method node (e.g. EventBus.emit), find the matching
+ * implementation Function in files that import the interface definition.
+ * Creates CALLS edges: InterfaceMethod → ImplementationFunction.
+ *
+ * This makes the call chain traversable:
+ *   register() →[tsgo]→ EventBus.emit (Method) →[dispatch]→ emit (Function in event-bus.ts)
+ */
+export declare const resolveInterfaceDispatches: (graph: KnowledgeGraph, ctx: ResolutionContext) => Promise<number>;