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

package/src/plugins/analysis/ast/visitors/TypeScriptVisitor.ts

@@ -26,11 +26,14 @@ import type {
   EnumDeclarationInfo,
   EnumMemberInfo
 } from '../types.js';
+import { ScopeTracker } from '../../../../core/ScopeTracker.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: unknown): string {
+export function typeNodeToString(node: unknown): string {
   if (!node || typeof node !== 'object') return 'unknown';
 
   const typeNode = node as { type: string; [key: string]: unknown };
@@ -97,8 +100,16 @@ function typeNodeToString(node: unknown): string {
 }
 
 export class TypeScriptVisitor extends ASTVisitor {
-  constructor(module: VisitorModule, collections: VisitorCollections) {
+  private scopeTracker?: 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: VisitorModule, collections: VisitorCollections, scopeTracker?: ScopeTracker) {
     super(module, collections);
+    this.scopeTracker = scopeTracker;
   }
 
   getHandlers(): VisitorHandlers {
@@ -108,6 +119,7 @@ export class TypeScriptVisitor extends ASTVisitor {
       typeAliases,
       enums
     } = this.collections;
+    const scopeTracker = this.scopeTracker;
 
     return {
       TSInterfaceDeclaration: (path: NodePath) => {
@@ -115,7 +127,12 @@ export class TypeScriptVisitor extends ASTVisitor {
         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: string | undefined;
+        if (scopeTracker) {
+          interfaceSemanticId = computeSemanticId('INTERFACE', interfaceName, scopeTracker.getContext());
+        }
 
         // Extract extends
         const extendsNames: string[] = [];
@@ -156,12 +173,12 @@ export class TypeScriptVisitor extends ASTVisitor {
         }
 
         (interfaces as InterfaceDeclarationInfo[]).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
         });
@@ -172,18 +189,23 @@ 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: string | undefined;
+        if (scopeTracker) {
+          typeSemanticId = computeSemanticId('TYPE', typeName, scopeTracker.getContext());
+        }
 
         // Extract the type being aliased
         const aliasOf = typeNodeToString(node.typeAnnotation);
 
         (typeAliases as TypeAliasInfo[]).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
         });
       },
@@ -193,7 +215,12 @@ 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: string | undefined;
+        if (scopeTracker) {
+          enumSemanticId = computeSemanticId('ENUM', enumName, scopeTracker.getContext());
+        }
 
         // Extract members
         const members: EnumMemberInfo[] = [];
@@ -220,12 +247,12 @@ export class TypeScriptVisitor extends ASTVisitor {
         }
 
         (enums as EnumDeclarationInfo[]).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/src/plugins/analysis/ast/visitors/VariableVisitor.ts

@@ -17,6 +17,9 @@ import type {
 import type { NodePath } from '@babel/traverse';
 import { ASTVisitor, type VisitorModule, type VisitorCollections, type VisitorHandlers, type CounterRef } from './ASTVisitor.js';
 import { ExpressionEvaluator } from '../ExpressionEvaluator.js';
+import { ScopeTracker } from '../../../../core/ScopeTracker.js';
+import { IdGenerator } from '../IdGenerator.js';
+import { NodeFactory } from '../../../../core/NodeFactory.js';
 
 /**
  * Variable info extracted from pattern
@@ -26,6 +29,7 @@ export interface VariableInfo {
   loc: { start: { line: number; column: number } };
   propertyPath?: string[];
   arrayIndex?: number;
+  isRest?: boolean;
 }
 
 /**
@@ -44,7 +48,10 @@ export type TrackVariableAssignmentCallback = (
   line: number,
   literals: unknown[],
   variableAssignments: unknown[],
-  literalCounterRef: CounterRef
+  literalCounterRef: CounterRef,
+  objectLiterals: unknown[],
+  objectProperties: unknown[],
+  objectLiteralCounterRef: CounterRef
 ) => void;
 
 /**
@@ -97,25 +104,100 @@ interface VariableAssignmentInfo {
   file?: string;
 }
 
+/**
+ * Call info extracted from CallExpression (REG-223)
+ */
+interface CallInfo {
+  line: number;
+  column: number;
+  name: string;
+  isMethodCall: boolean;
+}
+
 export class VariableVisitor extends ASTVisitor {
   private extractVariableNamesFromPattern: ExtractVariableNamesCallback;
   private trackVariableAssignment: TrackVariableAssignmentCallback;
+  private scopeTracker?: ScopeTracker;
+
+  /**
+   * Recursively unwrap AwaitExpression to get the underlying expression.
+   * await await fetch() -> fetch() (REG-223)
+   */
+  private unwrapAwaitExpression(node: Node): Node {
+    if (node.type === 'AwaitExpression' && (node as { argument?: Node }).argument) {
+      return this.unwrapAwaitExpression((node as { argument: Node }).argument);
+    }
+    return node;
+  }
+
+  /**
+   * Check if expression is CallExpression or AwaitExpression wrapping a call. (REG-223)
+   */
+  private isCallOrAwaitExpression(node: Node): boolean {
+    const unwrapped = this.unwrapAwaitExpression(node);
+    return unwrapped.type === 'CallExpression';
+  }
+
+  /**
+   * Extract call site information from CallExpression. (REG-223)
+   * Returns null if not a valid CallExpression.
+   */
+  private extractCallInfo(node: Node): CallInfo | null {
+    if (node.type !== 'CallExpression') {
+      return null;
+    }
+
+    const callExpr = node as { callee: Node; loc?: { start: { line: number; column: number } } };
+    const callee = callExpr.callee;
+    let name: string;
+    let isMethodCall = false;
+
+    // Direct call: fetchUser()
+    if (callee.type === 'Identifier') {
+      name = (callee as Identifier).name;
+    }
+    // Method call: obj.fetchUser() or arr.map()
+    else if (callee.type === 'MemberExpression') {
+      isMethodCall = true;
+      const memberExpr = callee as { object: Node; property: Node };
+      const objectName = memberExpr.object.type === 'Identifier'
+        ? (memberExpr.object as Identifier).name
+        : (memberExpr.object.type === 'ThisExpression' ? 'this' : 'unknown');
+      const methodName = memberExpr.property.type === 'Identifier'
+        ? (memberExpr.property as Identifier).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: VisitorModule,
     collections: VisitorCollections,
     extractVariableNamesFromPattern: ExtractVariableNamesCallback,
-    trackVariableAssignment: TrackVariableAssignmentCallback
+    trackVariableAssignment: TrackVariableAssignmentCallback,
+    scopeTracker?: ScopeTracker
   ) {
     super(module, collections);
     this.extractVariableNamesFromPattern = extractVariableNamesFromPattern;
     this.trackVariableAssignment = trackVariableAssignment;
+    this.scopeTracker = scopeTracker;
   }
 
   getHandlers(): VisitorHandlers {
@@ -124,12 +206,22 @@ export class VariableVisitor extends ASTVisitor {
     const classInstantiations = this.collections.classInstantiations ?? [];
     const literals = (this.collections.literals ?? []) as unknown[];
     const variableAssignments = this.collections.variableAssignments ?? [];
+    const scopes = (this.collections.scopes ?? []) as unknown[];
     const varDeclCounterRef = (this.collections.varDeclCounterRef ?? { value: 0 }) as CounterRef;
     const literalCounterRef = (this.collections.literalCounterRef ?? { value: 0 }) as CounterRef;
+    const scopeCounterRef = (this.collections.scopeCounterRef ?? { value: 0 }) as CounterRef;
+    // Object literal tracking collections (REG-328)
+    const objectLiterals = (this.collections.objectLiterals ?? []) as unknown[];
+    const objectProperties = (this.collections.objectProperties ?? []) as unknown[];
+    const objectLiteralCounterRef = (this.collections.objectLiteralCounterRef ?? { value: 0 }) as CounterRef;
+    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<unknown>();
+
     return {
       VariableDeclaration: (path: NodePath) => {
         // Only module-level variables
@@ -138,6 +230,41 @@ export class VariableVisitor extends ASTVisitor {
           const varNode = path.node as VariableDeclaration;
           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 as {left?: unknown}).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 as { type: string; loc?: { start: { line: number } } };
+            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 as { id: string; type: string; scopeType: string; semanticId: string; file: string; line: number; parentScopeId: string }[]).push({
+              id: scopeId,
+              type: 'SCOPE',
+              scopeType,
+              semanticId,
+              file: module.file,
+              line,
+              parentScopeId: module.id
+            });
+          }
+
           varNode.declarations.forEach((declarator: VariableDeclarator) => {
             // Extract all variable names from the pattern (handles destructuring)
             const variables = extractVariableNamesFromPattern(declarator.id);
@@ -147,13 +274,22 @@ export class VariableVisitor extends ASTVisitor {
               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);
+              // 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 varId = shouldBeConstant
-                ? `CONSTANT#${varInfo.name}#${module.file}#${varInfo.loc.start.line}:${varInfo.loc.start.column}:${(varDeclCounterRef as CounterRef).value++}`
-                : `VARIABLE#${varInfo.name}#${module.file}#${varInfo.loc.start.line}:${varInfo.loc.start.column}:${(varDeclCounterRef as CounterRef).value++}`;
+              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 as CounterRef
+              );
 
               if (shouldBeConstant) {
                 // CONSTANT node
@@ -198,64 +334,173 @@ 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 as Identifier).name
-                    : 'expr';
-                  let expressionPath = initName;
-
-                  if (varInfo.propertyPath) {
-                    expressionPath = `${initName}.${varInfo.propertyPath.join('.')}`;
-                  } else if (varInfo.arrayIndex !== undefined) {
-                    expressionPath = `${initName}[${varInfo.arrayIndex}]`;
-                  }
+              // For loop variables, the "init" is the right side of for...of/for...in
+              const initExpression = isLoopVariable
+                ? (parent as {right?: Node}).right
+                : declarator.init;
 
-                  const expressionId = `EXPRESSION#${expressionPath}#${module.file}#${varInfo.loc.start.line}:${varInfo.loc.start.column}`;
-
-                  // Create EXPRESSION node representing the property access
-                  (literals as LiteralExpressionInfo[]).push({
-                    id: expressionId,
-                    type: 'EXPRESSION',
-                    expressionType: varInfo.propertyPath ? 'MemberExpression' : 'ArrayAccess',
-                    path: expressionPath,
-                    baseName: initName,
-                    propertyPath: varInfo.propertyPath || null,
-                    arrayIndex: varInfo.arrayIndex,
+              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 as Identifier).name;
+                  (variableAssignments as unknown[]).push({
+                    variableId: varId,
+                    sourceType: 'DERIVES_FROM_VARIABLE',
+                    sourceName,
                     file: module.file,
                     line: varInfo.loc.start.line
                   });
+                }
+                // 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 as Identifier).name;
+                    const expressionLine = varInfo.loc.start.line;
 
-                  // Create ASSIGNED_FROM edge: VARIABLE -> EXPRESSION
-                  (variableAssignments as VariableAssignmentInfo[]).push({
-                    variableId: varId,
-                    sourceId: expressionId,
-                    sourceType: 'EXPRESSION'
-                  });
+                    // Handle rest elements specially - create edge to whole source
+                    if (varInfo.isRest) {
+                      (variableAssignments as unknown[]).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('.')}`;
+                    }
 
-                  // Also create DERIVES_FROM edge: EXPRESSION -> base variable (if identifier)
-                  if (declarator.init.type === 'Identifier') {
-                    (variableAssignments as VariableAssignmentInfo[]).push({
-                      variableId: expressionId,
-                      sourceId: null, // Will be resolved by name
-                      sourceName: (declarator.init as Identifier).name,
-                      sourceType: 'DERIVES_FROM_VARIABLE',
-                      file: module.file
+                    // Generate expression ID (matches GraphBuilder expectations)
+                    const expressionId = `${module.file}:EXPRESSION:MemberExpression:${expressionLine}:${expressionColumn}`;
+
+                    // Determine property for display
+                    let property: string;
+                    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 as unknown[]).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 as unknown[]).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: string;
+                    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 as unknown[]).push({
+                      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,
+                    initExpression,
                     varId,
                     varInfo.name,
                     module,
                     varInfo.loc.start.line,
                     literals,
                     variableAssignments,
-                    literalCounterRef as CounterRef
+                    literalCounterRef as CounterRef,
+                    objectLiterals,
+                    objectProperties,
+                    objectLiteralCounterRef
                   );
                 }
               }

package/src/plugins/discovery/MonorepoServiceDiscovery.ts

@@ -57,10 +57,11 @@ export class MonorepoServiceDiscovery extends DiscoveryPlugin {
   }
 
   async execute(context: PluginContext): Promise<PluginResult> {
+    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(
@@ -71,7 +72,7 @@ export class MonorepoServiceDiscovery extends DiscoveryPlugin {
     try {
       const services: ServiceInfo[] = [];
       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);

package/src/plugins/discovery/SimpleProjectDiscovery.ts

@@ -11,6 +11,7 @@ import { join } from 'path';
 import { NodeFactory } from '../../core/NodeFactory.js';
 import { Plugin, createSuccessResult, createErrorResult } from '../Plugin.js';
 import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+import { resolveSourceEntrypoint } from './resolveSourceEntrypoint.js';
 
 /**
  * Service info returned in metadata
@@ -33,6 +34,7 @@ interface PackageJson {
   name?: string;
   version?: string;
   main?: string;
+  source?: string;
   description?: string;
   dependencies?: Record<string, string>;
 }
@@ -70,7 +72,10 @@ export class SimpleProjectDiscovery extends Plugin {
     try {
       const packageJson: 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, {