@grafema/core 0.1.0-alpha.1

package/dist/plugins/analysis/FetchAnalyzer.js

@@ -0,0 +1,344 @@
+/**
+ * FetchAnalyzer - детектит HTTP requests (fetch, axios, custom wrappers)
+ *
+ * Паттерны:
+ * - fetch(url, options) - Native Fetch API
+ * - await fetch(url) - Async fetch
+ * - axios.get(url) - Axios GET
+ * - axios.post(url, data) - Axios POST
+ * - customFetch(url, options) - Custom wrappers (authFetch, apiFetch, etc.)
+ */
+import { readFileSync } from 'fs';
+import { parse } from '@babel/parser';
+import traverseModule from '@babel/traverse';
+import { Plugin, createSuccessResult, createErrorResult } from '../Plugin.js';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const traverse = traverseModule.default || traverseModule;
+export class FetchAnalyzer extends Plugin {
+    get metadata() {
+        return {
+            name: 'FetchAnalyzer',
+            phase: 'ANALYSIS',
+            priority: 75, // После JSASTAnalyzer (80)
+            creates: {
+                nodes: ['http:request', 'EXTERNAL'],
+                edges: ['CONTAINS', 'MAKES_REQUEST', 'CALLS_API']
+            },
+            dependencies: ['JSModuleIndexer', 'JSASTAnalyzer']
+        };
+    }
+    async execute(context) {
+        try {
+            const { graph } = context;
+            // Получаем все модули
+            const modules = await this.getModules(graph);
+            console.log(`[FetchAnalyzer] Processing ${modules.length} modules...`);
+            let requestsCount = 0;
+            let apisCount = 0;
+            const startTime = Date.now();
+            for (let i = 0; i < modules.length; i++) {
+                const module = modules[i];
+                const result = await this.analyzeModule(module, graph);
+                requestsCount += result.requests;
+                apisCount += result.apis;
+                // Progress every 20 modules
+                if ((i + 1) % 20 === 0 || i === modules.length - 1) {
+                    const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+                    const avgTime = ((Date.now() - startTime) / (i + 1)).toFixed(0);
+                    console.log(`[FetchAnalyzer] Progress: ${i + 1}/${modules.length} (${elapsed}s, avg ${avgTime}ms/module)`);
+                }
+            }
+            console.log(`[FetchAnalyzer] Found ${requestsCount} HTTP requests, ${apisCount} external APIs`);
+            return createSuccessResult({
+                nodes: requestsCount + apisCount,
+                edges: 0
+            }, {
+                requestsCount,
+                apisCount
+            });
+        }
+        catch (error) {
+            console.error('[FetchAnalyzer] Error:', error);
+            return createErrorResult(error);
+        }
+    }
+    async analyzeModule(module, graph) {
+        try {
+            const code = readFileSync(module.file, 'utf-8');
+            const ast = parse(code, {
+                sourceType: 'module',
+                plugins: [
+                    'jsx',
+                    'typescript',
+                    'classProperties',
+                    'decorators-legacy',
+                    'asyncGenerators',
+                    'dynamicImport',
+                    'optionalChaining',
+                    'nullishCoalescingOperator'
+                ]
+            });
+            const httpRequests = [];
+            const externalAPIs = new Set();
+            // Детект HTTP request паттернов
+            traverse(ast, {
+                CallExpression: (path) => {
+                    const node = path.node;
+                    const callee = node.callee;
+                    // Pattern 1: fetch(url, options)
+                    if (callee.type === 'Identifier' && callee.name === 'fetch') {
+                        const urlArg = node.arguments[0];
+                        const url = this.extractURL(urlArg);
+                        const method = this.extractMethod(node.arguments[1]) || 'GET';
+                        const line = node.loc.start.line;
+                        const request = {
+                            id: `http:request#${method}:${url}#${module.file}#${line}`,
+                            type: 'http:request',
+                            method: method,
+                            url: url,
+                            library: 'fetch',
+                            file: module.file,
+                            line: line,
+                            staticUrl: url !== 'dynamic' && url !== 'unknown' ? 'yes' : 'no'
+                        };
+                        httpRequests.push(request);
+                        // Определяем внешний ли это API
+                        if (this.isExternalAPI(url)) {
+                            externalAPIs.add(this.extractDomain(url));
+                        }
+                    }
+                    // Pattern 2: axios.get(url), axios.post(url, data), etc.
+                    if (callee.type === 'MemberExpression' &&
+                        callee.object.type === 'Identifier' &&
+                        callee.object.name === 'axios' &&
+                        callee.property.type === 'Identifier') {
+                        const method = callee.property.name.toUpperCase();
+                        const urlArg = node.arguments[0];
+                        const url = this.extractURL(urlArg);
+                        const line = node.loc.start.line;
+                        const request = {
+                            id: `http:request#${method}:${url}#${module.file}#${line}`,
+                            type: 'http:request',
+                            method: method,
+                            url: url,
+                            library: 'axios',
+                            file: module.file,
+                            line: line,
+                            staticUrl: url !== 'dynamic' && url !== 'unknown' ? 'yes' : 'no'
+                        };
+                        httpRequests.push(request);
+                        if (this.isExternalAPI(url)) {
+                            externalAPIs.add(this.extractDomain(url));
+                        }
+                    }
+                    // Pattern 3: axios(config) - generic
+                    if (callee.type === 'Identifier' && callee.name === 'axios') {
+                        const config = node.arguments[0];
+                        if (config && config.type === 'ObjectExpression') {
+                            const objExpr = config;
+                            const urlProp = objExpr.properties.find(p => p.type === 'ObjectProperty' &&
+                                p.key.type === 'Identifier' &&
+                                p.key.name === 'url');
+                            const methodProp = objExpr.properties.find(p => p.type === 'ObjectProperty' &&
+                                p.key.type === 'Identifier' &&
+                                p.key.name === 'method');
+                            const url = urlProp
+                                ? this.extractURL(urlProp.value)
+                                : 'unknown';
+                            const method = methodProp
+                                ? this.extractString(methodProp.value) || 'GET'
+                                : 'GET';
+                            const line = node.loc.start.line;
+                            const request = {
+                                id: `http:request#${method.toUpperCase()}:${url}#${module.file}#${line}`,
+                                type: 'http:request',
+                                method: method.toUpperCase(),
+                                url: url,
+                                library: 'axios',
+                                file: module.file,
+                                line: line,
+                                staticUrl: url !== 'dynamic' && url !== 'unknown' ? 'yes' : 'no'
+                            };
+                            httpRequests.push(request);
+                            if (this.isExternalAPI(url)) {
+                                externalAPIs.add(this.extractDomain(url));
+                            }
+                        }
+                    }
+                    // Pattern 4: Custom fetch wrappers (authFetch, apiFetch, etc.)
+                    if (callee.type === 'Identifier') {
+                        const calleeName = callee.name;
+                        if (calleeName !== 'fetch' &&
+                            (calleeName.toLowerCase().includes('fetch') ||
+                                calleeName.toLowerCase().includes('request'))) {
+                            const urlArg = node.arguments[0];
+                            const url = this.extractURL(urlArg);
+                            const method = this.extractMethod(node.arguments[1]) || 'GET';
+                            const line = node.loc.start.line;
+                            const request = {
+                                id: `http:request#${method}:${url}#${module.file}#${line}`,
+                                type: 'http:request',
+                                method: method,
+                                url: url,
+                                library: calleeName,
+                                file: module.file,
+                                line: line,
+                                staticUrl: url !== 'dynamic' && url !== 'unknown' ? 'yes' : 'no'
+                            };
+                            httpRequests.push(request);
+                            if (this.isExternalAPI(url)) {
+                                externalAPIs.add(this.extractDomain(url));
+                            }
+                        }
+                    }
+                }
+            });
+            // Создаём HTTP_REQUEST ноды
+            for (const request of httpRequests) {
+                await graph.addNode(request);
+                // Создаём ребро от модуля к request
+                await graph.addEdge({
+                    type: 'CONTAINS',
+                    src: module.id,
+                    dst: request.id
+                });
+                // Ищем FUNCTION node которая делает запрос
+                const functions = [];
+                for await (const fn of graph.queryNodes({ type: 'FUNCTION' })) {
+                    if (fn.file === request.file &&
+                        (fn.line ?? 0) <= request.line &&
+                        (fn.line ?? 0) + 50 >= request.line) {
+                        functions.push(fn);
+                    }
+                }
+                if (functions.length > 0) {
+                    // Берём ближайшую функцию
+                    const closestFunction = functions.reduce((closest, func) => {
+                        const currentDistance = Math.abs((func.line ?? 0) - request.line);
+                        const closestDistance = Math.abs((closest.line ?? 0) - request.line);
+                        return currentDistance < closestDistance ? func : closest;
+                    });
+                    await graph.addEdge({
+                        type: 'MAKES_REQUEST',
+                        src: closestFunction.id,
+                        dst: request.id
+                    });
+                }
+            }
+            // Создаём EXTERNAL ноды для внешних API
+            for (const apiDomain of externalAPIs) {
+                const apiId = `EXTERNAL#${apiDomain}`;
+                // Проверяем что нода ещё не создана
+                const existingApi = await graph.getNode(apiId);
+                if (!existingApi) {
+                    await graph.addNode({
+                        id: apiId,
+                        type: 'EXTERNAL',
+                        domain: apiDomain,
+                        name: apiDomain
+                    });
+                }
+                // Создаём рёбра от http:request к EXTERNAL
+                const apiRequests = httpRequests.filter(r => r.url.includes(apiDomain));
+                for (const request of apiRequests) {
+                    await graph.addEdge({
+                        type: 'CALLS_API',
+                        src: request.id,
+                        dst: apiId
+                    });
+                }
+            }
+            return {
+                requests: httpRequests.length,
+                apis: externalAPIs.size
+            };
+        }
+        catch (error) {
+            console.error(`[FetchAnalyzer] Error analyzing ${module.file}:`, error.message);
+            return { requests: 0, apis: 0 };
+        }
+    }
+    /**
+     * Извлекает URL из аргумента
+     */
+    extractURL(arg) {
+        if (!arg)
+            return 'unknown';
+        if (arg.type === 'StringLiteral') {
+            return arg.value;
+        }
+        else if (arg.type === 'TemplateLiteral') {
+            // Template literal - возвращаем паттерн
+            const tl = arg;
+            const parts = tl.quasis.map(q => q.value.raw);
+            const expressions = tl.expressions.map(() => '${...}');
+            let result = '';
+            for (let i = 0; i < parts.length; i++) {
+                result += parts[i];
+                if (i < expressions.length) {
+                    result += expressions[i];
+                }
+            }
+            return result;
+        }
+        else if (arg.type === 'BinaryExpression') {
+            const binExpr = arg;
+            if (binExpr.operator === '+') {
+                // String concatenation
+                return this.extractURL(binExpr.left) + this.extractURL(binExpr.right);
+            }
+        }
+        return 'dynamic';
+    }
+    /**
+     * Извлекает HTTP method из options объекта
+     */
+    extractMethod(optionsArg) {
+        if (!optionsArg || optionsArg.type !== 'ObjectExpression') {
+            return null;
+        }
+        const objExpr = optionsArg;
+        const methodProp = objExpr.properties.find(p => p.type === 'ObjectProperty' &&
+            p.key.type === 'Identifier' &&
+            p.key.name === 'method');
+        if (methodProp && methodProp.value) {
+            return this.extractString(methodProp.value);
+        }
+        return null;
+    }
+    /**
+     * Извлекает строковое значение
+     */
+    extractString(node) {
+        if (!node)
+            return null;
+        if (node.type === 'StringLiteral') {
+            return node.value;
+        }
+        return null;
+    }
+    /**
+     * Проверяет является ли URL внешним API
+     */
+    isExternalAPI(url) {
+        if (!url || url === 'unknown' || url === 'dynamic') {
+            return false;
+        }
+        // Внешний API - начинается с http:// или https://
+        return url.startsWith('http://') || url.startsWith('https://');
+    }
+    /**
+     * Извлекает домен из URL
+     */
+    extractDomain(url) {
+        try {
+            const urlObj = new URL(url);
+            return urlObj.hostname;
+        }
+        catch {
+            // Если не получилось распарсить - пытаемся извлечь вручную
+            const match = url.match(/https?:\/\/([^\/\?]+)/);
+            return match ? match[1] : url;
+        }
+    }
+}

