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

package/dist/plugins/indexing/IncrementalModuleIndexer.js

@@ -119,11 +119,12 @@ export class IncrementalModuleIndexer extends Plugin {
             return imports;
         }
         catch (err) {
-            console.error(`   ⚠️  Failed to parse imports from ${relative(projectRoot, filePath)}: ${err.message}`);
+            // Parse error will be logged by execute() when it needs logger context
             return [];
         }
     }
     async execute(context) {
+        const logger = this.log(context);
         try {
             const { manifest, graph } = context;
             // Cast manifest to expected shape
@@ -139,17 +140,18 @@ export class IncrementalModuleIndexer extends Plugin {
             let edgesCreated = 0;
             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();
                 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 = {
-                    id: `${file}:MODULE:${file}:0`,
+                    id: semanticId,
                     type: 'MODULE',
                     name: relativePath,
                     file: file,
@@ -169,10 +171,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)) {
                         queue.push(importFile);
@@ -209,13 +213,15 @@ export class IncrementalModuleIndexer extends Plugin {
                     // Ignore parse errors for unresolved count
                 }
                 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) {
                 await graph.addEdge({
@@ -226,12 +232,15 @@ 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 }, { filesScanned: processed.size });
         }
         catch (error) {
-            console.error(`[IncrementalModuleIndexer] Error:`, error);
+            logger.error('Indexing failed', { error });
             return createErrorResult(error);
         }
     }

package/dist/plugins/indexing/JSModuleIndexer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"JSModuleIndexer.d.ts","sourceRoot":"","sources":["../../../src/plugins/indexing/JSModuleIndexer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,EAAE,MAAM,EAA0C,MAAM,cAAc,CAAC;AAC9E,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AA2DhF,qBAAa,eAAgB,SAAQ,MAAM;IACzC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,KAAK,CAAgC;IAC7C,OAAO,CAAC,YAAY,CAAW;IAC/B,OAAO,CAAC,aAAa,CAAU;;IAU/B;;OAEG;IACH,OAAO,CAAC,UAAU;IAKlB,IAAI,QAAQ,IAAI,cAAc,CAU7B;IAED,OAAO,CAAC,iBAAiB;IASzB;;;;;;OAMG;IACH,OAAO,CAAC,WAAW;IAuEnB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAiBnB,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;CAoK7D"}
+{"version":3,"file":"JSModuleIndexer.d.ts","sourceRoot":"","sources":["../../../src/plugins/indexing/JSModuleIndexer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,EAAE,MAAM,EAAqB,MAAM,cAAc,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAgEhF,qBAAa,eAAgB,SAAQ,MAAM;IACzC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,KAAK,CAAgC;IAC7C,OAAO,CAAC,YAAY,CAAW;IAC/B,OAAO,CAAC,aAAa,CAAU;;IAY/B;;OAEG;IACH,OAAO,CAAC,UAAU;IAKlB,IAAI,QAAQ,IAAI,cAAc,CAU7B;IAED,OAAO,CAAC,iBAAiB;IASzB;;;;;;OAMG;IACH,OAAO,CAAC,WAAW;IAuEnB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAiBnB,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;CAqM7D"}

package/dist/plugins/indexing/JSModuleIndexer.js

@@ -3,12 +3,12 @@
  * Строит дерево зависимостей от entrypoint через DFS (как в file2host.js)
  */
 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';
 // @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';
 // Test file patterns (can be overridden in config)
 const DEFAULT_TEST_PATTERNS = [
     /[/\\]test[/\\]/, // /test/
@@ -27,7 +27,9 @@ export class JSModuleIndexer extends Plugin {
     markTestFiles;
     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
@@ -161,22 +163,25 @@ export class JSModuleIndexer extends Plugin {
         return path;
     }
     async execute(context) {
+        const logger = this.log(context);
         try {
             const { graph, onProgress, config } = context;
             const manifest = context.manifest;
             const projectPath = manifest?.projectPath ?? '';
             const service = manifest?.service ?? { id: '', name: '', path: '' };
+            // Collect parse errors to report (REG-147)
+            const parseErrors = [];
             // Check config for test file marking
             if (config?.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();
             const stack = [{ file: absoluteEntrypoint, depth: 0 }];
@@ -203,31 +208,44 @@ 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
-                // Используем NodeFactory для создания MODULE ноды
-                // ВСЕГДА создаём ноду в графе (граф может быть пустой после force)
+                const relativePath = relative(projectPath, currentFile) || basename(currentFile);
+                const semanticId = `${relativePath}->global->MODULE->module`;
+                // 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',
+                    name: relativePath,
+                    file: currentFile, // Keep absolute path for file reading in analyzers
+                    line: 0,
+                    contentHash: fileHash || '',
                     isTest
-                });
-                console.log(`[JSModuleIndexer] Creating MODULE node: ${moduleNode.id}`);
+                };
+                const moduleId = moduleNode.id;
+                logger.debug('Creating MODULE node', { moduleId: moduleNode.id });
                 await graph.addNode(moduleNode);
                 nodesCreated++;
                 // Always create SERVICE -> CONTAINS -> MODULE edge (even if module exists)
@@ -241,23 +259,24 @@ 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,
@@ -273,9 +292,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
             if (onProgress) {
@@ -288,11 +309,22 @@ export class JSModuleIndexer extends Plugin {
                     currentService: service.name
                 });
             }
-            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);
         }
     }

