@grafema/core 0.1.0-alpha.5 → 0.1.1-alpha

package/src/plugins/enrichment/PrefixEvaluator.ts

@@ -94,6 +94,7 @@ export class PrefixEvaluator extends Plugin {
   async execute(context: PluginContext): Promise<PluginResult> {
     try {
       const { graph } = context;
+      const logger = this.log(context);
       const graphTyped = graph as unknown as Graph;
 
       let mountPointsEvaluated = 0;
@@ -112,7 +113,7 @@ export class PrefixEvaluator extends Plugin {
         }
       }
 
-      console.log(`[PrefixEvaluator] Found ${mountPoints.length} mount points with placeholders`);
+      logger.info('Found mount points with placeholders', { count: mountPoints.length });
 
       // For each mount point try to evaluate prefix
       for (const mountPoint of mountPoints) {
@@ -125,7 +126,7 @@ export class PrefixEvaluator extends Plugin {
         });
 
         if (definesEdges.length === 0) {
-          console.log(`[PrefixEvaluator] No DEFINES edge for mount point ${mountPoint.id}`);
+          logger.debug('No DEFINES edge for mount point', { mountPointId: mountPoint.id });
           continue;
         }
 
@@ -133,7 +134,7 @@ export class PrefixEvaluator extends Plugin {
         const module = (graphTyped.nodes as Map<string, NodeRecord>).get(moduleId) as ModuleNode | undefined;
 
         if (!module || module.type !== 'MODULE') {
-          console.log(`[PrefixEvaluator] Module not found for ${mountPoint.id}`);
+          logger.debug('Module not found for mount point', { mountPointId: mountPoint.id });
           continue;
         }
 
@@ -147,7 +148,7 @@ export class PrefixEvaluator extends Plugin {
           });
         } catch (error) {
           const err = error as Error;
-          console.log(`[PrefixEvaluator] Failed to parse ${module.file}:`, err.message);
+          logger.debug('Failed to parse file', { file: module.file, error: err.message });
           continue;
         }
 
@@ -163,11 +164,18 @@ export class PrefixEvaluator extends Plugin {
           mountPoint.prefix = evaluatedPrefix;
           mountPoint.evaluated = true;
           successfulEvaluations++;
-          console.log(`[PrefixEvaluator] Resolved ${mountPoint.file}:${mountPoint.line}: ${evaluatedPrefix}`);
+          logger.debug('Resolved prefix', {
+            file: mountPoint.file,
+            line: mountPoint.line,
+            prefix: evaluatedPrefix
+          });
         }
       }
 
-      console.log(`[PrefixEvaluator] Evaluated ${successfulEvaluations}/${mountPointsEvaluated} mount points`);
+      logger.info('Evaluated mount points', {
+        successful: successfulEvaluations,
+        total: mountPointsEvaluated
+      });
 
       return createSuccessResult(
         { nodes: 0, edges: 0 },
@@ -175,7 +183,8 @@ export class PrefixEvaluator extends Plugin {
       );
 
     } catch (error) {
-      console.error(`[PrefixEvaluator] Error:`, error);
+      const logger = this.log(context);
+      logger.error('Error in PrefixEvaluator', { error });
       return createErrorResult(error as Error);
     }
   }

package/src/plugins/enrichment/RustFFIEnricher.ts

