@grafema/core 0.1.0-alpha.1

package/dist/plugins/analysis/IncrementalAnalysisPlugin.js

@@ -0,0 +1,472 @@
+/**
+ * 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, createSuccessResult, createErrorResult } from '../Plugin.js';
+import { versionManager } from '../../core/VersionManager.js';
+import { VCSPluginFactory } from '../vcs/index.js';
+import { parse } from '@babel/parser';
+import traverseModule from '@babel/traverse';
+import { readFile } from 'fs/promises';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const traverse = traverseModule.default || traverseModule;
+export class IncrementalAnalysisPlugin extends Plugin {
+    vcsPlugin = null;
+    get metadata() {
+        return {
+            name: 'IncrementalAnalysisPlugin',
+            phase: 'ANALYSIS',
+            priority: 85, // Запускается после JSModuleIndexer (90) но перед JSASTAnalyzer (80)
+            creates: {
+                nodes: ['FUNCTION', 'CLASS', 'VARIABLE_DECLARATION'], // Создаёт __local версии
+                edges: ['REPLACES', 'CALLS', 'USES']
+            },
+            dependencies: ['JSModuleIndexer']
+        };
+    }
+    async initialize(context) {
+        // Инициализируем VCS плагин
+        const manifest = context.manifest;
+        this.vcsPlugin = await VCSPluginFactory.detect({
+            rootPath: manifest?.projectPath
+        });
+        if (!this.vcsPlugin) {
+            console.log('[IncrementalAnalysis] No VCS detected, skipping incremental analysis');
+        }
+        else {
+            console.log(`[IncrementalAnalysis] Using VCS: ${this.vcsPlugin.metadata.name}`);
+        }
+    }
+    async execute(context) {
+        try {
+            const { graph } = context;
+            const manifest = context.manifest;
+            const projectPath = manifest?.projectPath ?? '';
+            // Если нет VCS - пропускаем инкрементальный анализ
+            if (!this.vcsPlugin) {
+                return createSuccessResult({ nodes: 0, edges: 0 }, {
+                    skipped: true,
+                    reason: 'No VCS detected'
+                });
+            }
+            // Проверяем наличие uncommitted изменений
+            const hasChanges = await this.vcsPlugin.hasUncommittedChanges();
+            if (!hasChanges) {
+                console.log('[IncrementalAnalysis] No uncommitted changes detected');
+                return createSuccessResult({ nodes: 0, edges: 0 }, {
+                    skipped: true,
+                    reason: 'No uncommitted changes'
+                });
+            }
+            // Получаем список изменённых файлов
+            const changedFiles = (await this.vcsPlugin.getChangedFiles());
+            console.log(`[IncrementalAnalysis] All changed files:`, changedFiles.map(f => f.path));
+            const jsFiles = changedFiles.filter(file => file.path.endsWith('.js') || file.path.endsWith('.mjs') || file.path.endsWith('.cjs'));
+            if (jsFiles.length === 0) {
+                console.log('[IncrementalAnalysis] No JavaScript files changed');
+                return createSuccessResult({ nodes: 0, edges: 0 }, {
+                    skipped: true,
+                    reason: 'No JS files changed'
+                });
+            }
+            console.log(`[IncrementalAnalysis] Found ${jsFiles.length} changed JS files:`, jsFiles.map(f => f.path));
+            let totalNodesCreated = 0;
+            let totalEdgesCreated = 0;
+            // Обрабатываем каждый изменённый файл
+            for (const fileInfo of jsFiles) {
+                const result = await this.processChangedFile(fileInfo, projectPath, graph);
+                totalNodesCreated += result.nodesCreated;
+                totalEdgesCreated += result.edgesCreated;
+            }
+            console.log(`[IncrementalAnalysis] Created ${totalNodesCreated} __local nodes, ${totalEdgesCreated} edges`);
+            return createSuccessResult({ nodes: totalNodesCreated, edges: totalEdgesCreated }, {
+                filesProcessed: jsFiles.length,
+                changedFiles: jsFiles.map(f => ({ path: f.path, status: f.status }))
+            });
+        }
+        catch (error) {
+            console.error('[IncrementalAnalysis] Error:', error);
+            return createErrorResult(error);
+        }
+    }
+    /**
+     * Обработать один изменённый файл
+     */
+    async processChangedFile(fileInfo, projectPath, graph) {
+        const { path: relativePath, status } = fileInfo;
+        // relativePath может начинаться с / или быть относительным
+        const fullPath = relativePath.startsWith('/') ? relativePath : `${projectPath}/${relativePath}`;
+        console.log(`[IncrementalAnalysis] Processing ${relativePath} (${status})`);
+        // Если файл удалён - ничего не делаем (main версия остаётся, __local не создаём)
+        if (status === 'deleted') {
+            console.log(`  → File deleted, keeping main version only`);
+            return { nodesCreated: 0, edgesCreated: 0 };
+        }
+        // Выполняем fine-grained merge
+        const result = await this.finegrainedMerge(fullPath, graph);
+        console.log(`  → Added: ${result.added}, Modified: ${result.modified}, Unchanged: ${result.unchanged}, Deleted: ${result.deleted}`);
+        return {
+            nodesCreated: result.added + result.modified,
+            edgesCreated: result.edgesCreated || 0
+        };
+    }
+    /**
+     * Fine-grained merge - ключевая функция инкрементального анализа
+     */
+    async finegrainedMerge(filePath, graph) {
+        // 1. Парсим новое содержимое файла
+        const newContent = await readFile(filePath, 'utf-8');
+        const newNodes = await this.extractTopLevelNodes(newContent, filePath);
+        console.log(`  → Parsed ${newNodes.length} nodes from new content`);
+        // 2. Получаем существующие main ноды для этого файла
+        const mainNodes = await graph.getNodesByVersion('main', {
+            file: filePath
+        });
+        const mainTopLevel = mainNodes.filter(node => ['FUNCTION', 'CLASS', 'VARIABLE_DECLARATION', 'MODULE'].includes(node.type));
+        console.log(`  → Found ${mainTopLevel.length} existing main nodes`);
+        // 3. Классифицируем изменения
+        const changes = versionManager.classifyChanges(mainTopLevel, newNodes);
+        console.log(`  → Classification: +${changes.added.length} ~${changes.modified.length} =${changes.unchanged.length} -${changes.deleted.length}`);
+        // 4. Создаём __local версии для added/modified нод
+        let edgesCreated = 0;
+        // 4a. ADDED nodes - просто создаём с версией __local
+        for (const node of changes.added) {
+            const enrichedNode = versionManager.enrichNodeWithVersion(node, '__local');
+            await graph.addNode(enrichedNode);
+        }
+        // 4b. MODIFIED nodes - создаём __local версию + REPLACES ребро
+        for (const { old: oldNode, new: newNode } of changes.modified) {
+            const mainNodeId = versionManager.generateVersionedId(oldNode, 'main');
+            const enrichedNode = versionManager.enrichNodeWithVersion(newNode, '__local', {
+                replacesId: mainNodeId
+            });
+            await graph.addNode(enrichedNode);
+            // Создаём REPLACES ребро
+            const replacesEdge = versionManager.createReplacesEdge(enrichedNode.id, mainNodeId);
+            console.log(`    [REPLACES] ${newNode.name}: ${enrichedNode.id} → ${mainNodeId}`);
+            await graph.addEdge({
+                type: replacesEdge.type,
+                src: replacesEdge.fromId,
+                dst: replacesEdge.toId
+            });
+            edgesCreated++;
+        }
+        // 4c. UNCHANGED nodes - не создаём __local версию (используется main)
+        // 4d. DELETED nodes - не создаём __local версию (main остаётся, показывая что было удалено)
+        // 5. Переанализируем изменённые ноды для создания связей (CALLS, USES)
+        const nodesToReanalyze = [...changes.added, ...changes.modified.map(m => m.new)];
+        if (nodesToReanalyze.length > 0) {
+            const reanalyzeResult = await this.reanalyzeNodes(nodesToReanalyze, filePath, '__local', graph);
+            edgesCreated += reanalyzeResult.edgesCreated;
+        }
+        return {
+            added: changes.added.length,
+            modified: changes.modified.length,
+            unchanged: changes.unchanged.length,
+            deleted: changes.deleted.length,
+            edgesCreated
+        };
+    }
+    /**
+     * Извлечь top-level ноды из файла
+     */
+    async extractTopLevelNodes(content, filePath) {
+        const nodes = [];
+        try {
+            // Парсим с помощью Babel
+            const ast = parse(content, {
+                sourceType: 'module',
+                plugins: [
+                    'jsx',
+                    'typescript',
+                    'decorators-legacy',
+                    'classProperties',
+                    'objectRestSpread',
+                    'optionalChaining',
+                    'nullishCoalescingOperator'
+                ]
+            });
+            // Обходим AST и извлекаем top-level декларации
+            traverse(ast, {
+                // Function Declarations (включая export function)
+                FunctionDeclaration: (path) => {
+                    // Только top-level функции (родитель - Program или ExportNamedDeclaration)
+                    const parentType = path.parent.type;
+                    if (parentType !== 'Program' &&
+                        parentType !== 'ExportNamedDeclaration' &&
+                        parentType !== 'ExportDefaultDeclaration') {
+                        return;
+                    }
+                    const node = path.node;
+                    nodes.push({
+                        type: 'FUNCTION',
+                        name: node.id?.name || 'anonymous',
+                        file: filePath,
+                        line: node.loc?.start.line || 0,
+                        column: node.loc?.start.column || 0,
+                        params: node.params.map(p => p.name || p.type),
+                        async: node.async || false,
+                        exported: this.isExported(path) ||
+                            parentType === 'ExportNamedDeclaration' ||
+                            parentType === 'ExportDefaultDeclaration',
+                        bodyHash: versionManager.calculateBodyHash(content.substring(node.body.start, node.body.end)) ?? undefined
+                    });
+                },
+                // Class Declarations
+                ClassDeclaration: (path) => {
+                    const parentType = path.parent.type;
+                    if (parentType !== 'Program' &&
+                        parentType !== 'ExportNamedDeclaration' &&
+                        parentType !== 'ExportDefaultDeclaration') {
+                        return;
+                    }
+                    const node = path.node;
+                    const methods = node.body.body
+                        .filter(member => member.type === 'ClassMethod')
+                        .map(method => method.key.name);
+                    nodes.push({
+                        type: 'CLASS',
+                        name: node.id?.name || 'anonymous',
+                        file: filePath,
+                        line: node.loc?.start.line || 0,
+                        column: node.loc?.start.column || 0,
+                        methods: methods,
+                        exported: this.isExported(path) ||
+                            parentType === 'ExportNamedDeclaration' ||
+                            parentType === 'ExportDefaultDeclaration',
+                        extends: node.superClass?.name || undefined
+                    });
+                },
+                // Variable Declarations (const, let, var)
+                VariableDeclaration: (path) => {
+                    const parentType = path.parent.type;
+                    if (parentType !== 'Program' && parentType !== 'ExportNamedDeclaration') {
+                        return;
+                    }
+                    const node = path.node;
+                    // Каждый declarator - отдельная нода
+                    for (const declarator of node.declarations) {
+                        if (declarator.id.type === 'Identifier') {
+                            nodes.push({
+                                type: 'VARIABLE_DECLARATION',
+                                name: declarator.id.name,
+                                file: filePath,
+                                line: node.loc?.start.line || 0,
+                                column: node.loc?.start.column || 0,
+                                kind: node.kind // const, let, var
+                            });
+                        }
+                    }
+                }
+            });
+        }
+        catch (error) {
+            console.error(`  ✗ Failed to parse ${filePath}:`, error.message);
+        }
+        return nodes;
+    }
+    /**
+     * Проверить, экспортируется ли нода
+     */
+    isExported(path) {
+        // Проверяем родительский узел
+        const parent = path.parent;
+        if (parent.type === 'ExportNamedDeclaration' || parent.type === 'ExportDefaultDeclaration') {
+            return true;
+        }
+        // Проверяем наличие export в том же scope
+        // export { foo, bar }
+        const programPath = path.findParent(p => p.isProgram());
+        if (programPath) {
+            const nodeName = path.node.id?.name;
+            if (!nodeName)
+                return false;
+            let isExported = false;
+            programPath.traverse({
+                ExportNamedDeclaration: (exportPath) => {
+                    const specifiers = exportPath.node.specifiers;
+                    if (specifiers) {
+                        for (const spec of specifiers) {
+                            if (spec.exported?.name === nodeName || spec.local?.name === nodeName) {
+                                isExported = true;
+                            }
+                        }
+                    }
+                }
+            });
+            return isExported;
+        }
+        return false;
+    }
+    /**
+     * Переанализировать ноды для создания CALLS/USES edges
+     */
+    async reanalyzeNodes(nodes, filePath, version, graph) {
+        let edgesCreated = 0;
+        try {
+            // Читаем файл заново
+            const content = await readFile(filePath, 'utf-8');
+            // Парсим AST
+            const ast = parse(content, {
+                sourceType: 'module',
+                plugins: ['jsx', 'typescript', 'decorators-legacy']
+            });
+            // Для каждой ноды ищем её в AST и анализируем
+            for (const node of nodes) {
+                if (node.type === 'FUNCTION') {
+                    const functionEdges = await this.analyzeFunctionCalls(node, ast, version, graph);
+                    edgesCreated += functionEdges;
+                }
+                else if (node.type === 'CLASS') {
+                    const classEdges = await this.analyzeClassMethods(node, ast, version, graph);
+                    edgesCreated += classEdges;
+                }
+            }
+            console.log(`  → Reanalyzed ${nodes.length} nodes, created ${edgesCreated} edges`);
+            return { edgesCreated };
+        }
+        catch (error) {
+            console.error(`[IncrementalAnalysis] Error reanalyzing nodes:`, error);
+            return { edgesCreated: 0 };
+        }
+    }
+    /**
+     * Анализировать вызовы функций внутри функции
+     */
+    async analyzeFunctionCalls(functionNode, ast, version, graph) {
+        let edgesCreated = 0;
+        let functionPath = null;
+        // Ищем функцию в AST по имени
+        traverse(ast, {
+            FunctionDeclaration: (path) => {
+                const node = path.node;
+                if (node.id?.name === functionNode.name) {
+                    functionPath = path;
+                    path.stop();
+                }
+            },
+            // Arrow functions и function expressions в VariableDeclaration
+            VariableDeclarator: (path) => {
+                const node = path.node;
+                if (node.id?.name === functionNode.name) {
+                    if (node.init?.type === 'ArrowFunctionExpression' ||
+                        node.init?.type === 'FunctionExpression') {
+                        functionPath = path.get('init');
+                        path.stop();
+                    }
+                }
+            }
+        });
+        // Если нашли функцию, анализируем её тело
+        if (functionPath) {
+            edgesCreated = await this.traverseFunctionBody(functionPath, functionNode, version, graph);
+        }
+        return edgesCreated;
+    }
+    /**
+     * Traverse function body для поиска CALLS
+     */
+    async traverseFunctionBody(path, functionNode, version, graph) {
+        const callSites = [];
+        // Собираем все CallExpression внутри функции
+        path.traverse({
+            CallExpression: (callPath) => {
+                const node = callPath.node;
+                const callee = node.callee;
+                // Простые вызовы: foo()
+                if (callee.type === 'Identifier') {
+                    callSites.push({
+                        callee: callee.name,
+                        type: 'FUNCTION_CALL'
+                    });
+                }
+                // Method calls: obj.method()
+                else if (callee.type === 'MemberExpression') {
+                    const objectName = callee.object?.name;
+                    const methodName = callee.property?.name;
+                    if (objectName && methodName) {
+                        callSites.push({
+                            callee: `${objectName}.${methodName}`,
+                            object: objectName,
+                            method: methodName,
+                            type: 'METHOD_CALL'
+                        });
+                    }
+                }
+            }
+        });
+        // Создаём CALLS edges для каждого call site (последовательно)
+        let edgesCreated = 0;
+        for (const callSite of callSites) {
+            // Генерируем ID для caller (__local версия)
+            const callerId = versionManager.generateVersionedId(functionNode, version);
+            // Пытаемся найти callee в графе (сначала __local, потом main)
+            const calleeName = callSite.callee.split('.')[0]; // Для method calls берём объект
+            const calleeStableId = `FUNCTION:${calleeName}:${functionNode.file}`;
+            // Ищем callee в базе
+            try {
+                const created = await this.findCalleeAndCreateEdge(callerId, calleeStableId, version, graph);
+                if (created)
+                    edgesCreated++;
+            }
+            catch (err) {
+                console.error(`[IncrementalAnalysis] Error creating CALLS edge:`, err);
+            }
+        }
+        return edgesCreated;
+    }
+    /**
+     * Найти callee и создать CALLS edge
+     */
+    async findCalleeAndCreateEdge(callerId, calleeStableId, version, graph) {
+        try {
+            // Ищем callee сначала в __local, потом в main
+            const calleeVersions = await graph.getNodesByStableId(calleeStableId);
+            if (calleeVersions.length === 0) {
+                // Callee не найден - возможно это external функция
+                return false;
+            }
+            // Предпочитаем __local версию, если есть
+            const calleeNode = calleeVersions.find(n => n.version === '__local') ||
+                calleeVersions.find(n => n.version === 'main');
+            if (!calleeNode) {
+                return false;
+            }
+            // Создаём CALLS edge
+            await graph.addEdge({
+                type: 'CALLS',
+                src: callerId,
+                dst: calleeNode.id
+            });
+            return true;
+        }
+        catch (error) {
+            console.error(`[IncrementalAnalysis] Error finding callee:`, error);
+            return false;
+        }
+    }
+    /**
+     * Анализировать методы класса
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async analyzeClassMethods(_classNode, _ast, _version, _graph) {
+        // TODO: реализовать анализ методов класса
+        return 0;
+    }
+}

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

@@ -0,0 +1,84 @@
+/**
+ * JSASTAnalyzer - плагин для парсинга JavaScript AST
+ * Создаёт ноды: FUNCTION, CLASS, METHOD и т.д.
+ */
+import type { NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+import { Plugin } from '../Plugin.js';
+import { type VisitorModule, type VisitorCollections } from './ast/visitors/index.js';
+import type { PluginContext, PluginResult, PluginMetadata, GraphBackend } from '@grafema/types';
+import type { ModuleNode, LiteralInfo, VariableAssignmentInfo, CounterRef, ExtractedVariable } from './ast/types.js';
+/**
+ * Context for tracking semantic IDs within a scope hierarchy.
+ * Used to generate stable, line-number-independent IDs for SCOPE nodes.
+ */
+interface ScopeContext {
+    semanticPath: string;
+    siblingCounters: Map<string, number>;
+}
+interface AnalysisManifest {
+    projectPath: string;
+    [key: string]: unknown;
+}
+interface AnalyzeContext extends PluginContext {
+    manifest?: AnalysisManifest;
+    forceAnalysis?: boolean;
+    workerCount?: number;
+    onProgress?: (info: Record<string, unknown>) => void;
+}
+export declare class JSASTAnalyzer extends Plugin {
+    private graphBuilder;
+    private analyzedModules;
+    private profiler;
+    private _cacheCleared;
+    constructor();
+    get metadata(): PluginMetadata;
+    /**
+     * Вычисляет хеш содержимого файла
+     */
+    calculateFileHash(filePath: string): string | null;
+    /**
+     * Проверяет нужно ли анализировать модуль (сравнивает хеши)
+     */
+    shouldAnalyzeModule(module: ModuleNode, graph: GraphBackend, forceAnalysis: boolean): Promise<boolean>;
+    execute(context: AnalyzeContext): Promise<PluginResult>;
+    /**
+     * Extract variable names from destructuring patterns
+     * Uses t.isX() type guards to avoid casts
+     */
+    extractVariableNamesFromPattern(pattern: t.Node | null | undefined, variables?: ExtractedVariable[], propertyPath?: string[]): ExtractedVariable[];
+    /**
+     * Отслеживает присваивание переменной для data flow анализа
+     */
+    trackVariableAssignment(initNode: t.Expression | null | undefined, variableId: string, variableName: string, module: VisitorModule, line: number, literals: LiteralInfo[], variableAssignments: VariableAssignmentInfo[], literalCounterRef: CounterRef): void;
+    /**
+     * Получить все MODULE ноды из графа
+     */
+    private getModuleNodes;
+    /**
+     * Анализировать один модуль
+     */
+    analyzeModule(module: ModuleNode, graph: GraphBackend, projectPath: string): Promise<{
+        nodes: number;
+        edges: number;
+    }>;
+    /**
+     * Helper to generate semantic ID for a scope and update counters
+     */
+    private generateSemanticId;
+    /**
+     * Helper to create child scope context from a semantic ID
+     */
+    private createChildScopeContext;
+    /**
+     * Generate a unique anonymous function name within the current scope
+     * Uses scopeCtx.siblingCounters to ensure stability across JS/TS versions
+     */
+    private generateAnonymousName;
+    /**
+     * Анализирует тело функции и извлекает переменные, вызовы, условные блоки
+     */
+    analyzeFunctionBody(funcPath: NodePath<t.Function>, parentScopeId: string, module: VisitorModule, collections: VisitorCollections, scopeCtx?: ScopeContext): void;
+}
+export {};
+//# sourceMappingURL=JSASTAnalyzer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"JSASTAnalyzer.d.ts","sourceRoot":"","sources":["../../../src/plugins/analysis/JSASTAnalyzer.ts"],"names":[],"mappings":"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"}