@grafema/core 0.1.0-alpha.1

package/dist/plugins/enrichment/HTTPConnectionEnricher.js

@@ -0,0 +1,135 @@
+/**
+ * HTTPConnectionEnricher - связывает http:request (frontend) с http:route (backend)
+ *
+ * Создаёт INTERACTS_WITH edges между:
+ * - Frontend fetch('/api/users') → Backend GET /api/users
+ * - Frontend fetch('/api/users', {method: 'POST'}) → Backend POST /api/users
+ *
+ * Поддержка параметризованных путей:
+ * - /api/graph/:serviceId матчится с /api/graph/my-service
+ */
+import { Plugin, createSuccessResult, createErrorResult } from '../Plugin.js';
+export class HTTPConnectionEnricher extends Plugin {
+    get metadata() {
+        return {
+            name: 'HTTPConnectionEnricher',
+            phase: 'ENRICHMENT',
+            priority: 50, // После основных enrichers
+            creates: {
+                nodes: [],
+                edges: ['INTERACTS_WITH']
+            },
+            dependencies: ['ExpressRouteAnalyzer', 'FetchAnalyzer']
+        };
+    }
+    async execute(context) {
+        const { graph } = context;
+        try {
+            // Собираем все http:route (backend endpoints)
+            const routes = [];
+            for await (const node of graph.queryNodes({ type: 'http:route' })) {
+                routes.push(node);
+            }
+            // Собираем все http:request (frontend requests)
+            const requests = [];
+            for await (const node of graph.queryNodes({ type: 'http:request' })) {
+                requests.push(node);
+            }
+            console.log(`[HTTPConnectionEnricher] Found ${routes.length} routes, ${requests.length} requests`);
+            // Дедуплицируем по ID (из-за multi-service анализа)
+            const uniqueRoutes = this.deduplicateById(routes);
+            const uniqueRequests = this.deduplicateById(requests);
+            console.log(`[HTTPConnectionEnricher] Unique: ${uniqueRoutes.length} routes, ${uniqueRequests.length} requests`);
+            let edgesCreated = 0;
+            const connections = [];
+            // Для каждого request ищем matching route
+            for (const request of uniqueRequests) {
+                // Пропускаем dynamic URLs
+                if (request.url === 'dynamic' || !request.url) {
+                    continue;
+                }
+                const method = (request.method || 'GET').toUpperCase();
+                const url = request.url;
+                // Ищем matching route
+                for (const route of uniqueRoutes) {
+                    const routeMethod = (route.method || 'GET').toUpperCase();
+                    const routePath = route.path;
+                    if (routePath && method === routeMethod && this.pathsMatch(url, routePath)) {
+                        // Создаём edge
+                        await graph.addEdge({
+                            type: 'INTERACTS_WITH',
+                            src: request.id,
+                            dst: route.id,
+                            matchType: this.hasParams(routePath) ? 'parametric' : 'exact'
+                        });
+                        connections.push({
+                            request: `${method} ${url}`,
+                            route: `${routeMethod} ${routePath}`,
+                            requestFile: request.file,
+                            routeFile: route.file
+                        });
+                        edgesCreated++;
+                        break; // Один request → один route
+                    }
+                }
+            }
+            // Логируем найденные связи
+            if (connections.length > 0) {
+                console.log(`[HTTPConnectionEnricher] Connections found:`);
+                for (const conn of connections) {
+                    console.log(`  ${conn.request} → ${conn.route}`);
+                }
+            }
+            return createSuccessResult({ nodes: 0, edges: edgesCreated }, {
+                connections: connections.length,
+                routesAnalyzed: uniqueRoutes.length,
+                requestsAnalyzed: uniqueRequests.length
+            });
+        }
+        catch (error) {
+            console.error(`[HTTPConnectionEnricher] Error:`, error);
+            return createErrorResult(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    /**
+     * Проверяет совпадают ли пути
+     * Поддерживает параметризованные пути: /api/users/:id матчится с /api/users/123
+     */
+    pathsMatch(requestUrl, routePath) {
+        // Точное совпадение
+        if (requestUrl === routePath) {
+            return true;
+        }
+        // Если route не имеет параметров, требуем точное совпадение
+        if (!this.hasParams(routePath)) {
+            return false;
+        }
+        // Преобразуем route path в regex
+        // /api/users/:id → /api/users/[^/]+
+        const regexPattern = routePath
+            .replace(/:[^/]+/g, '[^/]+') // :param → [^/]+
+            .replace(/\//g, '\\/'); // / → \/
+        const regex = new RegExp(`^${regexPattern}$`);
+        return regex.test(requestUrl);
+    }
+    /**
+     * Проверяет есть ли параметры в пути
+     */
+    hasParams(path) {
+        return Boolean(path && path.includes(':'));
+    }
+    /**
+     * Убирает дубликаты по ID
+     */
+    deduplicateById(nodes) {
+        const seen = new Set();
+        const unique = [];
+        for (const node of nodes) {
+            if (!seen.has(node.id)) {
+                seen.add(node.id);
+                unique.push(node);
+            }
+        }
+        return unique;
+    }
+}

package/dist/plugins/enrichment/ImportExportLinker.d.ts

@@ -0,0 +1,30 @@
+/**
+ * ImportExportLinker - создаёт IMPORTS_FROM edges между IMPORT и EXPORT нодами
+ *
+ * Этот enrichment plugin работает ПОСЛЕ JSASTAnalyzer и связывает:
+ * - IMPORT (default) -> IMPORTS_FROM -> EXPORT (default)
+ * - IMPORT (named)   -> IMPORTS_FROM -> EXPORT (named, matching name)
+ *
+ * ОПТИМИЗАЦИЯ:
+ * Вместо O(n) итерации по всем EXPORT нодам для каждого импорта,
+ * строим индекс один раз и используем O(1) lookup.
+ *
+ * Индекс: Map<file, Map<exportKey, exportNode>>
+ * где exportKey = "default" | "named:functionName" | "all"
+ */
+import { Plugin } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+export declare class ImportExportLinker extends Plugin {
+    get metadata(): PluginMetadata;
+    execute(context: PluginContext): Promise<PluginResult>;
+    /**
+     * Build index of all EXPORT nodes: Map<file, Map<exportKey, exportNode>>
+     * exportKey = "default" | "named:functionName" | "all"
+     */
+    private buildExportIndex;
+    /**
+     * Build MODULE lookup: Map<file, moduleNode>
+     */
+    private buildModuleLookup;
+}
+//# sourceMappingURL=ImportExportLinker.d.ts.map

package/dist/plugins/enrichment/ImportExportLinker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ImportExportLinker.d.ts","sourceRoot":"","sources":["../../../src/plugins/enrichment/ImportExportLinker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAmBhF,qBAAa,kBAAmB,SAAQ,MAAM;IAC5C,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAyH5D;;;OAGG;YACW,gBAAgB;IA+B9B;;OAEG;YACW,iBAAiB;CAWhC"}

package/dist/plugins/enrichment/ImportExportLinker.js

@@ -0,0 +1,176 @@
+/**
+ * ImportExportLinker - создаёт IMPORTS_FROM edges между IMPORT и EXPORT нодами
+ *
+ * Этот enrichment plugin работает ПОСЛЕ JSASTAnalyzer и связывает:
+ * - IMPORT (default) -> IMPORTS_FROM -> EXPORT (default)
+ * - IMPORT (named)   -> IMPORTS_FROM -> EXPORT (named, matching name)
+ *
+ * ОПТИМИЗАЦИЯ:
+ * Вместо O(n) итерации по всем EXPORT нодам для каждого импорта,
+ * строим индекс один раз и используем O(1) lookup.
+ *
+ * Индекс: Map<file, Map<exportKey, exportNode>>
+ * где exportKey = "default" | "named:functionName" | "all"
+ */
+import { dirname, resolve } from 'path';
+import { Plugin, createSuccessResult } from '../Plugin.js';
+export class ImportExportLinker extends Plugin {
+    get metadata() {
+        return {
+            name: 'ImportExportLinker',
+            phase: 'ENRICHMENT',
+            priority: 90, // Run early in enrichment, after analysis
+            creates: {
+                nodes: [],
+                edges: ['IMPORTS_FROM']
+            },
+            dependencies: ['JSASTAnalyzer'] // Requires IMPORT and EXPORT nodes
+        };
+    }
+    async execute(context) {
+        const { graph, onProgress } = context;
+        console.log('[ImportExportLinker] Starting import-export linking...');
+        const startTime = Date.now();
+        // Step 1: Build EXPORT index - Map<file, Map<exportKey, exportNode>>
+        const exportIndex = await this.buildExportIndex(graph);
+        const indexTime = Date.now() - startTime;
+        console.log(`[ImportExportLinker] Indexed exports from ${exportIndex.size} files in ${indexTime}ms`);
+        // Step 2: Build MODULE lookup - Map<file, moduleNode>
+        const modulesByFile = await this.buildModuleLookup(graph);
+        console.log(`[ImportExportLinker] Indexed ${modulesByFile.size} modules`);
+        // Step 3: Process all IMPORT nodes
+        const imports = [];
+        for await (const node of graph.queryNodes({ nodeType: 'IMPORT' })) {
+            imports.push(node);
+        }
+        console.log(`[ImportExportLinker] Found ${imports.length} imports to link`);
+        let edgesCreated = 0;
+        let skipped = 0;
+        let notFound = 0;
+        for (let i = 0; i < imports.length; i++) {
+            const imp = imports[i];
+            // Progress reporting
+            if (onProgress && i % 100 === 0) {
+                onProgress({
+                    phase: 'enrichment',
+                    currentPlugin: 'ImportExportLinker',
+                    message: `Linking imports ${i}/${imports.length}`,
+                    totalFiles: imports.length,
+                    processedFiles: i
+                });
+            }
+            // Skip external modules (non-relative imports)
+            const isRelative = imp.source && (imp.source.startsWith('./') || imp.source.startsWith('../'));
+            if (!isRelative) {
+                skipped++;
+                continue;
+            }
+            // Resolve target file path
+            const currentDir = dirname(imp.file);
+            const basePath = resolve(currentDir, imp.source);
+            // Try different extensions
+            const extensions = ['', '.js', '.ts', '.jsx', '.tsx', '/index.js', '/index.ts'];
+            let targetFile = null;
+            let targetExports = null;
+            for (const ext of extensions) {
+                const testPath = basePath + ext;
+                if (exportIndex.has(testPath)) {
+                    targetFile = testPath;
+                    targetExports = exportIndex.get(testPath);
+                    break;
+                }
+                // Also check modulesByFile in case exports haven't been indexed yet
+                if (!targetFile && modulesByFile.has(testPath)) {
+                    targetFile = testPath;
+                    targetExports = exportIndex.get(testPath) || new Map();
+                    break;
+                }
+            }
+            if (!targetFile || !targetExports) {
+                notFound++;
+                continue;
+            }
+            // Find matching export based on import type
+            const importType = imp.importType; // 'default', 'named', or 'namespace'
+            let targetExport;
+            if (importType === 'namespace') {
+                // import * as foo - already linked to MODULE in GraphBuilder
+                skipped++;
+                continue;
+            }
+            else if (importType === 'default') {
+                // import foo from './bar' -> find default export
+                targetExport = targetExports.get('default');
+            }
+            else {
+                // import { foo } from './bar' -> find named export 'foo'
+                const exportKey = `named:${imp.imported}`;
+                targetExport = targetExports.get(exportKey);
+            }
+            if (targetExport) {
+                await graph.addEdge({
+                    type: 'IMPORTS_FROM',
+                    src: imp.id,
+                    dst: targetExport.id
+                });
+                edgesCreated++;
+            }
+            else {
+                notFound++;
+            }
+        }
+        const totalTime = ((Date.now() - startTime) / 1000).toFixed(2);
+        console.log(`[ImportExportLinker] Complete: ${edgesCreated} edges created, ${skipped} skipped, ${notFound} not found (${totalTime}s)`);
+        return createSuccessResult({ nodes: 0, edges: edgesCreated }, {
+            importsProcessed: imports.length,
+            edgesCreated,
+            skipped,
+            notFound,
+            timeMs: Date.now() - startTime
+        });
+    }
+    /**
+     * Build index of all EXPORT nodes: Map<file, Map<exportKey, exportNode>>
+     * exportKey = "default" | "named:functionName" | "all"
+     */
+    async buildExportIndex(graph) {
+        const index = new Map();
+        for await (const node of graph.queryNodes({ nodeType: 'EXPORT' })) {
+            const exportNode = node;
+            if (!exportNode.file)
+                continue;
+            if (!index.has(exportNode.file)) {
+                index.set(exportNode.file, new Map());
+            }
+            const fileExports = index.get(exportNode.file);
+            // Build export key based on type
+            let exportKey;
+            if (exportNode.exportType === 'default') {
+                exportKey = 'default';
+            }
+            else if (exportNode.exportType === 'named') {
+                exportKey = `named:${exportNode.name}`;
+            }
+            else if (exportNode.exportType === 'all') {
+                exportKey = 'all';
+            }
+            else {
+                exportKey = `unknown:${exportNode.name || 'anonymous'}`;
+            }
+            fileExports.set(exportKey, exportNode);
+        }
+        return index;
+    }
+    /**
+     * Build MODULE lookup: Map<file, moduleNode>
+     */
+    async buildModuleLookup(graph) {
+        const lookup = new Map();
+        for await (const node of graph.queryNodes({ nodeType: 'MODULE' })) {
+            if (node.file) {
+                lookup.set(node.file, node);
+            }
+        }
+        return lookup;
+    }
+}

package/dist/plugins/enrichment/InstanceOfResolver.d.ts

@@ -0,0 +1,21 @@
+/**
+ * InstanceOfResolver - резолвит INSTANCE_OF edges к правильным CLASS нодам
+ *
+ * Проблема: При параллельном анализе модулей, CLASS ноды для импортированных
+ * классов создаются как "заглушки" (isInstantiationRef: true) потому что
+ * исходный модуль может ещё не быть проанализирован.
+ *
+ * Решение: После анализа всех модулей этот плагин:
+ * 1. Находит все INSTANCE_OF edges
+ * 2. Для edges указывающих на "заглушки" (CLASS с isInstantiationRef)
+ * 3. Ищет настоящую CLASS декларацию через IMPORT → MODULE → CLASS
+ * 4. Перенаправляет INSTANCE_OF edge на настоящий CLASS
+ * 5. Удаляет "заглушку" CLASS ноду
+ */
+import { Plugin } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+export declare class InstanceOfResolver extends Plugin {
+    get metadata(): PluginMetadata;
+    execute(context: PluginContext): Promise<PluginResult>;
+}
+//# sourceMappingURL=InstanceOfResolver.d.ts.map

package/dist/plugins/enrichment/InstanceOfResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InstanceOfResolver.d.ts","sourceRoot":"","sources":["../../../src/plugins/enrichment/InstanceOfResolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AA4BhF,qBAAa,kBAAmB,SAAQ,MAAM;IAC5C,IAAI,QAAQ,IAAI,cAAc,CAU7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;CA0G7D"}

package/dist/plugins/enrichment/InstanceOfResolver.js

@@ -0,0 +1,117 @@
+/**
+ * InstanceOfResolver - резолвит INSTANCE_OF edges к правильным CLASS нодам
+ *
+ * Проблема: При параллельном анализе модулей, CLASS ноды для импортированных
+ * классов создаются как "заглушки" (isInstantiationRef: true) потому что
+ * исходный модуль может ещё не быть проанализирован.
+ *
+ * Решение: После анализа всех модулей этот плагин:
+ * 1. Находит все INSTANCE_OF edges
+ * 2. Для edges указывающих на "заглушки" (CLASS с isInstantiationRef)
+ * 3. Ищет настоящую CLASS декларацию через IMPORT → MODULE → CLASS
+ * 4. Перенаправляет INSTANCE_OF edge на настоящий CLASS
+ * 5. Удаляет "заглушку" CLASS ноду
+ */
+import { dirname, resolve } from 'path';
+import { Plugin, createSuccessResult } from '../Plugin.js';
+export class InstanceOfResolver extends Plugin {
+    get metadata() {
+        return {
+            name: 'InstanceOfResolver',
+            phase: 'ENRICHMENT',
+            priority: 100, // Высокий приоритет - должен выполняться перед другими enrichment плагинами
+            creates: {
+                nodes: [],
+                edges: ['INSTANCE_OF'] // Пере-создаёт INSTANCE_OF edges
+            }
+        };
+    }
+    async execute(context) {
+        const { graph } = context;
+        let resolvedCount = 0;
+        let removedStubs = 0;
+        // 1. Собираем все CLASS ноды (декларации и заглушки)
+        const classDeclarations = new Map(); // file:name → classId (только настоящие декларации)
+        const classStubs = new Map(); // classId → { name, file }
+        for await (const node of graph.queryNodes({ type: 'CLASS' })) {
+            if (node.isInstantiationRef) {
+                classStubs.set(node.id, { name: node.name, file: node.file });
+            }
+            else {
+                // Настоящая декларация
+                const key = `${node.file}:${node.name}`;
+                classDeclarations.set(key, node.id);
+            }
+        }
+        if (classStubs.size === 0) {
+            return createSuccessResult({ nodes: 0, edges: 0 }, { resolvedInstanceOf: 0, removedStubs: 0 });
+        }
+        // 2. Собираем импорты для резолва
+        const importMap = new Map(); // file:localName → { source, imported }
+        for await (const node of graph.queryNodes({ type: 'IMPORT' })) {
+            const importNode = node;
+            const key = `${node.file}:${importNode.local}`;
+            importMap.set(key, { source: importNode.source, imported: importNode.imported });
+        }
+        // 3. Для каждой заглушки пытаемся найти настоящую декларацию
+        const edgesToUpdate = [];
+        const stubsToRemove = [];
+        for (const [stubId, stubInfo] of classStubs) {
+            const { name, file } = stubInfo;
+            // Проверяем есть ли импорт для этого класса
+            const importKey = `${file}:${name}`;
+            const importInfo = importMap.get(importKey);
+            if (!importInfo)
+                continue;
+            const { source, imported } = importInfo;
+            // Только относительные импорты (локальные модули)
+            if (!source.startsWith('./') && !source.startsWith('../'))
+                continue;
+            // Резолвим путь к исходному модулю
+            const moduleDir = dirname(file);
+            let resolvedPath = resolve(moduleDir, source);
+            if (!resolvedPath.endsWith('.js') && !resolvedPath.endsWith('.ts') && !resolvedPath.endsWith('.mjs')) {
+                resolvedPath += '.js';
+            }
+            // Ищем CLASS декларацию в исходном модуле
+            const importedClassName = imported === 'default' ? name : imported;
+            const declarationKey = `${resolvedPath}:${importedClassName}`;
+            const realClassId = classDeclarations.get(declarationKey);
+            if (realClassId) {
+                // Нашли настоящий класс!
+                // Собираем INSTANCE_OF edges указывающие на заглушку
+                const incomingEdges = await graph.getIncomingEdges(stubId, ['INSTANCE_OF']);
+                for (const edge of incomingEdges) {
+                    edgesToUpdate.push({
+                        src: edge.src,
+                        oldDst: stubId,
+                        newDst: realClassId
+                    });
+                }
+                stubsToRemove.push(stubId);
+            }
+        }
+        // 4. Обновляем edges (удаляем старые, создаём новые)
+        for (const update of edgesToUpdate) {
+            // Удаляем старый edge (if supported)
+            if (graph.deleteEdge) {
+                await graph.deleteEdge(update.src, update.oldDst, 'INSTANCE_OF');
+            }
+            // Создаём новый edge
+            await graph.addEdge({
+                type: 'INSTANCE_OF',
+                src: update.src,
+                dst: update.newDst
+            });
+            resolvedCount++;
+        }
+        // 5. Удаляем заглушки (if supported)
+        for (const stubId of stubsToRemove) {
+            if (graph.deleteNode) {
+                await graph.deleteNode(stubId);
+                removedStubs++;
+            }
+        }
+        return createSuccessResult({ nodes: 0, edges: resolvedCount }, { resolvedInstanceOf: resolvedCount, removedStubs: removedStubs });
+    }
+}

package/dist/plugins/enrichment/MethodCallResolver.d.ts

@@ -0,0 +1,41 @@
+/**
+ * MethodCallResolver - обогащает METHOD_CALL ноды связями CALLS к определениям методов
+ *
+ * Находит вызовы методов (CALL с "object" атрибутом) и пытается связать их с:
+ * 1. Методами классов в том же файле
+ * 2. Методами классов в импортированных модулях
+ * 3. Методами объектов переменных
+ *
+ * СОЗДАЁТ РЁБРА:
+ * - METHOD_CALL -> CALLS -> METHOD (для методов классов)
+ * - METHOD_CALL -> CALLS -> FUNCTION (для методов объектов)
+ */
+import { Plugin } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+export declare class MethodCallResolver extends Plugin {
+    private _containingClassCache?;
+    get metadata(): PluginMetadata;
+    execute(context: PluginContext): Promise<PluginResult>;
+    /**
+     * Строит индекс классов и их методов
+     */
+    private buildClassMethodIndex;
+    /**
+     * Строит индекс переменных и их типов (из INSTANCE_OF рёбер)
+     */
+    private buildVariableTypeIndex;
+    /**
+     * Пытается найти определение метода
+     */
+    private resolveMethodCall;
+    /**
+     * Находит класс, содержащий данный method call
+     */
+    private findContainingClass;
+    private findContainingClassRecursive;
+    /**
+     * Проверяет является ли метод внешним (console, Array, Promise, etc.)
+     */
+    private isExternalMethod;
+}
+//# sourceMappingURL=MethodCallResolver.d.ts.map

package/dist/plugins/enrichment/MethodCallResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MethodCallResolver.d.ts","sourceRoot":"","sources":["../../../src/plugins/enrichment/MethodCallResolver.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;AAmBhF,qBAAa,kBAAmB,SAAQ,MAAM;IAC5C,OAAO,CAAC,qBAAqB,CAAC,CAAqC;IAEnE,IAAI,QAAQ,IAAI,cAAc,CAU7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IA8F5D;;OAEG;YACW,qBAAqB;IA0CnC;;OAEG;YACW,sBAAsB;IAkBpC;;OAEG;YACW,iBAAiB;IA0D/B;;OAEG;YACW,mBAAmB;YAqBnB,4BAA4B;IAyB1C;;OAEG;IACH,OAAO,CAAC,gBAAgB;CAWzB"}