@@ -40,20 +40,21 @@ export class RustFFIEnricher extends Plugin {
 
   async execute(context: PluginContext): Promise<PluginResult> {
     const { graph } = context;
+    const logger = this.log(context);
 
     // 1. Build index of NAPI-exported Rust functions/methods
     const napiIndex = await this.buildNapiIndex(graph);
 
     if (napiIndex.size === 0) {
-      console.log('[RustFFIEnricher] No NAPI exports found, skipping');
+      logger.info('No NAPI exports found, skipping');
       return createSuccessResult({ nodes: 0, edges: 0 }, { skipped: true, reason: 'No NAPI exports' });
     }
 
-    console.log(`[RustFFIEnricher] Indexed ${napiIndex.size} NAPI exports`);
+    logger.debug('Indexed NAPI exports', { count: napiIndex.size });
 
     // 2. Find JS CALL nodes that target Rust
     const jsCalls = await this.findRustCallingJsCalls(graph);
-    console.log(`[RustFFIEnricher] Found ${jsCalls.length} candidate JS calls`);
+    logger.debug('Found candidate JS calls', { count: jsCalls.length });
 
     // 3. Match and create FFI_CALLS edges
     let edgesCreated = 0;
@@ -78,10 +79,10 @@ export class RustFFIEnricher extends Plugin {
     }
 
     if (unmatched.length > 0 && unmatched.length <= 20) {
-      console.log(`[RustFFIEnricher] Unmatched calls:`, unmatched.slice(0, 10));
+      logger.debug('Unmatched calls', { calls: unmatched.slice(0, 10) });
     }
 
-    console.log(`[RustFFIEnricher] Created ${edgesCreated} FFI_CALLS edges`);
+    logger.info('Created FFI_CALLS edges', { count: edgesCreated, unmatched: unmatched.length });
     return createSuccessResult({ nodes: 0, edges: edgesCreated }, { unmatched: unmatched.length });
   }
 

package/src/plugins/enrichment/ValueDomainAnalyzer.ts

@@ -65,7 +65,6 @@ interface ScopeNode {
   file?: string;
   line?: number;
   originalId?: string;
-  stableId?: string;
   parentScopeId?: string;
   constraints?: Constraint[];
 }
@@ -101,6 +100,7 @@ interface Graph {
   getOutgoingEdges(nodeId: string): Promise<EdgeRecord[]>;
   getIncomingEdges(nodeId: string): Promise<EdgeRecord[]>;
   addEdge(edge: { src: string; dst: string; type: string; metadata?: Record<string, unknown> }): Promise<void> | void;
+  deleteEdge?(src: string, dst: string, type: string): Promise<void>;  // Optional for edge updates
 }
 
 interface ProgressCallback {
@@ -154,17 +154,18 @@ export class ValueDomainAnalyzer extends Plugin {
       priority: 65, // After AliasTracker (60)
       creates: {
         nodes: [],
-        edges: ['CALLS']
+        edges: ['CALLS', 'FLOWS_INTO']  // Added FLOWS_INTO (modifies existing)
       }
     };
   }
 
   async execute(context: PluginContext): Promise<PluginResult> {
     const { graph } = context;
+    const logger = this.log(context);
     const onProgress = (context as unknown as { onProgress?: ProgressCallback }).onProgress;
     const graphTyped = graph as unknown as Graph;
 
-    console.log('[ValueDomainAnalyzer] Starting value domain analysis...');
+    logger.info('Starting value domain analysis');
 
     let callsProcessed = 0;
     let callsResolved = 0;
@@ -182,7 +183,7 @@ export class ValueDomainAnalyzer extends Plugin {
       }
     }
 
-    console.log(`[ValueDomainAnalyzer] Found ${computedCalls.length} computed member calls`);
+    logger.info('Found computed member calls', { count: computedCalls.length });
 
     // 2. For each computed call get value set
     for (const call of computedCalls) {
@@ -249,18 +250,24 @@ export class ValueDomainAnalyzer extends Plugin {
       }
     }
 
+    // 5. Resolve computed property mutations in FLOWS_INTO edges
+    logger.debug('Resolving computed property mutations');
+    const mutationStats = await this.resolveComputedMutations(graphTyped, logger);
+    logger.debug('Mutation resolution stats', mutationStats);
+
     const summary = {
       callsProcessed,
       callsResolved,
       edgesCreated,
       conditionalCalls,
-      partialCalls
+      partialCalls,
+      computedMutations: mutationStats
     };
 
-    console.log('[ValueDomainAnalyzer] Summary:', summary);
+    logger.info('Summary', summary);
 
     return createSuccessResult(
-      { nodes: 0, edges: edgesCreated },
+      { nodes: 0, edges: edgesCreated + mutationStats.resolved + mutationStats.conditional },
       summary
     );
   }