package/dist/plugins/analysis/IncrementalAnalysisPlugin.d.ts

@@ -0,0 +1,65 @@
+/**
+ * IncrementalAnalysisPlugin - плагин для инкрементального анализа
+ *
+ * НАЗНАЧЕНИЕ:
+ * Обнаруживает изменённые файлы через VCS (Git) и создаёт __local версии
+ * только для изменённых нод, используя fine-grained merge
+ *
+ * АЛГОРИТМ:
+ * 1. Получить список изменённых файлов из VCS
+ * 2. Для каждого файла:
+ *    - Парсить новый код
+ *    - Получить main версию нод
+ *    - Классифицировать: added/modified/deleted/unchanged
+ *    - Создать __local версии только для added/modified
+ * 3. Переанализировать изменённые ноды для создания связей
+ *
+ * ВЕРСИИ:
+ * - "main" - committed код (git HEAD)
+ * - "__local" - uncommitted изменения
+ */
+import { Plugin } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+export declare class IncrementalAnalysisPlugin extends Plugin {
+    private vcsPlugin;
+    get metadata(): PluginMetadata;
+    initialize(context: PluginContext): Promise<void>;
+    execute(context: PluginContext): Promise<PluginResult>;
+    /**
+     * Обработать один изменённый файл
+     */
+    private processChangedFile;
+    /**
+     * Fine-grained merge - ключевая функция инкрементального анализа
+     */
+    private finegrainedMerge;
+    /**
+     * Извлечь top-level ноды из файла
+     */
+    private extractTopLevelNodes;
+    /**
+     * Проверить, экспортируется ли нода
+     */
+    private isExported;
+    /**
+     * Переанализировать ноды для создания CALLS/USES edges
+     */
+    private reanalyzeNodes;
+    /**
+     * Анализировать вызовы функций внутри функции
+     */
+    private analyzeFunctionCalls;
+    /**
+     * Traverse function body для поиска CALLS
+     */
+    private traverseFunctionBody;
+    /**
+     * Найти callee и создать CALLS edge
+     */
+    private findCalleeAndCreateEdge;
+    /**
+     * Анализировать методы класса
+     */
+    private analyzeClassMethods;
+}
+//# sourceMappingURL=IncrementalAnalysisPlugin.d.ts.map

package/dist/plugins/analysis/IncrementalAnalysisPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IncrementalAnalysisPlugin.d.ts","sourceRoot":"","sources":["../../../src/plugins/analysis/IncrementalAnalysisPlugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,MAAM,EAA0C,MAAM,cAAc,CAAC;AAC9E,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAmDhF,qBAAa,yBAA0B,SAAQ,MAAM;IACnD,OAAO,CAAC,SAAS,CAA0B;IAE3C,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,UAAU,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAcjD,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAyF5D;;OAEG;YACW,kBAAkB;IA8BhC;;OAEG;YACW,gBAAgB;IAmF9B;;OAEG;YACW,oBAAoB;IAiIlC;;OAEG;IACH,OAAO,CAAC,UAAU;IAmClB;;OAEG;YACW,cAAc;IAsC5B;;OAEG;YACW,oBAAoB;IA0ClC;;OAEG;YACW,oBAAoB;IA6DlC;;OAEG;YACW,uBAAuB;IAsCrC;;OAEG;YAEW,mBAAmB;CASlC"}