@grafema/core 0.1.0-alpha.5 → 0.2.0-beta

package/src/plugins/enrichment/ValueDomainAnalyzer.ts

@@ -17,6 +17,15 @@ import { Plugin, createSuccessResult } from '../Plugin.js';
 import type { PluginMetadata, PluginContext, PluginResult } from '../Plugin.js';
 import type { NodeRecord } from '@grafema/types';
 import type { EdgeRecord } from '@grafema/types';
+import {
+  traceValues,
+  aggregateValues,
+  NONDETERMINISTIC_PATTERNS,
+  NONDETERMINISTIC_OBJECTS,
+} from '../../queries/traceValues.js';
+
+// Re-export for backward compatibility
+export { NONDETERMINISTIC_PATTERNS, NONDETERMINISTIC_OBJECTS };
 
 interface ComputedCallNode {
   id: string;
@@ -42,22 +51,6 @@ interface VariableNode {
   [key: string]: unknown;
 }
 
-interface ExpressionNode {
-  id: string;
-  type: string;
-  name?: string;
-  file?: string;
-  line?: number;
-  expressionType?: string;
-  object?: string;
-  property?: string;
-  attrs?: {
-    expressionType?: string;
-    object?: string;
-    property?: string;
-  };
-}
-
 interface ScopeNode {
   id: string;
   type: string;
@@ -65,7 +58,6 @@ interface ScopeNode {
   file?: string;
   line?: number;
   originalId?: string;
-  stableId?: string;
   parentScopeId?: string;
   constraints?: Constraint[];
 }
@@ -90,17 +82,13 @@ interface ValueSetAtNodeResult extends ValueSetResult {
   globalHasUnknown: boolean;
 }
 
-interface NondeterministicPattern {
-  object: string;
-  property: string;
-}
-
 interface Graph {
   queryNodes(filter: { nodeType: string }): AsyncIterable<NodeRecord>;
   getNode(id: string): Promise<NodeRecord | null>;
   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 {
@@ -116,37 +104,6 @@ interface ProgressCallback {
 export class ValueDomainAnalyzer extends Plugin {
   static MAX_DEPTH = 10; // Maximum depth for tracing
 
-  // Nondeterministic MemberExpression patterns
-  // object.property patterns that are external/user input
-  static NONDETERMINISTIC_PATTERNS: NondeterministicPattern[] = [
-    // Environment variables
-    { object: 'process', property: 'env' },
-    // HTTP request data (Express.js patterns)
-    { object: 'req', property: 'body' },
-    { object: 'req', property: 'query' },
-    { object: 'req', property: 'params' },
-    { object: 'req', property: 'headers' },
-    { object: 'req', property: 'cookies' },
-    { object: 'request', property: 'body' },
-    { object: 'request', property: 'query' },
-    { object: 'request', property: 'params' },
-    // Context patterns (Koa, etc.)
-    { object: 'ctx', property: 'request' },
-    { object: 'ctx', property: 'body' },
-    { object: 'ctx', property: 'query' },
-    { object: 'ctx', property: 'params' },
-  ];
-
-  // Nondeterministic object prefixes (any property access is nondeterministic)
-  static NONDETERMINISTIC_OBJECTS: string[] = [
-    'process.env',  // process.env.ANY_VAR
-    'req.body',     // req.body.userId
-    'req.query',    // req.query.filter
-    'req.params',   // req.params.id
-    'request.body',
-    'ctx.request',
-  ];
-
   get metadata(): PluginMetadata {
     return {
       name: 'ValueDomainAnalyzer',
@@ -154,17 +111,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 +140,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 +207,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 +258,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 +338,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;
         }
@@ -505,135 +465,69 @@ export class ValueDomainAnalyzer extends Plugin {
   }
 
   /**
-   * Check if an EXPRESSION node represents a nondeterministic source
-   */
-  isNondeterministicExpression(node: ExpressionNode): boolean {
-    const expressionType = node.expressionType || node.attrs?.expressionType;
-    if (expressionType !== 'MemberExpression') {
-      return false;
-    }
-
-    const object = node.object || node.attrs?.object;
-    const property = node.property || node.attrs?.property;
-
-    if (!object || !property) {
-      return false;
-    }
-
-    // Check exact patterns (object.property)
-    for (const pattern of ValueDomainAnalyzer.NONDETERMINISTIC_PATTERNS) {
-      if (object === pattern.object && property === pattern.property) {
-        return true;
-      }
-    }
-
-    // Check if object is a known nondeterministic prefix
-    // e.g., process.env.VAR where object is 'process.env'
-    for (const prefix of ValueDomainAnalyzer.NONDETERMINISTIC_OBJECTS) {
-      if (object === prefix || object.startsWith(prefix + '.')) {
-        return true;
-      }
-    }
-
-    return false;
-  }
-
-  /**
-   * Recursive value set tracing through ASSIGNED_FROM edges
+   * Recursive value set tracing through ASSIGNED_FROM edges.
+   * Delegates to shared traceValues utility (REG-244).
    */
   async traceValueSet(
     node: NodeRecord,
     graph: Graph,
-    visited: Set<string>,
+    _visited: Set<string>,
     depth: number
   ): Promise<ValueSetResult> {
-    const result: ValueSetResult = { values: [], hasUnknown: false };
-
-    // Cycle protection
-    if (visited.has(node.id)) {
-      return result;
-    }
-    visited.add(node.id);
-
-    // Depth protection
-    if (depth > ValueDomainAnalyzer.MAX_DEPTH) {
-      result.hasUnknown = true;
-      return result;
-    }
-
-    // Support both fields: nodeType (from getNode) and type (alias)
-    const nodeType = (node as { nodeType?: string; type?: string }).nodeType ||
-                     (node as { type?: string }).type;
-
-    // If it's a LITERAL - add value
-    if (nodeType === 'LITERAL') {
-      const value = (node as { value?: unknown }).value;
-      if (value !== undefined && value !== null) {
-        result.values.push(value);
-      }
-      return result;
-    }
-
-    // If it's a PARAMETER or nondeterministic source
-    if (nodeType === 'PARAMETER') {
-      result.hasUnknown = true;
-      return result;
-    }
-
-    // If it's a CALL - consider nondeterministic (for now)
-    if (nodeType === 'CALL') {
-      result.hasUnknown = true;
-      return result;
-    }
-
-    // If it's an EXPRESSION - check nondeterministic patterns
-    if (nodeType === 'EXPRESSION') {
-      if (this.isNondeterministicExpression(node as ExpressionNode)) {
-        result.hasUnknown = true;
-        return result;
-      }
-    }
+    // Create adapter from Graph interface to TraceValuesGraphBackend
+    const backend = {
+      getNode: async (id: string) => {
+        const n = await graph.getNode(id);
+        if (!n) return null;
+        return {
+          id: n.id,
+          type: (n as { type?: string }).type,
+          nodeType: (n as { nodeType?: string }).nodeType,
+          value: (n as { value?: unknown }).value,
+          file: (n as { file?: string }).file,
+          line: (n as { line?: number }).line,
+          expressionType: (n as { expressionType?: string }).expressionType,
+          object: (n as { object?: string }).object,
+          property: (n as { property?: string }).property,
+        };
+      },
+      getOutgoingEdges: async (nodeId: string, edgeTypes: string[] | null) => {
+        const edges = await graph.getOutgoingEdges(nodeId);
+        const filtered = edgeTypes === null
+          ? edges
+          : edges.filter(e => edgeTypes.includes(e.type));
+        return filtered.map(e => ({
+          src: (e as { src?: string; source_id?: string }).src ||
+               (e as { source_id?: string }).source_id || '',
+          dst: (e as { dst?: string; target_id?: string }).dst ||
+               (e as { target_id?: string }).target_id || '',
+          type: e.type,
+        }));
+      },
+      // REG-334: getIncomingEdges required for Promise tracing
+      getIncomingEdges: async (nodeId: string, edgeTypes: string[] | null) => {
+        const edges = await graph.getIncomingEdges(nodeId);
+        const filtered = edgeTypes === null
+          ? edges
+          : edges.filter(e => edgeTypes.includes(e.type));
+        return filtered.map(e => ({
+          src: (e as { src?: string; source_id?: string }).src ||
+               (e as { source_id?: string }).source_id || '',
+          dst: (e as { dst?: string; target_id?: string }).dst ||
+               (e as { target_id?: string }).target_id || '',
+          type: e.type,
+        }));
+      },
+    };
 
-    // Follow ASSIGNED_FROM and DERIVES_FROM edges
-    // DERIVES_FROM is used for template literals and other composite expressions
-    const outgoing = await graph.getOutgoingEdges(node.id);
-    // edgeType (from getOutgoingEdges) or edge_type (from other APIs)
-    const dataFlowEdges = outgoing.filter(e => {
-      const edgeType = (e as { edgeType?: string; edge_type?: string }).edgeType ||
-                       (e as { edge_type?: string }).edge_type;
-      return edgeType === 'ASSIGNED_FROM' || edgeType === 'DERIVES_FROM';
+    // Use shared utility
+    const traced = await traceValues(backend, node.id, {
+      maxDepth: ValueDomainAnalyzer.MAX_DEPTH - depth,
+      followDerivesFrom: true,
+      detectNondeterministic: true,
     });
 
-    if (dataFlowEdges.length === 0) {
-      // No sources - unknown
-      result.hasUnknown = true;
-      return result;
-    }
-
-    // Recursively trace each source
-    for (const edge of dataFlowEdges) {
-      // dst (from getOutgoingEdges) or target_id (from other APIs)
-      const targetId = (edge as { dst?: string; target_id?: string }).dst ||
-                       (edge as { target_id?: string }).target_id;
-      if (!targetId) continue;
-
-      const sourceNode = await graph.getNode(targetId);
-      if (!sourceNode) continue;
-
-      const sourceResult = await this.traceValueSet(
-        sourceNode,
-        graph,
-        visited,
-        depth + 1
-      );
-
-      sourceResult.values.forEach(v => result.values.push(v));
-      if (sourceResult.hasUnknown) {
-        result.hasUnknown = true;
-      }
-    }
-
-    return result;
+    return aggregateValues(traced);
   }
 
   /**
@@ -652,11 +546,7 @@ export class ValueDomainAnalyzer extends Plugin {
         // Check if this is a method of the right object
         // Simplified: check via incoming CONTAINS edges from CLASS
         const incoming = await graph.getIncomingEdges(node.id);
-        const containsEdges = incoming.filter(e => {
-          const edgeType = (e as { edgeType?: string; edge_type?: string }).edgeType ||
-                           (e as { edge_type?: string }).edge_type;
-          return edgeType === 'CONTAINS';
-        });
+        const containsEdges = incoming.filter(e => e.type === 'CONTAINS');
 
         for (const edge of containsEdges) {
           const sourceId = (edge as { src?: string; source_id?: string }).src ||
@@ -677,6 +567,136 @@ 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) {
+        if (edge.type !== 'FLOWS_INTO') continue;
+
+        const edgeKey = `${edge.src}->${edge.dst}:FLOWS_INTO`;
+        if (processedEdges.has(edgeKey)) continue;
+        processedEdges.add(edgeKey);
+
+        const mutationType = edge.metadata?.mutationType as string | undefined;
+        const computedPropertyVar = edge.metadata?.computedPropertyVar as string | undefined;
+
+        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);
     }
   }