@@ -294,13 +301,10 @@ export class ValueDomainAnalyzer extends Plugin {
     }
 
     if (variables.length === 0) {
-      console.log(`[ValueDomainAnalyzer] No variable found for ${variableName} in ${file}`);
       result.hasUnknown = true;
       return result;
     }
 
-    console.log(`[ValueDomainAnalyzer] Found ${variables.length} variable(s) for ${variableName}`);
-
     // Trace ASSIGNED_FROM to LITERAL or nondeterministic sources
     const visited = new Set<string>();
     const valueSet = new Set<unknown>();
@@ -377,8 +381,7 @@ export class ValueDomainAnalyzer extends Plugin {
       for await (const s of graph.queryNodes({ nodeType: 'SCOPE' })) {
         const scopeNode = s as ScopeNode;
         if (scopeNode.id === currentScopeId ||
-            scopeNode.originalId === currentScopeId ||
-            scopeNode.stableId === currentScopeId) {
+            scopeNode.originalId === currentScopeId) {
           scope = scopeNode;
           break;
         }
@@ -677,6 +680,140 @@ export class ValueDomainAnalyzer extends Plugin {
 
     return null;
   }
+
+  /**
+   * Resolve computed property names for object mutations.
+   * Finds FLOWS_INTO edges with mutationType: 'computed' and resolves
+   * the property name using value set tracing.
+   *
+   * @param graph - Graph backend with edge operations
+   * @returns Statistics about resolution
+   */
+  async resolveComputedMutations(graph: Graph, logger: ReturnType<typeof this.log>): Promise<{
+    resolved: number;
+    conditional: number;
+    unknownParameter: number;
+    unknownRuntime: number;
+    deferredCrossFile: number;
+    total: number;
+  }> {
+    const stats = {
+      resolved: 0,
+      conditional: 0,
+      unknownParameter: 0,
+      unknownRuntime: 0,
+      deferredCrossFile: 0,
+      total: 0
+    };
+
+    // Process edges by finding all VARIABLE and CONSTANT nodes and checking their outgoing edges
+    const processedEdges = new Set<string>();
+
+    // Helper to process a node's outgoing edges
+    const processNodeEdges = async (node: NodeRecord): Promise<void> => {
+      const outgoing = await graph.getOutgoingEdges(node.id);
+
+      for (const edge of outgoing) {
+        const edgeType = (edge as { edgeType?: string; edge_type?: string; type?: string }).edgeType ||
+                         (edge as { edge_type?: string }).edge_type ||
+                         (edge as { type?: string }).type;
+
+        if (edgeType !== 'FLOWS_INTO') continue;
+
+        const edgeKey = `${edge.src}->${edge.dst}:FLOWS_INTO`;
+        if (processedEdges.has(edgeKey)) continue;
+        processedEdges.add(edgeKey);
+
+        const mutationType = (edge as { mutationType?: string }).mutationType;
+        const computedPropertyVar = (edge as { computedPropertyVar?: string }).computedPropertyVar;
+
+        if (mutationType !== 'computed' || !computedPropertyVar) continue;
+
+        stats.total++;
+
+        // Get file from source node
+        const sourceNode = await graph.getNode(edge.src);
+        const file = (sourceNode as { file?: string })?.file;
+        if (!file) continue;
+
+        // Resolve the computed property variable using existing getValueSet
+        const valueSet = await this.getValueSet(computedPropertyVar, file, graph);
+
+        // Check if the variable is a PARAMETER node
+        let isParameter = false;
+        for await (const node of graph.queryNodes({ nodeType: 'PARAMETER' })) {
+          const paramNode = node as { name?: string; file?: string; attrs?: { name?: string; file?: string } };
+          const nodeName = paramNode.name || paramNode.attrs?.name;
+          const nodeFile = paramNode.file || paramNode.attrs?.file;
+          if (nodeName === computedPropertyVar && nodeFile === file) {
+            isParameter = true;
+            break;
+          }
+        }
+
+        // Determine resolution status based on value set
+        let resolutionStatus: string;
+        let resolvedPropertyNames: string[] = [];
+
+        if (valueSet.values.length === 0 && isParameter) {
+          // Variable is a function parameter - cannot be statically resolved
+          resolutionStatus = 'UNKNOWN_PARAMETER';
+          stats.unknownParameter++;
+        } else if (valueSet.values.length === 0 && valueSet.hasUnknown) {
+          // Completely nondeterministic - runtime value (function call result, etc.)
+          resolutionStatus = 'UNKNOWN_RUNTIME';
+          stats.unknownRuntime++;
+        } else if (valueSet.values.length === 0) {
+          // No values found at all - treat as unknown
+          resolutionStatus = 'UNKNOWN_RUNTIME';
+          stats.unknownRuntime++;
+        } else if (valueSet.values.length === 1 && !valueSet.hasUnknown) {
+          // Single deterministic value
+          resolutionStatus = 'RESOLVED';
+          resolvedPropertyNames = valueSet.values.map(v => String(v));
+          stats.resolved++;
+        } else {
+          // Multiple values (conditional) or partial resolution
+          resolutionStatus = 'RESOLVED_CONDITIONAL';
+          resolvedPropertyNames = valueSet.values.map(v => String(v));
+          stats.conditional++;
+        }
+
+        // Update edge: delete old, create new with resolved data
+        // Following the same pattern as InstanceOfResolver
+        if (graph.deleteEdge) {
+          await graph.deleteEdge(edge.src, edge.dst, 'FLOWS_INTO');
+        }
+
+        // Preserve original edge data and add resolution info
+        // For UNKNOWN cases, keep propertyName as '<computed>' and resolvedPropertyNames empty
+        await graph.addEdge({
+          src: edge.src,
+          dst: edge.dst,
+          type: 'FLOWS_INTO',
+          metadata: {
+            mutationType,
+            propertyName: resolvedPropertyNames[0] || '<computed>',
+            computedPropertyVar,
+            resolvedPropertyNames,
+            resolutionStatus
+          }
+        });
+      }
+    };
+
+    // Process VARIABLE nodes
+    for await (const node of graph.queryNodes({ nodeType: 'VARIABLE' })) {
+      await processNodeEdges(node);
+    }
+
+    // Process CONSTANT nodes
+    for await (const node of graph.queryNodes({ nodeType: 'CONSTANT' })) {
+      await processNodeEdges(node);
+    }
+
+    return stats;
+  }
 }
 
 export default ValueDomainAnalyzer;

package/src/plugins/indexing/IncrementalModuleIndexer.ts

@@ -151,12 +151,13 @@ export class IncrementalModuleIndexer extends Plugin {
 
       return imports;
     } catch (err) {
-      console.error(`   ⚠️  Failed to parse imports from ${relative(projectRoot, filePath)}: ${(err as Error).message}`);
+      // Parse error will be logged by execute() when it needs logger context
       return [];
     }
   }
 
   async execute(context: PluginContext): Promise<PluginResult> {
+    const logger = this.log(context);
     try {
       const { manifest, graph } = context;
       // Cast manifest to expected shape
@@ -175,7 +176,7 @@ export class IncrementalModuleIndexer extends Plugin {
       let totalImportsParsed = 0;
       let unresolvedImports = 0;
 
-      console.log(`📦 Starting incremental indexing from: ${relative(projectPath, entryFile)}\n`);
+      logger.info('Starting incremental indexing', { entryFile: relative(projectPath, entryFile) });
 
       while (queue.length > 0) {
         const file = queue.shift()!;
@@ -183,12 +184,13 @@ export class IncrementalModuleIndexer extends Plugin {
         if (processed.has(file)) continue;
         processed.add(file);
 
-        // Create MODULE node
+        // Create MODULE node with semantic ID
         const fileHash = this.calculateFileHash(file);
         const relativePath = relative(projectPath, file);
+        const semanticId = `${relativePath}->global->MODULE->module`;
 
         const moduleNode: NodeRecord = {
-          id: `${file}:MODULE:${file}:0`,
+          id: semanticId,
           type: 'MODULE',
           name: relativePath,
           file: file,
@@ -211,10 +213,12 @@ export class IncrementalModuleIndexer extends Plugin {
         const imports = this.parseImports(file, projectPath);
         totalImportsParsed += imports.length;
         for (const importFile of imports) {
-          // Store for later edge creation
+          // Store for later edge creation with semantic ID format
+          const importRelativePath = relative(projectPath, importFile);
+          const importSemanticId = `${importRelativePath}->global->MODULE->module`;
           pendingImports.push({
             src: moduleNode.id,
-            dst: `${importFile}:MODULE:${importFile}:0`
+            dst: importSemanticId
           });
 
           if (!processed.has(importFile)) {
@@ -251,14 +255,16 @@ export class IncrementalModuleIndexer extends Plugin {
         }
 
         if (processed.size % 10 === 0) {
-          process.stdout.write(`\r   📦 Indexed ${processed.size} modules (${queue.length} in queue)...`);
+          logger.debug('Indexing progress', { indexed: processed.size, queueLength: queue.length });
         }
       }
 
-      console.log(`\r   ✅ Indexed ${processed.size} modules\n`);
-      console.log(`   📥 Parsed ${totalImportsParsed} import specifiers (unresolved: ${unresolvedImports})`);
-      console.log(`   🔗 Pending IMPORTS edges to create: ${pendingImports.length}\n`);
-      console.log(`   📊 Creating IMPORTS edges...\n`);
+      logger.info('Modules indexed', { count: processed.size });
+      logger.debug('Import statistics', {
+        totalImportsParsed,
+        unresolvedImports,
+        pendingEdges: pendingImports.length
+      });
 
       // Now create all IMPORTS edges after all MODULE nodes exist
       for (const { src, dst } of pendingImports) {
@@ -271,8 +277,11 @@ export class IncrementalModuleIndexer extends Plugin {
         edgesCreated++;
       }
 
-      console.log(`   📊 Created ${nodesCreated} MODULE nodes and ${edgesCreated} edges`);
-      console.log(`   📈 IMPORTS edges created: ${pendingImports.length}\n`);
+      logger.info('Indexing complete', {
+        nodesCreated,
+        edgesCreated,
+        importsEdgesCreated: pendingImports.length
+      });
 
       return createSuccessResult(
         { nodes: nodesCreated, edges: edgesCreated },
@@ -280,7 +289,7 @@ export class IncrementalModuleIndexer extends Plugin {
       );
 
     } catch (error) {
-      console.error(`[IncrementalModuleIndexer] Error:`, error);
+      logger.error('Indexing failed', { error });
       return createErrorResult(error as Error);
     }
   }

package/src/plugins/indexing/JSModuleIndexer.ts

@@ -4,13 +4,14 @@
  */
 
 import { readFileSync, existsSync } from 'fs';
-import { join, resolve, dirname } from 'path';
+import { join, resolve, dirname, relative, basename } from 'path';
 import { createHash } from 'crypto';
-import { Plugin, createSuccessResult, createErrorResult } from '../Plugin.js';
+import { Plugin, createErrorResult } from '../Plugin.js';
 import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
 // @ts-expect-error - no type declarations for node-source-walk
 import Walker from 'node-source-walk';
 import { NodeFactory } from '../../core/NodeFactory.js';
+import { LanguageError } from '../../errors/GrafemaError.js';
 
 /**
  * Manifest with service info
@@ -21,6 +22,10 @@ interface IndexerManifest {
     id: string;
     name: string;
     path: string;
+    metadata?: {
+      entrypoint?: string;
+      [key: string]: unknown;
+    };
   };
 }
 
@@ -74,7 +79,9 @@ export class JSModuleIndexer extends Plugin {
 
   constructor() {
     super();
-    this.walker = new Walker();
+    this.walker = new Walker({
+      plugins: ['jsx', 'typescript']
+    });
     this.cache = new Map(); // Кеш зависимостей файла
     this.testPatterns = DEFAULT_TEST_PATTERNS;
     this.markTestFiles = true; // Default: enabled
@@ -208,26 +215,30 @@ export class JSModuleIndexer extends Plugin {
   }
 
   async execute(context: PluginContext): Promise<PluginResult> {
+    const logger = this.log(context);
     try {
       const { graph, onProgress, config } = context;
       const manifest = context.manifest as IndexerManifest | undefined;
       const projectPath = manifest?.projectPath ?? '';
       const service = manifest?.service ?? { id: '', name: '', path: '' };
 
+      // Collect parse errors to report (REG-147)
+      const parseErrors: Error[] = [];
+
       // Check config for test file marking
       if ((config as { analysis?: { tests?: { markTestFiles?: boolean } } })?.analysis?.tests?.markTestFiles === false) {
         this.markTestFiles = false;
       }
 
-      const entrypoint = service.path;
-      // const pkgPath = join(projectPath, 'pkg');
+      // Use metadata.entrypoint if available (from config services), otherwise fall back to path
+      const entrypoint = service.metadata?.entrypoint || service.path;
 
       // Резолвим entrypoint относительно projectPath
       const absoluteEntrypoint = entrypoint.startsWith('/')
         ? entrypoint
         : join(projectPath, entrypoint);
 
-      console.log(`[JSModuleIndexer] Building dependency tree from ${service.name}`);
+      logger.info('Building dependency tree', { service: service.name });
 
       // DFS через стек (как в file2host.js)
       const visited = new Set<string>();
@@ -261,37 +272,55 @@ export class JSModuleIndexer extends Plugin {
           lastProgressReport = visited.size;
         }
 
-        console.log(`[JSModuleIndexer] Processing: ${currentFile.replace(projectPath, '')} (depth ${depth})`);
+        logger.debug('Processing file', { file: currentFile.replace(projectPath, ''), depth });
 
         if (depth > MAX_DEPTH) {
-          console.log(`[JSModuleIndexer] Max depth ${MAX_DEPTH} reached at ${currentFile}`);
+          logger.warn('Max depth reached', { maxDepth: MAX_DEPTH, file: currentFile });
           continue;
         }
 
         // Парсим зависимости
         const deps = this.processFile(currentFile, projectPath);
-        console.log(`[JSModuleIndexer] Found ${deps instanceof Error ? 0 : deps.length} dependencies in ${currentFile.replace(projectPath, '')}`);
+        logger.debug('Found dependencies', { file: currentFile.replace(projectPath, ''), count: deps instanceof Error ? 0 : deps.length });
 
         if (deps instanceof Error) {
           if (!deps.message.includes('ENOENT')) {
-            console.log(`[JSModuleIndexer] Error parsing ${currentFile}: ${deps.message}`);
+            const relativePath = relative(projectPath, currentFile) || basename(currentFile);
+            const error = new LanguageError(
+              `Failed to parse ${relativePath}: ${deps.message}`,
+              'ERR_PARSE_FAILURE',
+              {
+                filePath: currentFile,
+                phase: 'INDEXING',
+                plugin: 'JSModuleIndexer',
+              },
+              'Check file syntax or ensure the file is a supported JavaScript/TypeScript file'
+            );
+            parseErrors.push(error);
+            logger.debug('Parse error', { file: currentFile, error: deps.message });
           }
           continue;
         }
 
-        // Создаём MODULE ноду для текущего файла
+        // Создаём MODULE ноду для текущего файла с semantic ID
         const fileHash = this.calculateFileHash(currentFile);
-        const moduleId = `MODULE:${fileHash}`; // StableID-based for deduplication
+        const relativePath = relative(projectPath, currentFile) || basename(currentFile);
+        const semanticId = `${relativePath}->global->MODULE->module`;
 
-        // Используем NodeFactory для создания MODULE ноды
-        // ВСЕГДА создаём ноду в графе (граф может быть пустой после force)
+        // Construct MODULE node manually to preserve absolute file path for analyzers
         const isTest = this.isTestFile(currentFile);
-        const moduleNode = NodeFactory.createModule(currentFile, projectPath, {
-          contentHash: fileHash ?? undefined,
+        const moduleNode = {
+          id: semanticId,
+          type: 'MODULE' as const,
+          name: relativePath,
+          file: currentFile, // Keep absolute path for file reading in analyzers
+          line: 0,
+          contentHash: fileHash || '',
           isTest
-        });
+        };
+        const moduleId = moduleNode.id;
 
-        console.log(`[JSModuleIndexer] Creating MODULE node: ${moduleNode.id}`);
+        logger.debug('Creating MODULE node', { moduleId: moduleNode.id });
         await graph.addNode(moduleNode);
         nodesCreated++;
 
@@ -306,25 +335,26 @@ export class JSModuleIndexer extends Plugin {
         for (const dep of deps) {
           if (dep.startsWith('package::')) {
             // npm пакет - игнорируем пока
-            console.log(`[JSModuleIndexer]   Skipping npm package: ${dep}`);
+            logger.debug('Skipping npm package', { package: dep });
             continue;
           }
 
           const resolvedDep = this.resolveModulePath(dep);
-          console.log(`[JSModuleIndexer]   Resolved: ${dep} -> ${resolvedDep.replace(projectPath, '')}`);
+          logger.debug('Resolved dependency', { from: dep, to: resolvedDep.replace(projectPath, '') });
 
           // Добавляем в стек если ещё не посещали
           if (!visited.has(resolvedDep)) {
             visited.add(resolvedDep);
             stack.push({ file: resolvedDep, depth: depth + 1 });
-            console.log(`[JSModuleIndexer]   Added to stack (depth ${depth + 1})`);
+            logger.debug('Added to stack', { depth: depth + 1 });
           } else {
-            console.log(`[JSModuleIndexer]   Already visited, skipping`);
+            logger.debug('Already visited, skipping', { file: resolvedDep });
           }
 
           // Queue DEPENDS_ON edges for later (after all nodes exist)
-          const depHash = this.calculateFileHash(resolvedDep);
-          const depModuleId = `MODULE:${depHash}`;
+          // Use semantic ID format for dependency reference
+          const depRelativePath = relative(projectPath, resolvedDep) || basename(resolvedDep);
+          const depModuleId = `${depRelativePath}->global->MODULE->module`;
           pendingDependsOnEdges.push({
             src: moduleId,
             dst: depModuleId,
@@ -342,9 +372,11 @@ export class JSModuleIndexer extends Plugin {
 
       // Warning if hit MAX_MODULES limit
       if (visited.size >= MAX_MODULES) {
-        console.warn(`[JSModuleIndexer] ⚠️  ${service.name} hit MAX_MODULES limit (${MAX_MODULES})!`);
-        console.warn(`[JSModuleIndexer]    This service may be pulling in too many dependencies.`);
-        console.warn(`[JSModuleIndexer]    Unprocessed files in stack: ${stack.length}`);
+        logger.warn('Hit MAX_MODULES limit', {
+          service: service.name,
+          limit: MAX_MODULES,
+          unprocessedInStack: stack.length
+        });
       }
 
       // Final progress report
@@ -359,15 +391,23 @@ export class JSModuleIndexer extends Plugin {
         });
       }
 
-      console.log(`[JSModuleIndexer] ${service.name}: ${nodesCreated} modules, ${visited.size} total in tree`);
-
-      return createSuccessResult(
-        { nodes: nodesCreated, edges: edgesCreated },
-        { totalModules: visited.size }
-      );
+      logger.info('Indexing complete', {
+        service: service.name,
+        modulesCreated: nodesCreated,
+        totalInTree: visited.size
+      });
+
+      // Return result with parse errors (REG-147)
+      return {
+        success: true,
+        created: { nodes: nodesCreated, edges: edgesCreated },
+        errors: parseErrors,
+        warnings: [],
+        metadata: { totalModules: visited.size },
+      };
 
     } catch (error) {
-      console.error(`[JSModuleIndexer] Error:`, error);
+      logger.error('Indexing failed', { error });
       return createErrorResult(error as Error);
     }
   }