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

package/dist/plugins/indexing/JSModuleIndexer.js

@@ -3,12 +3,13 @@
  * Строит дерево зависимостей от 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 { minimatch } from 'minimatch';
+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/
@@ -25,9 +26,15 @@ export class JSModuleIndexer extends Plugin {
     cache;
     testPatterns;
     markTestFiles;
+    // Include/exclude pattern filtering (REG-185)
+    includePatterns;
+    excludePatterns;
+    projectPath = '';
     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
@@ -40,6 +47,39 @@ export class JSModuleIndexer extends Plugin {
             return false;
         return this.testPatterns.some(pattern => pattern.test(filePath));
     }
+    /**
+     * Check if a file should be skipped based on include/exclude patterns.
+     *
+     * Logic:
+     * 1. If file matches any exclude pattern -> SKIP
+     * 2. If include patterns specified AND file doesn't match any -> SKIP
+     * 3. Otherwise -> PROCESS
+     *
+     * @param absolutePath - Absolute path to the file
+     * @returns true if file should be skipped, false if it should be processed
+     */
+    shouldSkipFile(absolutePath) {
+        // Normalize to relative path for pattern matching
+        const relativePath = relative(this.projectPath, absolutePath).replace(/\\/g, '/');
+        // Check exclude patterns first (if any match, skip)
+        if (this.excludePatterns && this.excludePatterns.length > 0) {
+            for (const pattern of this.excludePatterns) {
+                if (minimatch(relativePath, pattern, { dot: true })) {
+                    return true; // Excluded
+                }
+            }
+        }
+        // Check include patterns (if specified, file must match at least one)
+        if (this.includePatterns && this.includePatterns.length > 0) {
+            for (const pattern of this.includePatterns) {
+                if (minimatch(relativePath, pattern, { dot: true })) {
+                    return false; // Included
+                }
+            }
+            return true; // Include specified but file didn't match any
+        }
+        return false; // No filtering, process file
+    }
     get metadata() {
         return {
             name: 'JSModuleIndexer',
@@ -161,22 +201,38 @@ 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 = [];
+            // Store projectPath for shouldSkipFile()
+            this.projectPath = projectPath;
+            // Read include/exclude patterns from config (REG-185)
+            const orchConfig = config;
+            this.includePatterns = orchConfig?.include;
+            this.excludePatterns = orchConfig?.exclude;
+            // Log if patterns are configured
+            if (this.includePatterns || this.excludePatterns) {
+                logger.info('File filtering enabled', {
+                    include: this.includePatterns?.length ?? 0,
+                    exclude: this.excludePatterns?.length ?? 0,
+                });
+            }
             // 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 }];
@@ -192,6 +248,13 @@ export class JSModuleIndexer extends Plugin {
             const PROGRESS_INTERVAL = 10; // Report every N files
             while (stack.length > 0 && visited.size < MAX_MODULES) {
                 const { file: currentFile, depth } = stack.pop();
+                // Check if file should be skipped based on include/exclude patterns (REG-185)
+                if (this.shouldSkipFile(currentFile)) {
+                    logger.debug('Skipping file (filtered by patterns)', {
+                        file: currentFile.replace(projectPath, '')
+                    });
+                    continue; // Don't process, don't follow imports
+                }
                 // Report progress every PROGRESS_INTERVAL files
                 if (onProgress && visited.size - lastProgressReport >= PROGRESS_INTERVAL) {
                     onProgress({
@@ -203,31 +266,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 +317,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 +350,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 +367,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

@@ -1,6 +1,6 @@
 /**
  * RustModuleIndexer - plugin for indexing Rust modules
- * Discovers .rs files in rust-engine/src/ directory
+ * Discovers .rs files in packages/rfdb-server/src/ directory
  */
 import { Plugin } from '../Plugin.js';
 import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';

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

@@ -1,6 +1,6 @@
 /**
  * RustModuleIndexer - plugin for indexing Rust modules
- * Discovers .rs files in rust-engine/src/ directory
+ * Discovers .rs files in packages/rfdb-server/src/ directory
  */
 import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
 import { resolve, relative, basename, join } from 'path';
@@ -84,19 +84,20 @@ 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;
         const { projectPath } = typedManifest;
-        // Find rust-engine/src directory
-        const rustRoot = resolve(projectPath, 'rust-engine/src');
+        // Find packages/rfdb-server/src directory
+        const rustRoot = resolve(projectPath, 'packages/rfdb-server/src');
         if (!existsSync(rustRoot)) {
-            console.log('[RustModuleIndexer] rust-engine/src not found, skipping');
+            logger.info('packages/rfdb-server/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/BrokenImportValidator.d.ts

@@ -0,0 +1,31 @@
+/**
+ * BrokenImportValidator - detects broken imports and undefined symbols (REG-261)
+ *
+ * This VALIDATION plugin queries the graph (built by ANALYSIS and ENRICHMENT phases)
+ * to detect:
+ *
+ * 1. ERR_BROKEN_IMPORT: Named/default import references non-existent export
+ *    - IMPORT node with relative source but no IMPORTS_FROM edge
+ *    - Skips: external (npm) imports, namespace imports, type-only imports
+ *
+ * 2. ERR_UNDEFINED_SYMBOL: Symbol used but not defined, imported, or global
+ *    - CALL node without CALLS edge
+ *    - Not a method call (no `object` property)
+ *    - Not a local definition (FUNCTION/CLASS/VARIABLE in same file)
+ *    - Not an import (IMPORT with matching local name)
+ *    - Not a known global (console, setTimeout, etc.)
+ *
+ * Architecture follows existing validator patterns:
+ * - Phase: VALIDATION
+ * - Priority: 85 (after enrichment, before general validators)
+ * - Returns: ValidationError[] collected via DiagnosticCollector
+ */
+import { Plugin } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+export declare class BrokenImportValidator extends Plugin {
+    private globalsRegistry;
+    constructor(config?: Record<string, unknown>);
+    get metadata(): PluginMetadata;
+    execute(context: PluginContext): Promise<PluginResult>;
+}
+//# sourceMappingURL=BrokenImportValidator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BrokenImportValidator.d.ts","sourceRoot":"","sources":["../../../src/plugins/validation/BrokenImportValidator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAqChF,qBAAa,qBAAsB,SAAQ,MAAM;IAC/C,OAAO,CAAC,eAAe,CAAkB;gBAE7B,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;IAWhD,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;CA4O7D"}