@grafema/core 0.1.0-alpha.1

package/dist/plugins/indexing/RustModuleIndexer.js

@@ -0,0 +1,140 @@
+/**
+ * RustModuleIndexer - plugin for indexing Rust modules
+ * Discovers .rs files in rust-engine/src/ directory
+ */
+import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
+import { resolve, relative, basename, join } from 'path';
+import { createHash } from 'crypto';
+import { Plugin, createSuccessResult } from '../Plugin.js';
+// Test file patterns for Rust
+const RUST_TEST_PATTERNS = [
+    /[/\\]tests[/\\]/, // /tests/
+    /_test\.rs$/, // _test.rs
+    /[/\\]test\.rs$/, // test.rs in subdirectory
+];
+export class RustModuleIndexer extends Plugin {
+    testPatterns;
+    constructor() {
+        super();
+        this.testPatterns = RUST_TEST_PATTERNS;
+    }
+    get metadata() {
+        return {
+            name: 'RustModuleIndexer',
+            phase: 'INDEXING',
+            priority: 85, // After JSModuleIndexer (90)
+            creates: {
+                nodes: ['RUST_MODULE'],
+                edges: ['CONTAINS']
+            }
+        };
+    }
+    /**
+     * Check if file is a test file based on path patterns
+     */
+    isTestFile(filePath) {
+        return this.testPatterns.some(pattern => pattern.test(filePath));
+    }
+    /**
+     * Recursively find all .rs files in a directory
+     */
+    findRustFiles(dir, files = []) {
+        try {
+            const entries = readdirSync(dir);
+            for (const entry of entries) {
+                // Skip target directory
+                if (entry === 'target')
+                    continue;
+                const fullPath = join(dir, entry);
+                try {
+                    const stat = statSync(fullPath);
+                    if (stat.isDirectory()) {
+                        this.findRustFiles(fullPath, files);
+                    }
+                    else if (entry.endsWith('.rs')) {
+                        files.push(fullPath);
+                    }
+                }
+                catch {
+                    // Skip files we can't stat
+                }
+            }
+        }
+        catch {
+            // Skip directories we can't read
+        }
+        return files;
+    }
+    /**
+     * Convert file path to Rust module name
+     * src/ffi/napi_bindings.rs -> ffi::napi_bindings
+     * src/lib.rs -> crate
+     * src/ffi/mod.rs -> ffi
+     */
+    pathToModuleName(relativePath) {
+        let name = relativePath
+            .replace(/\.rs$/, '')
+            .replace(/\//g, '::');
+        if (name.endsWith('::mod')) {
+            name = name.replace(/::mod$/, '');
+        }
+        if (name === 'lib') {
+            name = 'crate';
+        }
+        return name;
+    }
+    async execute(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');
+        if (!existsSync(rustRoot)) {
+            console.log('[RustModuleIndexer] 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`);
+        let nodesCreated = 0;
+        const errors = [];
+        for (const filePath of rsFiles) {
+            try {
+                const content = readFileSync(filePath, 'utf-8');
+                const hash = createHash('sha256').update(content).digest('hex');
+                const relativePath = relative(rustRoot, filePath);
+                const moduleName = this.pathToModuleName(relativePath);
+                const nodeId = `RUST_MODULE#${moduleName}#${filePath}`;
+                await graph.addNode({
+                    id: nodeId,
+                    type: 'RUST_MODULE',
+                    name: moduleName,
+                    file: filePath,
+                    contentHash: hash,
+                    isLib: basename(filePath) === 'lib.rs',
+                    isMod: basename(filePath) === 'mod.rs',
+                    isTest: this.isTestFile(filePath)
+                });
+                nodesCreated++;
+                if (onProgress && nodesCreated % 10 === 0) {
+                    onProgress({
+                        phase: 'indexing',
+                        currentPlugin: 'RustModuleIndexer',
+                        message: `Indexed ${nodesCreated}/${rsFiles.length} Rust modules`,
+                        totalFiles: rsFiles.length,
+                        processedFiles: nodesCreated
+                    });
+                }
+            }
+            catch (err) {
+                errors.push({ file: filePath, error: err.message });
+            }
+        }
+        if (errors.length > 0) {
+            console.warn(`[RustModuleIndexer] ${errors.length} errors during indexing`);
+        }
+        console.log(`[RustModuleIndexer] Indexed ${nodesCreated} Rust modules`);
+        return createSuccessResult({ nodes: nodesCreated, edges: 0 }, { errors: errors.length });
+    }
+}

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

@@ -0,0 +1,46 @@
+/**
+ * ServiceDetector - обнаруживает сервисы в монорепозитории
+ *
+ * Паттерны детекции:
+ * 1. Директории с package.json в apps/, packages/, services/
+ * 2. Директории с Dockerfile
+ * 3. Директории с server.js/index.js entry points
+ */
+import type { NodeRecord } from '@grafema/types';
+/**
+ * Context for ServiceDetector
+ */
+interface DetectorContext {
+    projectPath: string;
+    graph: {
+        addNode(node: NodeRecord): Promise<void>;
+    };
+}
+export declare class ServiceDetector {
+    name: string;
+    phase: string;
+    priority: number;
+    constructor();
+    /**
+     * Анализирует проект и создаёт SERVICE ноды
+     */
+    analyze(context: DetectorContext): Promise<DetectorContext>;
+    /**
+     * Обнаруживает сервисы в директории монорепо
+     */
+    private detectServicesInDir;
+    /**
+     * Обнаруживает корневой сервис (не монорепо)
+     */
+    private detectRootService;
+    /**
+     * Создаёт объект сервиса из директории
+     */
+    private createServiceFromDir;
+    /**
+     * Находит entry point сервиса
+     */
+    private findEntryPoint;
+}
+export {};
+//# sourceMappingURL=ServiceDetector.d.ts.map

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

@@ -0,0 +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"}

package/dist/plugins/indexing/ServiceDetector.js

@@ -0,0 +1,164 @@
+/**
+ * ServiceDetector - обнаруживает сервисы в монорепозитории
+ *
+ * Паттерны детекции:
+ * 1. Директории с package.json в apps/, packages/, services/
+ * 2. Директории с Dockerfile
+ * 3. Директории с server.js/index.js entry points
+ */
+import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
+import { join, basename } from 'path';
+export class ServiceDetector {
+    name;
+    phase;
+    priority;
+    constructor() {
+        this.name = 'ServiceDetector';
+        this.phase = 'INDEXING';
+        this.priority = 90; // Запускается перед JSModuleIndexer
+    }
+    /**
+     * Анализирует проект и создаёт SERVICE ноды
+     */
+    async analyze(context) {
+        const { projectPath, graph } = context;
+        const services = [];
+        console.log(`[${this.name}] Detecting services in: ${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);
+                services.push(...detected);
+            }
+        }
+        // Паттерн 2: Корневой проект (если нет монорепо)
+        if (services.length === 0) {
+            const rootService = this.detectRootService(projectPath);
+            if (rootService) {
+                services.push(rootService);
+            }
+        }
+        // Создаём SERVICE ноды в графе
+        for (const service of services) {
+            await graph.addNode({
+                id: service.id,
+                type: 'SERVICE',
+                name: service.name,
+                file: service.path,
+                metadata: {
+                    packageJson: service.packageJson,
+                    entryPoint: service.entryPoint,
+                    hasDockerfile: service.hasDockerfile
+                }
+            });
+        }
+        console.log(`[${this.name}] Detected ${services.length} services`);
+        services.forEach(s => console.log(`  - ${s.name} (${s.path})`));
+        return context;
+    }
+    /**
+     * Обнаруживает сервисы в директории монорепо
+     */
+    detectServicesInDir(dir, projectPath) {
+        const services = [];
+        try {
+            const entries = readdirSync(dir);
+            for (const entry of entries) {
+                const fullPath = join(dir, entry);
+                // Пропускаем файлы и скрытые директории
+                if (!statSync(fullPath).isDirectory() || entry.startsWith('.')) {
+                    continue;
+                }
+                // Проверяем признаки сервиса
+                const packageJsonPath = join(fullPath, 'package.json');
+                const hasPackageJson = existsSync(packageJsonPath);
+                if (hasPackageJson) {
+                    const service = this.createServiceFromDir(fullPath, entry, projectPath);
+                    if (service) {
+                        services.push(service);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.warn(`[${this.name}] Error scanning ${dir}:`, error.message);
+        }
+        return services;
+    }
+    /**
+     * Обнаруживает корневой сервис (не монорепо)
+     */
+    detectRootService(projectPath) {
+        const packageJsonPath = join(projectPath, 'package.json');
+        if (!existsSync(packageJsonPath)) {
+            return null;
+        }
+        const projectName = basename(projectPath);
+        return this.createServiceFromDir(projectPath, projectName, projectPath);
+    }
+    /**
+     * Создаёт объект сервиса из директории
+     */
+    createServiceFromDir(servicePath, serviceName, projectPath) {
+        try {
+            const packageJsonPath = join(servicePath, 'package.json');
+            let packageJson = null;
+            if (existsSync(packageJsonPath)) {
+                const content = readFileSync(packageJsonPath, 'utf-8');
+                packageJson = JSON.parse(content);
+            }
+            // Определяем entry point
+            const entryPoint = this.findEntryPoint(servicePath, packageJson);
+            // Проверяем наличие Dockerfile
+            const hasDockerfile = existsSync(join(servicePath, 'Dockerfile')) ||
+                existsSync(join(servicePath, 'dockerfile'));
+            // Генерируем ID сервиса
+            const relativePath = servicePath.replace(projectPath, '').replace(/^\//, '');
+            const serviceId = `SERVICE:${relativePath || serviceName}`;
+            return {
+                id: serviceId,
+                name: packageJson?.name || serviceName,
+                path: servicePath,
+                packageJson,
+                entryPoint,
+                hasDockerfile
+            };
+        }
+        catch (error) {
+            console.warn(`[${this.name}] Error creating service from ${servicePath}:`, error.message);
+            return null;
+        }
+    }
+    /**
+     * Находит entry point сервиса
+     */
+    findEntryPoint(servicePath, packageJson) {
+        // 1. Из package.json main
+        if (packageJson?.main) {
+            return packageJson.main;
+        }
+        // 2. Стандартные entry points
+        const candidates = [
+            'src/index.js',
+            'src/index.ts',
+            'src/server.js',
+            'src/server.ts',
+            'src/main.js',
+            'src/main.ts',
+            'index.js',
+            'index.ts',
+            'server.js',
+            'server.ts',
+            'app.js',
+            'app.ts'
+        ];
+        for (const candidate of candidates) {
+            if (existsSync(join(servicePath, candidate))) {
+                return candidate;
+            }
+        }
+        return null;
+    }
+}

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

@@ -0,0 +1,23 @@
+/**
+ * CallResolverValidator - проверяет что все вызовы функций ссылаются на определения
+ *
+ * Использует Datalog для декларативной проверки гарантии:
+ * "Все внутренние вызовы функций (CALL_SITE) должны иметь CALLS ребро к FUNCTION"
+ *
+ * ПРАВИЛО (Datalog):
+ * violation(X) :- node(X, "CALL"), \+ attr(X, "object", _), \+ edge(X, _, "CALLS").
+ *
+ * Это находит CALL узлы без "object" метаданных (т.е. CALL_SITE, не METHOD_CALL),
+ * которые не имеют CALLS ребра к определению функции.
+ */
+import { Plugin } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+export declare class CallResolverValidator extends Plugin {
+    get metadata(): PluginMetadata;
+    execute(context: PluginContext): Promise<PluginResult>;
+    /**
+     * Подсчитывает статистику по вызовам
+     */
+    private countMethodCalls;
+}
+//# sourceMappingURL=CallResolverValidator.d.ts.map

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

@@ -0,0 +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"}

package/dist/plugins/validation/CallResolverValidator.js

@@ -0,0 +1,108 @@
+/**
+ * CallResolverValidator - проверяет что все вызовы функций ссылаются на определения
+ *
+ * Использует Datalog для декларативной проверки гарантии:
+ * "Все внутренние вызовы функций (CALL_SITE) должны иметь CALLS ребро к FUNCTION"
+ *
+ * ПРАВИЛО (Datalog):
+ * violation(X) :- node(X, "CALL"), \+ attr(X, "object", _), \+ edge(X, _, "CALLS").
+ *
+ * Это находит CALL узлы без "object" метаданных (т.е. CALL_SITE, не METHOD_CALL),
+ * которые не имеют CALLS ребра к определению функции.
+ */
+import { Plugin, createSuccessResult } from '../Plugin.js';
+export class CallResolverValidator extends Plugin {
+    get metadata() {
+        return {
+            name: 'CallResolverValidator',
+            phase: 'VALIDATION',
+            priority: 90,
+            creates: {
+                nodes: [],
+                edges: []
+            }
+        };
+    }
+    async execute(context) {
+        const { graph } = context;
+        console.log('[CallResolverValidator] Starting call resolution validation using Datalog...');
+        // Check if graph supports checkGuarantee
+        if (!graph.checkGuarantee) {
+            console.log('[CallResolverValidator] Graph does not support checkGuarantee, skipping validation');
+            return createSuccessResult({ nodes: 0, edges: 0 }, { skipped: true });
+        }
+        // Datalog гарантия:
+        // CALL без "object" (т.е. CALL_SITE) должен иметь CALLS ребро
+        const violations = await graph.checkGuarantee(`
+      violation(X) :- node(X, "CALL"), \\+ attr(X, "object", _), \\+ edge(X, _, "CALLS").
+    `);
+        const issues = [];
+        if (violations.length > 0) {
+            console.log(`[CallResolverValidator] Found ${violations.length} unresolved function calls`);
+            for (const v of violations) {
+                const nodeId = v.bindings.find(b => b.name === 'X')?.value;
+                if (nodeId) {
+                    const node = await graph.getNode(nodeId);
+                    if (node) {
+                        issues.push({
+                            type: 'UNRESOLVED_FUNCTION_CALL',
+                            severity: 'WARNING',
+                            message: `Call to "${node.name}" at ${node.file}:${node.line || '?'} does not resolve to a function definition`,
+                            callName: node.name,
+                            nodeId: nodeId,
+                            file: node.file,
+                            line: node.line
+                        });
+                    }
+                }
+            }
+        }
+        // Также проверим METHOD_CALL на известные внешние методы
+        // (это информационно, не ошибка)
+        const methodCallStats = await this.countMethodCalls(graph);
+        const summary = {
+            totalCalls: methodCallStats.total,
+            resolvedInternalCalls: methodCallStats.resolved,
+            unresolvedInternalCalls: issues.length,
+            externalMethodCalls: methodCallStats.external,
+            issues: issues.length
+        };
+        console.log('[CallResolverValidator] Summary:', summary);
+        if (issues.length > 0) {
+            console.log(`[CallResolverValidator] Unresolved calls:`);
+            for (const issue of issues.slice(0, 10)) { // Show first 10
+                console.log(`  ⚠️ ${issue.message}`);
+            }
+            if (issues.length > 10) {
+                console.log(`  ... and ${issues.length - 10} more`);
+            }
+        }
+        return createSuccessResult({ nodes: 0, edges: 0 }, { summary, issues });
+    }
+    /**
+     * Подсчитывает статистику по вызовам
+     */
+    async countMethodCalls(graph) {
+        const stats = {
+            total: 0,
+            resolved: 0,
+            external: 0
+        };
+        // Подсчитываем все CALL узлы
+        for await (const node of graph.queryNodes({ nodeType: 'CALL' })) {
+            stats.total++;
+            // Проверяем наличие "object" в метаданных (METHOD_CALL)
+            if (node.object) {
+                stats.external++;
+            }
+            else {
+                // CALL_SITE - проверяем есть ли CALLS ребро
+                const edges = await graph.getOutgoingEdges(node.id, ['CALLS']);
+                if (edges.length > 0) {
+                    stats.resolved++;
+                }
+            }
+        }
+        return stats;
+    }
+}

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

@@ -0,0 +1,24 @@
+/**
+ * DataFlowValidator - проверяет что все переменные прослеживаются до листовых узлов
+ *
+ * ПРАВИЛО: Каждая переменная должна иметь путь до листового узла через ASSIGNED_FROM рёбра
+ *
+ * ЛИСТОВЫЕ УЗЛЫ:
+ * - LITERAL: примитивные значения
+ * - EXTERNAL_STDIO: console.log/error
+ * - EXTERNAL_DATABASE: database queries
+ * - EXTERNAL_NETWORK: HTTP requests
+ * - EXTERNAL_FILESYSTEM: fs.readFile
+ * - EVENT_LISTENER: события
+ */
+import { Plugin } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+export declare class DataFlowValidator extends Plugin {
+    get metadata(): PluginMetadata;
+    execute(context: PluginContext): Promise<PluginResult>;
+    /**
+     * Находит путь от переменной до листового узла
+     */
+    private findPathToLeaf;
+}
+//# sourceMappingURL=DataFlowValidator.d.ts.map

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

@@ -0,0 +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"}

package/dist/plugins/validation/DataFlowValidator.js

@@ -0,0 +1,148 @@
+/**
+ * DataFlowValidator - проверяет что все переменные прослеживаются до листовых узлов
+ *
+ * ПРАВИЛО: Каждая переменная должна иметь путь до листового узла через ASSIGNED_FROM рёбра
+ *
+ * ЛИСТОВЫЕ УЗЛЫ:
+ * - LITERAL: примитивные значения
+ * - EXTERNAL_STDIO: console.log/error
+ * - EXTERNAL_DATABASE: database queries
+ * - EXTERNAL_NETWORK: HTTP requests
+ * - EXTERNAL_FILESYSTEM: fs.readFile
+ * - EVENT_LISTENER: события
+ */
+import { Plugin, createSuccessResult } from '../Plugin.js';
+export class DataFlowValidator extends Plugin {
+    get metadata() {
+        return {
+            name: 'DataFlowValidator',
+            phase: 'VALIDATION',
+            priority: 100,
+            creates: {
+                nodes: [],
+                edges: []
+            }
+        };
+    }
+    async execute(context) {
+        const { graph } = context;
+        console.log('[DataFlowValidator] Starting data flow validation...');
+        // Check if graph supports getAllEdges
+        if (!graph.getAllEdges) {
+            console.log('[DataFlowValidator] 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`);
+        const issues = [];
+        const leafTypes = new Set([
+            'LITERAL',
+            'EXTERNAL_STDIO',
+            'EXTERNAL_DATABASE',
+            'EXTERNAL_NETWORK',
+            'EXTERNAL_FILESYSTEM',
+            'EVENT_LISTENER',
+            'CLASS', // NewExpression - конструкторы классов
+            'FUNCTION', // Arrow functions и function expressions
+            'METHOD_CALL', // Вызовы методов (промежуточные узлы)
+            'CALL_SITE' // Вызовы функций (промежуточные узлы)
+        ]);
+        for (const variable of variables) {
+            // Проверяем наличие ASSIGNED_FROM ребра
+            const assignment = allEdges.find(e => e.type === 'ASSIGNED_FROM' && e.src === variable.id);
+            if (!assignment) {
+                issues.push({
+                    type: 'MISSING_ASSIGNMENT',
+                    severity: 'WARNING',
+                    message: `Variable "${variable.name}" (${variable.file}:${variable.line}) has no ASSIGNED_FROM edge`,
+                    variable: variable.name,
+                    file: variable.file,
+                    line: variable.line
+                });
+                continue;
+            }
+            // Проверяем что источник существует
+            const source = allNodes.find(n => n.id === assignment.dst);
+            if (!source) {
+                issues.push({
+                    type: 'BROKEN_REFERENCE',
+                    severity: 'ERROR',
+                    message: `Variable "${variable.name}" references non-existent node ${assignment.dst}`,
+                    variable: variable.name,
+                    file: variable.file,
+                    line: variable.line
+                });
+                continue;
+            }
+            // Проверяем путь до листового узла
+            const path = this.findPathToLeaf(variable, allNodes, allEdges, leafTypes);
+            if (!path.found) {
+                issues.push({
+                    type: 'NO_LEAF_NODE',
+                    severity: 'WARNING',
+                    message: `Variable "${variable.name}" (${variable.file}:${variable.line}) does not trace to a leaf node. Chain: ${path.chain.join(' -> ')}`,
+                    variable: variable.name,
+                    file: variable.file,
+                    line: variable.line,
+                    chain: path.chain
+                });
+            }
+        }
+        // Группируем issues по типу
+        const summary = {
+            total: variables.length,
+            validated: variables.length - issues.length,
+            issues: issues.length,
+            byType: {}
+        };
+        for (const issue of issues) {
+            if (!summary.byType[issue.type]) {
+                summary.byType[issue.type] = 0;
+            }
+            summary.byType[issue.type]++;
+        }
+        console.log('[DataFlowValidator] Summary:', summary);
+        // Выводим issues
+        if (issues.length > 0) {
+            console.log(`[DataFlowValidator] Found ${issues.length} issues:`);
+            for (const issue of issues) {
+                const level = issue.severity === 'ERROR' ? '❌' : '⚠️';
+                console.log(`  ${level} [${issue.type}] ${issue.message}`);
+            }
+        }
+        return createSuccessResult({ nodes: 0, edges: 0 }, { summary, issues });
+    }
+    /**
+     * Находит путь от переменной до листового узла
+     */
+    findPathToLeaf(startNode, allNodes, allEdges, leafTypes, visited = new Set(), chain = []) {
+        // Защита от циклов
+        if (visited.has(startNode.id)) {
+            return { found: false, chain: [...chain, `${startNode.type}:${startNode.name} (CYCLE)`] };
+        }
+        visited.add(startNode.id);
+        chain.push(`${startNode.type}:${startNode.name}`);
+        // Проверяем что это листовой узел
+        if (leafTypes.has(startNode.type)) {
+            return { found: true, chain };
+        }
+        // Ищем ASSIGNED_FROM ребро
+        const assignment = allEdges.find(e => e.type === 'ASSIGNED_FROM' && e.src === startNode.id);
+        if (!assignment) {
+            // Для METHOD_CALL и CALL_SITE - это промежуточные узлы, но можем считать их leaf для первой версии
+            if (startNode.type === 'METHOD_CALL' || startNode.type === 'CALL_SITE') {
+                return { found: true, chain: [...chain, '(intermediate node)'] };
+            }
+            return { found: false, chain: [...chain, '(no assignment)'] };
+        }
+        // Продолжаем по цепочке
+        const nextNode = allNodes.find(n => n.id === assignment.dst);
+        if (!nextNode) {
+            return { found: false, chain: [...chain, '(broken reference)'] };
+        }
+        return this.findPathToLeaf(nextNode, allNodes, allEdges, leafTypes, visited, chain);
+    }
+}