package/dist/plugins/indexing/RustModuleIndexer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RustModuleIndexer.d.ts","sourceRoot":"","sources":["../../../src/plugins/indexing/RustModuleIndexer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAUhF,qBAAa,iBAAkB,SAAQ,MAAM;IAC3C,OAAO,CAAC,YAAY,CAAW;;IAO/B,IAAI,QAAQ,IAAI,cAAc,CAU7B;IAED;;OAEG;IACH,OAAO,CAAC,UAAU;IAIlB;;OAEG;IACH,OAAO,CAAC,aAAa;IAyBrB;;;;;OAKG;IACH,OAAO,CAAC,gBAAgB;IAclB,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;CAiE7D"}
+{"version":3,"file":"RustModuleIndexer.d.ts","sourceRoot":"","sources":["../../../src/plugins/indexing/RustModuleIndexer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAUhF,qBAAa,iBAAkB,SAAQ,MAAM;IAC3C,OAAO,CAAC,YAAY,CAAW;;IAO/B,IAAI,QAAQ,IAAI,cAAc,CAU7B;IAED;;OAEG;IACH,OAAO,CAAC,UAAU;IAIlB;;OAEG;IACH,OAAO,CAAC,aAAa;IAyBrB;;;;;OAKG;IACH,OAAO,CAAC,gBAAgB;IAclB,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;CAkE7D"}

package/dist/plugins/indexing/RustModuleIndexer.js

@@ -84,6 +84,7 @@ export class RustModuleIndexer extends Plugin {
         return name;
     }
     async execute(context) {
+        const logger = this.log(context);
         const { manifest, graph, onProgress } = context;
         // Cast manifest to expected shape
         const typedManifest = manifest;
@@ -91,12 +92,12 @@ export class RustModuleIndexer extends Plugin {
         // Find rust-engine/src directory
         const rustRoot = resolve(projectPath, 'rust-engine/src');
         if (!existsSync(rustRoot)) {
-            console.log('[RustModuleIndexer] rust-engine/src not found, skipping');
+            logger.info('rust-engine/src not found, skipping');
             return createSuccessResult({ nodes: 0, edges: 0 }, { skipped: true });
         }
         // Discover all .rs files recursively
         const rsFiles = this.findRustFiles(rustRoot);
-        console.log(`[RustModuleIndexer] Found ${rsFiles.length} .rs files`);
+        logger.info('Found Rust files', { count: rsFiles.length });
         let nodesCreated = 0;
         const errors = [];
         for (const filePath of rsFiles) {
@@ -132,9 +133,9 @@ export class RustModuleIndexer extends Plugin {
             }
         }
         if (errors.length > 0) {
-            console.warn(`[RustModuleIndexer] ${errors.length} errors during indexing`);
+            logger.warn('Errors during indexing', { errorCount: errors.length });
         }
-        console.log(`[RustModuleIndexer] Indexed ${nodesCreated} Rust modules`);
+        logger.info('Rust modules indexed', { count: nodesCreated });
         return createSuccessResult({ nodes: nodesCreated, edges: 0 }, { errors: errors.length });
     }
 }

package/dist/plugins/indexing/ServiceDetector.d.ts

@@ -15,6 +15,11 @@ interface DetectorContext {
     graph: {
         addNode(node: NodeRecord): Promise<void>;
     };
+    logger?: {
+        info(message: string, data?: Record<string, unknown>): void;
+        debug(message: string, data?: Record<string, unknown>): void;
+        warn(message: string, data?: Record<string, unknown>): void;
+    };
 }
 export declare class ServiceDetector {
     name: string;
@@ -39,6 +44,11 @@ export declare class ServiceDetector {
     private createServiceFromDir;
     /**
      * Находит entry point сервиса
+     *
+     * Resolution priority:
+     * 1. TypeScript source (via resolveSourceEntrypoint)
+     * 2. package.json main field
+     * 3. Standard fallback candidates
      */
     private findEntryPoint;
 }

package/dist/plugins/indexing/ServiceDetector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ServiceDetector.d.ts","sourceRoot":"","sources":["../../../src/plugins/indexing/ServiceDetector.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEjD;;GAEG;AACH,UAAU,eAAe;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE;QACL,OAAO,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;KAC1C,CAAC;CACH;AAuBD,qBAAa,eAAe;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;;IAQjB;;OAEG;IACG,OAAO,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC;IA+CjE;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAgC3B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAWzB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAuC5B;;OAEG;IACH,OAAO,CAAC,cAAc;CA8BvB"}
+{"version":3,"file":"ServiceDetector.d.ts","sourceRoot":"","sources":["../../../src/plugins/indexing/ServiceDetector.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAGjD;;GAEG;AACH,UAAU,eAAe;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE;QACL,OAAO,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;KAC1C,CAAC;IACF,MAAM,CAAC,EAAE;QACP,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;QAC5D,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;QAC7D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;KAC7D,CAAC;CACH;AAwBD,qBAAa,eAAe;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;;IAQjB;;OAEG;IACG,OAAO,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC;IA+CjE;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAgC3B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAWzB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAwC5B;;;;;;;OAOG;IACH,OAAO,CAAC,cAAc;CAsCvB"}

package/dist/plugins/indexing/ServiceDetector.js

@@ -8,6 +8,7 @@
  */
 import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
 import { join, basename } from 'path';
+import { resolveSourceEntrypoint } from '../discovery/resolveSourceEntrypoint.js';
 export class ServiceDetector {
     name;
     phase;
@@ -21,21 +22,21 @@ export class ServiceDetector {
      * Анализирует проект и создаёт SERVICE ноды
      */
     async analyze(context) {
-        const { projectPath, graph } = context;
+        const { projectPath, graph, logger } = context;
         const services = [];
-        console.log(`[${this.name}] Detecting services in: ${projectPath}`);
+        logger?.info('Detecting services', { projectPath });
         // Паттерн 1: Монорепо структура (apps/, packages/, services/)
         const monorepoPatterns = ['apps', 'packages', 'services'];
         for (const pattern of monorepoPatterns) {
             const monorepoDir = join(projectPath, pattern);
             if (existsSync(monorepoDir)) {
-                const detected = this.detectServicesInDir(monorepoDir, projectPath);
+                const detected = this.detectServicesInDir(monorepoDir, projectPath, logger);
                 services.push(...detected);
             }
         }
         // Паттерн 2: Корневой проект (если нет монорепо)
         if (services.length === 0) {
-            const rootService = this.detectRootService(projectPath);
+            const rootService = this.detectRootService(projectPath, logger);
             if (rootService) {
                 services.push(rootService);
             }
@@ -54,14 +55,14 @@ export class ServiceDetector {
                 }
             });
         }
-        console.log(`[${this.name}] Detected ${services.length} services`);
-        services.forEach(s => console.log(`  - ${s.name} (${s.path})`));
+        logger?.info('Services detected', { count: services.length });
+        services.forEach(s => logger?.debug('Service found', { name: s.name, path: s.path }));
         return context;
     }
     /**
      * Обнаруживает сервисы в директории монорепо
      */
-    detectServicesInDir(dir, projectPath) {
+    detectServicesInDir(dir, projectPath, logger) {
         const services = [];
         try {
             const entries = readdirSync(dir);
@@ -75,7 +76,7 @@ export class ServiceDetector {
                 const packageJsonPath = join(fullPath, 'package.json');
                 const hasPackageJson = existsSync(packageJsonPath);
                 if (hasPackageJson) {
-                    const service = this.createServiceFromDir(fullPath, entry, projectPath);
+                    const service = this.createServiceFromDir(fullPath, entry, projectPath, logger);
                     if (service) {
                         services.push(service);
                     }
@@ -83,25 +84,25 @@ export class ServiceDetector {
             }
         }
         catch (error) {
-            console.warn(`[${this.name}] Error scanning ${dir}:`, error.message);
+            logger?.warn('Error scanning directory', { dir, error: error.message });
         }
         return services;
     }
     /**
      * Обнаруживает корневой сервис (не монорепо)
      */
-    detectRootService(projectPath) {
+    detectRootService(projectPath, logger) {
         const packageJsonPath = join(projectPath, 'package.json');
         if (!existsSync(packageJsonPath)) {
             return null;
         }
         const projectName = basename(projectPath);
-        return this.createServiceFromDir(projectPath, projectName, projectPath);
+        return this.createServiceFromDir(projectPath, projectName, projectPath, logger);
     }
     /**
      * Создаёт объект сервиса из директории
      */
-    createServiceFromDir(servicePath, serviceName, projectPath) {
+    createServiceFromDir(servicePath, serviceName, projectPath, logger) {
         try {
             const packageJsonPath = join(servicePath, 'package.json');
             let packageJson = null;
@@ -127,19 +128,31 @@ export class ServiceDetector {
             };
         }
         catch (error) {
-            console.warn(`[${this.name}] Error creating service from ${servicePath}:`, error.message);
+            logger?.warn('Error creating service', { servicePath, error: error.message });
             return null;
         }
     }
     /**
      * Находит entry point сервиса
+     *
+     * Resolution priority:
+     * 1. TypeScript source (via resolveSourceEntrypoint)
+     * 2. package.json main field
+     * 3. Standard fallback candidates
      */
     findEntryPoint(servicePath, packageJson) {
-        // 1. Из package.json main
+        // 1. Try TypeScript source first (prefers src/ over dist/)
+        if (packageJson) {
+            const tsSource = resolveSourceEntrypoint(servicePath, packageJson);
+            if (tsSource) {
+                return tsSource;
+            }
+        }
+        // 2. Fallback to package.json main (for JS projects or when source not found)
         if (packageJson?.main) {
             return packageJson.main;
         }
-        // 2. Стандартные entry points
+        // 3. Standard fallback candidates
         const candidates = [
             'src/index.js',
             'src/index.ts',

package/dist/plugins/validation/CallResolverValidator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CallResolverValidator.d.ts","sourceRoot":"","sources":["../../../src/plugins/validation/CallResolverValidator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AA2ChF,qBAAa,qBAAsB,SAAQ,MAAM;IAC/C,IAAI,QAAQ,IAAI,cAAc,CAU7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAuE5D;;OAEG;YACW,gBAAgB;CAyB/B"}
+{"version":3,"file":"CallResolverValidator.d.ts","sourceRoot":"","sources":["../../../src/plugins/validation/CallResolverValidator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AA2ChF,qBAAa,qBAAsB,SAAQ,MAAM;IAC/C,IAAI,QAAQ,IAAI,cAAc,CAU7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAwE5D;;OAEG;YACW,gBAAgB;CAyB/B"}

package/dist/plugins/validation/CallResolverValidator.js

@@ -25,10 +25,11 @@ export class CallResolverValidator extends Plugin {
     }
     async execute(context) {
         const { graph } = context;
-        console.log('[CallResolverValidator] Starting call resolution validation using Datalog...');
+        const logger = this.log(context);
+        logger.info('Starting call resolution validation using Datalog');
         // Check if graph supports checkGuarantee
         if (!graph.checkGuarantee) {
-            console.log('[CallResolverValidator] Graph does not support checkGuarantee, skipping validation');
+            logger.debug('Graph does not support checkGuarantee, skipping validation');
             return createSuccessResult({ nodes: 0, edges: 0 }, { skipped: true });
         }
         // Datalog гарантия:
@@ -38,7 +39,7 @@ export class CallResolverValidator extends Plugin {
     `);
         const issues = [];
         if (violations.length > 0) {
-            console.log(`[CallResolverValidator] Found ${violations.length} unresolved function calls`);
+            logger.debug('Unresolved function calls found', { count: violations.length });
             for (const v of violations) {
                 const nodeId = v.bindings.find(b => b.name === 'X')?.value;
                 if (nodeId) {
@@ -67,14 +68,14 @@ export class CallResolverValidator extends Plugin {
             externalMethodCalls: methodCallStats.external,
             issues: issues.length
         };
-        console.log('[CallResolverValidator] Summary:', summary);
+        logger.info('Validation complete', { ...summary });
         if (issues.length > 0) {
-            console.log(`[CallResolverValidator] Unresolved calls:`);
+            logger.warn('Unresolved calls detected', { count: issues.length });
             for (const issue of issues.slice(0, 10)) { // Show first 10
-                console.log(`  ⚠️ ${issue.message}`);
+                logger.warn(issue.message);
             }
             if (issues.length > 10) {
-                console.log(`  ... and ${issues.length - 10} more`);
+                logger.debug(`... and ${issues.length - 10} more`);
             }
         }
         return createSuccessResult({ nodes: 0, edges: 0 }, { summary, issues });

package/dist/plugins/validation/DataFlowValidator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DataFlowValidator.d.ts","sourceRoot":"","sources":["../../../src/plugins/validation/DataFlowValidator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AA4ChF,qBAAa,iBAAkB,SAAQ,MAAM;IAC3C,IAAI,QAAQ,IAAI,cAAc,CAU7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAkH5D;;OAEG;IACH,OAAO,CAAC,cAAc;CA2CvB"}
+{"version":3,"file":"DataFlowValidator.d.ts","sourceRoot":"","sources":["../../../src/plugins/validation/DataFlowValidator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AA4ChF,qBAAa,iBAAkB,SAAQ,MAAM;IAC3C,IAAI,QAAQ,IAAI,cAAc,CAU7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAsH5D;;OAEG;IACH,OAAO,CAAC,cAAc;CA2CvB"}

package/dist/plugins/validation/DataFlowValidator.js

@@ -26,25 +26,26 @@ export class DataFlowValidator extends Plugin {
     }
     async execute(context) {
         const { graph } = context;
-        console.log('[DataFlowValidator] Starting data flow validation...');
+        const logger = this.log(context);
+        logger.info('Starting data flow validation');
         // Check if graph supports getAllEdges
         if (!graph.getAllEdges) {
-            console.log('[DataFlowValidator] Graph does not support getAllEdges, skipping validation');
+            logger.debug('Graph does not support getAllEdges, skipping validation');
             return createSuccessResult({ nodes: 0, edges: 0 }, { skipped: true });
         }
         // Получаем все переменные
         const allNodes = await graph.getAllNodes();
         const allEdges = await graph.getAllEdges();
         const variables = allNodes.filter(n => n.type === 'VARIABLE_DECLARATION' || n.type === 'CONSTANT');
-        console.log(`[DataFlowValidator] Found ${variables.length} variables to validate`);
+        logger.debug('Variables collected', { count: variables.length });
         const issues = [];
         const leafTypes = new Set([
             'LITERAL',
-            'EXTERNAL_STDIO',
-            'EXTERNAL_DATABASE',
-            'EXTERNAL_NETWORK',
-            'EXTERNAL_FILESYSTEM',
-            'EVENT_LISTENER',
+            'net:stdio',
+            'db:query',
+            'net:request',
+            'fs:operation',
+            'event:listener',
             'CLASS', // NewExpression - конструкторы классов
             'FUNCTION', // Arrow functions и function expressions
             'METHOD_CALL', // Вызовы методов (промежуточные узлы)
@@ -104,13 +105,17 @@ export class DataFlowValidator extends Plugin {
             }
             summary.byType[issue.type]++;
         }
-        console.log('[DataFlowValidator] Summary:', summary);
+        logger.info('Validation complete', { ...summary });
         // Выводим issues
         if (issues.length > 0) {
-            console.log(`[DataFlowValidator] Found ${issues.length} issues:`);
+            logger.warn('Data flow issues found', { count: issues.length });
             for (const issue of issues) {
-                const level = issue.severity === 'ERROR' ? '❌' : '⚠️';
-                console.log(`  ${level} [${issue.type}] ${issue.message}`);
+                if (issue.severity === 'ERROR') {
+                    logger.error(`[${issue.type}] ${issue.message}`);
+                }
+                else {
+                    logger.warn(`[${issue.type}] ${issue.message}`);
+                }
             }
         }
         return createSuccessResult({ nodes: 0, edges: 0 }, { summary, issues });

package/dist/plugins/validation/EvalBanValidator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EvalBanValidator.d.ts","sourceRoot":"","sources":["../../../src/plugins/validation/EvalBanValidator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAoChF,qBAAa,gBAAiB,SAAQ,MAAM;IAC1C,IAAI,QAAQ,IAAI,cAAc,CAU7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;CAyG7D"}
+{"version":3,"file":"EvalBanValidator.d.ts","sourceRoot":"","sources":["../../../src/plugins/validation/EvalBanValidator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAoChF,qBAAa,gBAAiB,SAAQ,MAAM;IAC1C,IAAI,QAAQ,IAAI,cAAc,CAU7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;CA0G7D"}