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

package/dist/plugins/analysis/ast/visitors/TypeScriptVisitor.js

@@ -7,10 +7,12 @@
  * - TSEnumDeclaration
  */
 import { ASTVisitor } from './ASTVisitor.js';
+import { computeSemanticId } from '../../../../core/SemanticId.js';
+import { getLine, getColumn } from '../utils/location.js';
 /**
  * Extracts a string representation of a TypeScript type node
  */
-function typeNodeToString(node) {
+export function typeNodeToString(node) {
     if (!node || typeof node !== 'object')
         return 'unknown';
     const typeNode = node;
@@ -77,19 +79,31 @@ function typeNodeToString(node) {
     }
 }
 export class TypeScriptVisitor extends ASTVisitor {
-    constructor(module, collections) {
+    scopeTracker;
+    /**
+     * @param module - Current module being analyzed
+     * @param collections - Must contain interfaces, typeAliases, enums arrays
+     * @param scopeTracker - Optional ScopeTracker for semantic ID generation
+     */
+    constructor(module, collections, scopeTracker) {
         super(module, collections);
+        this.scopeTracker = scopeTracker;
     }
     getHandlers() {
         const { module } = this;
         const { interfaces, typeAliases, enums } = this.collections;
+        const scopeTracker = this.scopeTracker;
         return {
             TSInterfaceDeclaration: (path) => {
                 const node = path.node;
                 if (!node.id)
                     return;
                 const interfaceName = node.id.name;
-                const interfaceId = `INTERFACE#${interfaceName}#${module.file}#${node.loc.start.line}`;
+                // Generate semantic ID if scopeTracker available
+                let interfaceSemanticId;
+                if (scopeTracker) {
+                    interfaceSemanticId = computeSemanticId('INTERFACE', interfaceName, scopeTracker.getContext());
+                }
                 // Extract extends
                 const extendsNames = [];
                 if (node.extends && node.extends.length > 0) {
@@ -128,12 +142,12 @@ export class TypeScriptVisitor extends ASTVisitor {
                     }
                 }
                 interfaces.push({
-                    id: interfaceId,
+                    semanticId: interfaceSemanticId,
                     type: 'INTERFACE',
                     name: interfaceName,
                     file: module.file,
-                    line: node.loc.start.line,
-                    column: node.loc.start.column,
+                    line: getLine(node),
+                    column: getColumn(node),
                     extends: extendsNames.length > 0 ? extendsNames : undefined,
                     properties
                 });
@@ -143,16 +157,20 @@ export class TypeScriptVisitor extends ASTVisitor {
                 if (!node.id)
                     return;
                 const typeName = node.id.name;
-                const typeId = `TYPE#${typeName}#${module.file}#${node.loc.start.line}`;
+                // Generate semantic ID if scopeTracker available
+                let typeSemanticId;
+                if (scopeTracker) {
+                    typeSemanticId = computeSemanticId('TYPE', typeName, scopeTracker.getContext());
+                }
                 // Extract the type being aliased
                 const aliasOf = typeNodeToString(node.typeAnnotation);
                 typeAliases.push({
-                    id: typeId,
+                    semanticId: typeSemanticId,
                     type: 'TYPE',
                     name: typeName,
                     file: module.file,
-                    line: node.loc.start.line,
-                    column: node.loc.start.column,
+                    line: getLine(node),
+                    column: getColumn(node),
                     aliasOf
                 });
             },
@@ -161,7 +179,11 @@ export class TypeScriptVisitor extends ASTVisitor {
                 if (!node.id)
                     return;
                 const enumName = node.id.name;
-                const enumId = `ENUM#${enumName}#${module.file}#${node.loc.start.line}`;
+                // Generate semantic ID if scopeTracker available
+                let enumSemanticId;
+                if (scopeTracker) {
+                    enumSemanticId = computeSemanticId('ENUM', enumName, scopeTracker.getContext());
+                }
                 // Extract members
                 const members = [];
                 if (node.members) {
@@ -185,12 +207,12 @@ export class TypeScriptVisitor extends ASTVisitor {
                     }
                 }
                 enums.push({
-                    id: enumId,
+                    semanticId: enumSemanticId,
                     type: 'ENUM',
                     name: enumName,
                     file: module.file,
-                    line: node.loc.start.line,
-                    column: node.loc.start.column,
+                    line: getLine(node),
+                    column: getColumn(node),
                     isConst: node.const || false,
                     members
                 });

package/dist/plugins/analysis/ast/visitors/VariableVisitor.d.ts

@@ -8,6 +8,7 @@
  */
 import type { Node } from '@babel/types';
 import { ASTVisitor, type VisitorModule, type VisitorCollections, type VisitorHandlers, type CounterRef } from './ASTVisitor.js';
+import { ScopeTracker } from '../../../../core/ScopeTracker.js';
 /**
  * Variable info extracted from pattern
  */
@@ -21,6 +22,7 @@ export interface VariableInfo {
     };
     propertyPath?: string[];
     arrayIndex?: number;
+    isRest?: boolean;
 }
 /**
  * Callback type for extracting variable names from patterns
@@ -29,17 +31,33 @@ export type ExtractVariableNamesCallback = (pattern: Node) => VariableInfo[];
 /**
  * Callback type for tracking variable assignments
  */
-export type TrackVariableAssignmentCallback = (initNode: Node, variableId: string, variableName: string, module: VisitorModule, line: number, literals: unknown[], variableAssignments: unknown[], literalCounterRef: CounterRef) => void;
+export type TrackVariableAssignmentCallback = (initNode: Node, variableId: string, variableName: string, module: VisitorModule, line: number, literals: unknown[], variableAssignments: unknown[], literalCounterRef: CounterRef, objectLiterals: unknown[], objectProperties: unknown[], objectLiteralCounterRef: CounterRef) => void;
 export declare class VariableVisitor extends ASTVisitor {
     private extractVariableNamesFromPattern;
     private trackVariableAssignment;
+    private scopeTracker?;
+    /**
+     * Recursively unwrap AwaitExpression to get the underlying expression.
+     * await await fetch() -> fetch() (REG-223)
+     */
+    private unwrapAwaitExpression;
+    /**
+     * Check if expression is CallExpression or AwaitExpression wrapping a call. (REG-223)
+     */
+    private isCallOrAwaitExpression;
+    /**
+     * Extract call site information from CallExpression. (REG-223)
+     * Returns null if not a valid CallExpression.
+     */
+    private extractCallInfo;
     /**
      * @param module - Current module being analyzed
      * @param collections - Must contain arrays and counter refs
      * @param extractVariableNamesFromPattern - Helper for destructuring
      * @param trackVariableAssignment - Helper for data flow tracking
+     * @param scopeTracker - Optional ScopeTracker for semantic ID generation
      */
-    constructor(module: VisitorModule, collections: VisitorCollections, extractVariableNamesFromPattern: ExtractVariableNamesCallback, trackVariableAssignment: TrackVariableAssignmentCallback);
+    constructor(module: VisitorModule, collections: VisitorCollections, extractVariableNamesFromPattern: ExtractVariableNamesCallback, trackVariableAssignment: TrackVariableAssignmentCallback, scopeTracker?: ScopeTracker);
     getHandlers(): VisitorHandlers;
 }
 //# sourceMappingURL=VariableVisitor.d.ts.map

package/dist/plugins/analysis/ast/visitors/VariableVisitor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VariableVisitor.d.ts","sourceRoot":"","sources":["../../../../../src/plugins/analysis/ast/visitors/VariableVisitor.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAKV,IAAI,EACL,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,UAAU,EAAE,KAAK,aAAa,EAAE,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAE,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAGjI;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE;QAAE,KAAK,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAC;IACjD,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,MAAM,4BAA4B,GAAG,CAAC,OAAO,EAAE,IAAI,KAAK,YAAY,EAAE,CAAC;AAE7E;;GAEG;AACH,MAAM,MAAM,+BAA+B,GAAG,CAC5C,QAAQ,EAAE,IAAI,EACd,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,aAAa,EACrB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,OAAO,EAAE,EACnB,mBAAmB,EAAE,OAAO,EAAE,EAC9B,iBAAiB,EAAE,UAAU,KAC1B,IAAI,CAAC;AAoDV,qBAAa,eAAgB,SAAQ,UAAU;IAC7C,OAAO,CAAC,+BAA+B,CAA+B;IACtE,OAAO,CAAC,uBAAuB,CAAkC;IAEjE;;;;;OAKG;gBAED,MAAM,EAAE,aAAa,EACrB,WAAW,EAAE,kBAAkB,EAC/B,+BAA+B,EAAE,4BAA4B,EAC7D,uBAAuB,EAAE,+BAA+B;IAO1D,WAAW,IAAI,eAAe;CAmJ/B"}
+{"version":3,"file":"VariableVisitor.d.ts","sourceRoot":"","sources":["../../../../../src/plugins/analysis/ast/visitors/VariableVisitor.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAKV,IAAI,EACL,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,UAAU,EAAE,KAAK,aAAa,EAAE,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAE,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAEjI,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAIhE;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE;QAAE,KAAK,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAC;IACjD,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,MAAM,4BAA4B,GAAG,CAAC,OAAO,EAAE,IAAI,KAAK,YAAY,EAAE,CAAC;AAE7E;;GAEG;AACH,MAAM,MAAM,+BAA+B,GAAG,CAC5C,QAAQ,EAAE,IAAI,EACd,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,aAAa,EACrB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,OAAO,EAAE,EACnB,mBAAmB,EAAE,OAAO,EAAE,EAC9B,iBAAiB,EAAE,UAAU,EAC7B,cAAc,EAAE,OAAO,EAAE,EACzB,gBAAgB,EAAE,OAAO,EAAE,EAC3B,uBAAuB,EAAE,UAAU,KAChC,IAAI,CAAC;AA8DV,qBAAa,eAAgB,SAAQ,UAAU;IAC7C,OAAO,CAAC,+BAA+B,CAA+B;IACtE,OAAO,CAAC,uBAAuB,CAAkC;IACjE,OAAO,CAAC,YAAY,CAAC,CAAe;IAEpC;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAO7B;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAK/B;;;OAGG;IACH,OAAO,CAAC,eAAe;IAsCvB;;;;;;OAMG;gBAED,MAAM,EAAE,aAAa,EACrB,WAAW,EAAE,kBAAkB,EAC/B,+BAA+B,EAAE,4BAA4B,EAC7D,uBAAuB,EAAE,+BAA+B,EACxD,YAAY,CAAC,EAAE,YAAY;IAQ7B,WAAW,IAAI,eAAe;CAsT/B"}

package/dist/plugins/analysis/ast/visitors/VariableVisitor.js

@@ -8,19 +8,78 @@
  */
 import { ASTVisitor } from './ASTVisitor.js';
 import { ExpressionEvaluator } from '../ExpressionEvaluator.js';
+import { IdGenerator } from '../IdGenerator.js';
 export class VariableVisitor extends ASTVisitor {
     extractVariableNamesFromPattern;
     trackVariableAssignment;
+    scopeTracker;
+    /**
+     * Recursively unwrap AwaitExpression to get the underlying expression.
+     * await await fetch() -> fetch() (REG-223)
+     */
+    unwrapAwaitExpression(node) {
+        if (node.type === 'AwaitExpression' && node.argument) {
+            return this.unwrapAwaitExpression(node.argument);
+        }
+        return node;
+    }
+    /**
+     * Check if expression is CallExpression or AwaitExpression wrapping a call. (REG-223)
+     */
+    isCallOrAwaitExpression(node) {
+        const unwrapped = this.unwrapAwaitExpression(node);
+        return unwrapped.type === 'CallExpression';
+    }
+    /**
+     * Extract call site information from CallExpression. (REG-223)
+     * Returns null if not a valid CallExpression.
+     */
+    extractCallInfo(node) {
+        if (node.type !== 'CallExpression') {
+            return null;
+        }
+        const callExpr = node;
+        const callee = callExpr.callee;
+        let name;
+        let isMethodCall = false;
+        // Direct call: fetchUser()
+        if (callee.type === 'Identifier') {
+            name = callee.name;
+        }
+        // Method call: obj.fetchUser() or arr.map()
+        else if (callee.type === 'MemberExpression') {
+            isMethodCall = true;
+            const memberExpr = callee;
+            const objectName = memberExpr.object.type === 'Identifier'
+                ? memberExpr.object.name
+                : (memberExpr.object.type === 'ThisExpression' ? 'this' : 'unknown');
+            const methodName = memberExpr.property.type === 'Identifier'
+                ? memberExpr.property.name
+                : 'unknown';
+            name = `${objectName}.${methodName}`;
+        }
+        else {
+            return null;
+        }
+        return {
+            line: callExpr.loc?.start.line ?? 0,
+            column: callExpr.loc?.start.column ?? 0,
+            name,
+            isMethodCall
+        };
+    }
     /**
      * @param module - Current module being analyzed
      * @param collections - Must contain arrays and counter refs
      * @param extractVariableNamesFromPattern - Helper for destructuring
      * @param trackVariableAssignment - Helper for data flow tracking
+     * @param scopeTracker - Optional ScopeTracker for semantic ID generation
      */
-    constructor(module, collections, extractVariableNamesFromPattern, trackVariableAssignment) {
+    constructor(module, collections, extractVariableNamesFromPattern, trackVariableAssignment, scopeTracker) {
         super(module, collections);
         this.extractVariableNamesFromPattern = extractVariableNamesFromPattern;
         this.trackVariableAssignment = trackVariableAssignment;
+        this.scopeTracker = scopeTracker;
     }
     getHandlers() {
         const { module } = this;
@@ -28,10 +87,19 @@ export class VariableVisitor extends ASTVisitor {
         const classInstantiations = this.collections.classInstantiations ?? [];
         const literals = (this.collections.literals ?? []);
         const variableAssignments = this.collections.variableAssignments ?? [];
+        const scopes = (this.collections.scopes ?? []);
         const varDeclCounterRef = (this.collections.varDeclCounterRef ?? { value: 0 });
         const literalCounterRef = (this.collections.literalCounterRef ?? { value: 0 });
+        const scopeCounterRef = (this.collections.scopeCounterRef ?? { value: 0 });
+        // Object literal tracking collections (REG-328)
+        const objectLiterals = (this.collections.objectLiterals ?? []);
+        const objectProperties = (this.collections.objectProperties ?? []);
+        const objectLiteralCounterRef = (this.collections.objectLiteralCounterRef ?? { value: 0 });
+        const scopeTracker = this.scopeTracker;
         const extractVariableNamesFromPattern = this.extractVariableNamesFromPattern;
         const trackVariableAssignment = this.trackVariableAssignment;
+        // Track which loops we've already created scopes for
+        const processedLoops = new Set();
         return {
             VariableDeclaration: (path) => {
                 // Only module-level variables
@@ -39,6 +107,35 @@ export class VariableVisitor extends ASTVisitor {
                 if (!functionParent) {
                     const varNode = path.node;
                     const isConst = varNode.kind === 'const';
+                    // Check if this is a loop variable (for...of or for...in)
+                    const parent = path.parent;
+                    const isLoopVariable = (parent.type === 'ForOfStatement' || parent.type === 'ForInStatement')
+                        && parent.left === varNode;
+                    // If this is a loop variable, create the loop scope first (if not already created)
+                    if (isLoopVariable && !processedLoops.has(parent)) {
+                        processedLoops.add(parent);
+                        const loopNode = parent;
+                        const line = loopNode.loc?.start.line ?? 0;
+                        const scopeType = loopNode.type === 'ForOfStatement' ? 'for-of-loop' : 'for-in-loop';
+                        const trackerType = loopNode.type === 'ForOfStatement' ? 'for-of' : 'for-in';
+                        const scopeId = `SCOPE#${scopeType}#${module.file}#${line}:${scopeCounterRef.value++}`;
+                        // Enter scope in tracker BEFORE generating semantic ID
+                        if (scopeTracker) {
+                            scopeTracker.enterCountedScope(trackerType);
+                        }
+                        const semanticId = scopeTracker
+                            ? scopeTracker.getContext().scopePath.join('->')
+                            : scopeId;
+                        scopes.push({
+                            id: scopeId,
+                            type: 'SCOPE',
+                            scopeType,
+                            semanticId,
+                            file: module.file,
+                            line,
+                            parentScopeId: module.id
+                        });
+                    }
                     varNode.declarations.forEach((declarator) => {
                         // Extract all variable names from the pattern (handles destructuring)
                         const variables = extractVariableNamesFromPattern(declarator.id);
@@ -46,12 +143,13 @@ export class VariableVisitor extends ASTVisitor {
                             const literalValue = ExpressionEvaluator.extractLiteralValue(declarator.init);
                             const isLiteral = literalValue !== null;
                             const isNewExpression = declarator.init && declarator.init.type === 'NewExpression';
-                            // For const with literal or NewExpression create CONSTANT
-                            // For everything else - VARIABLE
-                            const shouldBeConstant = isConst && (isLiteral || isNewExpression);
-                            const varId = shouldBeConstant
-                                ? `CONSTANT#${varInfo.name}#${module.file}#${varInfo.loc.start.line}:${varInfo.loc.start.column}:${varDeclCounterRef.value++}`
-                                : `VARIABLE#${varInfo.name}#${module.file}#${varInfo.loc.start.line}:${varInfo.loc.start.column}:${varDeclCounterRef.value++}`;
+                            // Loop variables with const should be CONSTANT (they can't be reassigned in loop body)
+                            // Regular variables with const are CONSTANT only if initialized with literal or new expression
+                            const shouldBeConstant = isConst && (isLoopVariable || isLiteral || isNewExpression);
+                            const nodeType = shouldBeConstant ? 'CONSTANT' : 'VARIABLE';
+                            // Generate ID using centralized IdGenerator
+                            const idGenerator = new IdGenerator(scopeTracker);
+                            const varId = idGenerator.generate(nodeType, varInfo.name, module.file, varInfo.loc.start.line, varInfo.loc.start.column, varDeclCounterRef);
                             if (shouldBeConstant) {
                                 // CONSTANT node
                                 const constantData = {
@@ -92,53 +190,153 @@ export class VariableVisitor extends ASTVisitor {
                                 });
                             }
                             // Track assignment for data flow analysis
-                            if (declarator.init) {
-                                // Handle destructuring - create EXPRESSION for property path
-                                if (varInfo.propertyPath || varInfo.arrayIndex !== undefined) {
-                                    // Create EXPRESSION node for the property access
-                                    const initName = declarator.init.type === 'Identifier'
-                                        ? declarator.init.name
-                                        : 'expr';
-                                    let expressionPath = initName;
-                                    if (varInfo.propertyPath) {
-                                        expressionPath = `${initName}.${varInfo.propertyPath.join('.')}`;
-                                    }
-                                    else if (varInfo.arrayIndex !== undefined) {
-                                        expressionPath = `${initName}[${varInfo.arrayIndex}]`;
-                                    }
-                                    const expressionId = `EXPRESSION#${expressionPath}#${module.file}#${varInfo.loc.start.line}:${varInfo.loc.start.column}`;
-                                    // Create EXPRESSION node representing the property access
-                                    literals.push({
-                                        id: expressionId,
-                                        type: 'EXPRESSION',
-                                        expressionType: varInfo.propertyPath ? 'MemberExpression' : 'ArrayAccess',
-                                        path: expressionPath,
-                                        baseName: initName,
-                                        propertyPath: varInfo.propertyPath || null,
-                                        arrayIndex: varInfo.arrayIndex,
-                                        file: module.file,
-                                        line: varInfo.loc.start.line
-                                    });
-                                    // Create ASSIGNED_FROM edge: VARIABLE -> EXPRESSION
+                            // For loop variables, the "init" is the right side of for...of/for...in
+                            const initExpression = isLoopVariable
+                                ? parent.right
+                                : declarator.init;
+                            if (initExpression) {
+                                // For loop variables, create DERIVES_FROM edges instead of ASSIGNED_FROM
+                                // Loop variables derive their values from the collection (semantic difference)
+                                if (isLoopVariable && initExpression.type === 'Identifier') {
+                                    const sourceName = initExpression.name;
                                     variableAssignments.push({
                                         variableId: varId,
-                                        sourceId: expressionId,
-                                        sourceType: 'EXPRESSION'
+                                        sourceType: 'DERIVES_FROM_VARIABLE',
+                                        sourceName,
+                                        file: module.file,
+                                        line: varInfo.loc.start.line
                                     });
-                                    // Also create DERIVES_FROM edge: EXPRESSION -> base variable (if identifier)
-                                    if (declarator.init.type === 'Identifier') {
+                                }
+                                // Handle destructuring - create EXPRESSION for property path
+                                else if (varInfo.propertyPath || varInfo.arrayIndex !== undefined || varInfo.isRest) {
+                                    // Phase 1: Simple Identifier init expressions (REG-201)
+                                    if (initExpression.type === 'Identifier') {
+                                        const sourceBaseName = initExpression.name;
+                                        const expressionLine = varInfo.loc.start.line;
+                                        // Handle rest elements specially - create edge to whole source
+                                        if (varInfo.isRest) {
+                                            variableAssignments.push({
+                                                variableId: varId,
+                                                sourceType: 'VARIABLE',
+                                                sourceName: sourceBaseName,
+                                                line: expressionLine
+                                            });
+                                            return;
+                                        }
+                                        const expressionColumn = varInfo.loc.start.column;
+                                        // Build property path string
+                                        let fullPath = sourceBaseName;
+                                        if (varInfo.propertyPath && varInfo.propertyPath.length > 0) {
+                                            fullPath = `${sourceBaseName}.${varInfo.propertyPath.join('.')}`;
+                                        }
+                                        // Generate expression ID (matches GraphBuilder expectations)
+                                        const expressionId = `${module.file}:EXPRESSION:MemberExpression:${expressionLine}:${expressionColumn}`;
+                                        // Determine property for display
+                                        let property;
+                                        if (varInfo.propertyPath && varInfo.propertyPath.length > 0) {
+                                            property = varInfo.propertyPath[varInfo.propertyPath.length - 1];
+                                        }
+                                        else if (varInfo.arrayIndex !== undefined) {
+                                            property = String(varInfo.arrayIndex);
+                                        }
+                                        else {
+                                            property = '';
+                                        }
+                                        // Push assignment with full metadata for GraphBuilder (REG-201)
+                                        // GraphBuilder will create the EXPRESSION node from this metadata
+                                        variableAssignments.push({
+                                            variableId: varId,
+                                            sourceId: expressionId,
+                                            sourceType: 'EXPRESSION',
+                                            expressionType: 'MemberExpression',
+                                            object: sourceBaseName,
+                                            property: property,
+                                            computed: varInfo.arrayIndex !== undefined,
+                                            path: fullPath,
+                                            objectSourceName: sourceBaseName, // Use objectSourceName for DERIVES_FROM edge creation
+                                            propertyPath: varInfo.propertyPath || undefined,
+                                            arrayIndex: varInfo.arrayIndex,
+                                            file: module.file,
+                                            line: expressionLine,
+                                            column: expressionColumn
+                                        });
+                                    }
+                                    // Phase 2: CallExpression or AwaitExpression (REG-223)
+                                    else if (this.isCallOrAwaitExpression(initExpression)) {
+                                        const unwrapped = this.unwrapAwaitExpression(initExpression);
+                                        const callInfo = this.extractCallInfo(unwrapped);
+                                        if (!callInfo) {
+                                            // Unsupported call pattern (computed callee, etc.)
+                                            return;
+                                        }
+                                        const callRepresentation = `${callInfo.name}()`;
+                                        const expressionLine = varInfo.loc.start.line;
+                                        const expressionColumn = varInfo.loc.start.column;
+                                        // Handle rest elements - create direct CALL_SITE assignment
+                                        if (varInfo.isRest) {
+                                            variableAssignments.push({
+                                                variableId: varId,
+                                                sourceType: 'CALL_SITE',
+                                                callName: callInfo.name,
+                                                callLine: callInfo.line,
+                                                callColumn: callInfo.column,
+                                                callSourceLine: callInfo.line,
+                                                callSourceColumn: callInfo.column,
+                                                callSourceFile: module.file,
+                                                callSourceName: callInfo.name,
+                                                line: expressionLine
+                                            });
+                                            return;
+                                        }
+                                        // Generate expression ID (matches GraphBuilder expectations)
+                                        const expressionId = `${module.file}:EXPRESSION:MemberExpression:${expressionLine}:${expressionColumn}`;
+                                        // Determine property for display
+                                        let property;
+                                        if (varInfo.propertyPath && varInfo.propertyPath.length > 0) {
+                                            property = varInfo.propertyPath[varInfo.propertyPath.length - 1];
+                                        }
+                                        else if (varInfo.arrayIndex !== undefined) {
+                                            property = String(varInfo.arrayIndex);
+                                        }
+                                        else {
+                                            property = '';
+                                        }
+                                        // Build property path string: "fetchUser().data" or "fetchUser().user.name"
+                                        let fullPath = callRepresentation;
+                                        if (varInfo.propertyPath && varInfo.propertyPath.length > 0) {
+                                            fullPath = `${callRepresentation}.${varInfo.propertyPath.join('.')}`;
+                                        }
+                                        // Push assignment with call source metadata for GraphBuilder (REG-223)
                                         variableAssignments.push({
-                                            variableId: expressionId,
-                                            sourceId: null, // Will be resolved by name
-                                            sourceName: declarator.init.name,
-                                            sourceType: 'DERIVES_FROM_VARIABLE',
-                                            file: module.file
+                                            variableId: varId,
+                                            sourceId: expressionId,
+                                            sourceType: 'EXPRESSION',
+                                            expressionType: 'MemberExpression',
+                                            object: callRepresentation, // "fetchUser()" - display name
+                                            property: property,
+                                            computed: varInfo.arrayIndex !== undefined,
+                                            path: fullPath,
+                                            propertyPath: varInfo.propertyPath || undefined,
+                                            arrayIndex: varInfo.arrayIndex,
+                                            // Call source for DERIVES_FROM lookup (REG-223)
+                                            callSourceLine: callInfo.line,
+                                            callSourceColumn: callInfo.column,
+                                            callSourceFile: module.file,
+                                            callSourceName: callInfo.name,
+                                            sourceMetadata: {
+                                                sourceType: callInfo.isMethodCall ? 'method-call' : 'call'
+                                            },
+                                            file: module.file,
+                                            line: expressionLine,
+                                            column: expressionColumn
                                         });
                                     }
+                                    // Unsupported init type (MemberExpression without call, etc.)
+                                    // Skip silently
                                 }
                                 else {
                                     // Normal assignment tracking
-                                    trackVariableAssignment(declarator.init, varId, varInfo.name, module, varInfo.loc.start.line, literals, variableAssignments, literalCounterRef);
+                                    trackVariableAssignment(initExpression, varId, varInfo.name, module, varInfo.loc.start.line, literals, variableAssignments, literalCounterRef, objectLiterals, objectProperties, objectLiteralCounterRef);
                                 }
                             }
                         });

package/dist/plugins/discovery/MonorepoServiceDiscovery.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MonorepoServiceDiscovery.d.ts","sourceRoot":"","sources":["../../../src/plugins/discovery/MonorepoServiceDiscovery.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEvD,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAehF;;GAEG;AACH,UAAU,cAAe,SAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACtD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB;AAED,qBAAa,wBAAyB,SAAQ,eAAe;IAC3D,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,WAAW,CAAW;gBAElB,MAAM,GAAE,cAAmB;IAOvC,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;CA0D7D"}
+{"version":3,"file":"MonorepoServiceDiscovery.d.ts","sourceRoot":"","sources":["../../../src/plugins/discovery/MonorepoServiceDiscovery.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEvD,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAehF;;GAEG;AACH,UAAU,cAAe,SAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACtD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB;AAED,qBAAa,wBAAyB,SAAQ,eAAe;IAC3D,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,WAAW,CAAW;gBAElB,MAAM,GAAE,cAAmB;IAOvC,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;CA2D7D"}

package/dist/plugins/discovery/MonorepoServiceDiscovery.js

@@ -32,16 +32,17 @@ export class MonorepoServiceDiscovery extends DiscoveryPlugin {
         };
     }
     async execute(context) {
+        const logger = this.log(context);
         const { projectPath, graph } = context;
         const servicesPath = join(projectPath, this.servicesDir);
-        console.log(`[MonorepoServiceDiscovery] Looking for services in: ${servicesPath}`);
+        logger.debug('Looking for services', { servicesPath });
         if (!existsSync(servicesPath)) {
             return createErrorResult(new Error(`Services directory not found: ${servicesPath}`));
         }
         try {
             const services = [];
             const entries = readdirSync(servicesPath);
-            console.log(`[MonorepoServiceDiscovery] Found ${entries.length} entries`);
+            logger.debug('Found entries', { count: entries.length });
             for (const entry of entries) {
                 const fullPath = join(servicesPath, entry);
                 const stat = statSync(fullPath);

package/dist/plugins/discovery/SimpleProjectDiscovery.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SimpleProjectDiscovery.d.ts","sourceRoot":"","sources":["../../../src/plugins/discovery/SimpleProjectDiscovery.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,OAAO,EAAE,MAAM,EAA0C,MAAM,cAAc,CAAC;AAC9E,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AA2BhF,qBAAa,sBAAuB,SAAQ,MAAM;IAEhD,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;CA+C7D"}
+{"version":3,"file":"SimpleProjectDiscovery.d.ts","sourceRoot":"","sources":["../../../src/plugins/discovery/SimpleProjectDiscovery.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,OAAO,EAAE,MAAM,EAA0C,MAAM,cAAc,CAAC;AAC9E,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AA6BhF,qBAAa,sBAAuB,SAAQ,MAAM;IAEhD,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;CAkD7D"}

package/dist/plugins/discovery/SimpleProjectDiscovery.js

@@ -9,6 +9,7 @@ import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 import { NodeFactory } from '../../core/NodeFactory.js';
 import { Plugin, createSuccessResult, createErrorResult } from '../Plugin.js';
+import { resolveSourceEntrypoint } from './resolveSourceEntrypoint.js';
 export class SimpleProjectDiscovery extends Plugin {
     get metadata() {
         return {
@@ -36,7 +37,10 @@ export class SimpleProjectDiscovery extends Plugin {
         try {
             const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
             const serviceName = packageJson.name || 'unnamed-service';
-            const entrypoint = packageJson.main || 'index.js';
+            // Prefer TypeScript source over compiled output
+            const entrypoint = resolveSourceEntrypoint(projectPath, packageJson)
+                ?? packageJson.main
+                ?? 'index.js';
             // Используем NodeFactory для создания SERVICE ноды
             const serviceNode = NodeFactory.createService(serviceName, projectPath, {
                 discoveryMethod: 'simple',

package/dist/plugins/discovery/WorkspaceDiscovery.d.ts

@@ -0,0 +1,22 @@
+/**
+ * WorkspaceDiscovery - Discovery plugin for npm/pnpm/yarn/lerna workspaces
+ *
+ * Detects workspace configuration and creates SERVICE nodes for each package.
+ * Priority: 110 (higher than MonorepoServiceDiscovery at 100)
+ *
+ * Supports:
+ * - pnpm-workspace.yaml
+ * - package.json workspaces (npm/yarn)
+ * - lerna.json
+ */
+import { DiscoveryPlugin } from './DiscoveryPlugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+export declare class WorkspaceDiscovery extends DiscoveryPlugin {
+    get metadata(): PluginMetadata;
+    execute(context: PluginContext): Promise<PluginResult>;
+    /**
+     * Create SERVICE node from workspace package.
+     */
+    private createServiceNode;
+}
+//# sourceMappingURL=WorkspaceDiscovery.d.ts.map

package/dist/plugins/discovery/WorkspaceDiscovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkspaceDiscovery.d.ts","sourceRoot":"","sources":["../../../src/plugins/discovery/WorkspaceDiscovery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEvD,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAuBhF,qBAAa,kBAAmB,SAAQ,eAAe;IACrD,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IA4F5D;;OAEG;IACH,OAAO,CAAC,iBAAiB;CAmC1B"}