@grafema/core 0.1.0-alpha.1

package/dist/core/Task.js

@@ -0,0 +1,85 @@
+/**
+ * Task - базовая единица работы в очереди
+ */
+export class Task {
+    id;
+    type;
+    priority;
+    data;
+    dependencies;
+    status;
+    result;
+    error;
+    startedAt;
+    completedAt;
+    retries;
+    maxRetries;
+    constructor({ id, type, priority = 50, data, dependencies = [] }) {
+        this.id = id;
+        this.type = type;
+        this.priority = priority;
+        this.data = data;
+        this.dependencies = dependencies;
+        this.status = 'pending';
+        this.result = null;
+        this.error = null;
+        this.startedAt = null;
+        this.completedAt = null;
+        this.retries = 0;
+        this.maxRetries = 3;
+    }
+    /**
+     * Может ли задача выполняться (все зависимости готовы)
+     */
+    canExecute(completedTasks) {
+        return this.dependencies.every(depId => completedTasks.has(depId));
+    }
+    /**
+     * Начать выполнение
+     */
+    start() {
+        this.status = 'running';
+        this.startedAt = Date.now();
+    }
+    /**
+     * Завершить успешно
+     */
+    complete(result) {
+        this.status = 'completed';
+        this.result = result;
+        this.completedAt = Date.now();
+    }
+    /**
+     * Завершить с ошибкой
+     */
+    fail(error) {
+        this.status = 'failed';
+        this.error = error;
+        this.completedAt = Date.now();
+    }
+    /**
+     * Можно ли повторить
+     */
+    canRetry() {
+        return this.retries < this.maxRetries;
+    }
+    /**
+     * Повторить задачу
+     */
+    retry() {
+        this.retries++;
+        this.status = 'pending';
+        this.error = null;
+        this.startedAt = null;
+        this.completedAt = null;
+    }
+    /**
+     * Продолжительность выполнения (мс)
+     */
+    get duration() {
+        if (!this.startedAt)
+            return 0;
+        const end = this.completedAt || Date.now();
+        return end - this.startedAt;
+    }
+}

package/dist/core/TaskTypes.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Task Types - конкретные типы данных для задач
+ *
+ * Extensibility: добавляйте новые типы в TaskData union
+ */
+import type { ModuleNode } from '../plugins/analysis/ast/types.js';
+export type TaskType = 'ANALYZE_MODULE';
+/**
+ * Данные для ANALYZE_MODULE задачи
+ */
+export interface AnalyzeModuleData {
+    module: ModuleNode;
+}
+/**
+ * Union всех возможных TaskData
+ * Расширяется при добавлении новых типов задач
+ */
+export type TaskData = AnalyzeModuleData;
+export declare function isAnalyzeModuleData(data: TaskData): data is AnalyzeModuleData;
+//# sourceMappingURL=TaskTypes.d.ts.map

package/dist/core/TaskTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TaskTypes.d.ts","sourceRoot":"","sources":["../../src/core/TaskTypes.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAC;AAGnE,MAAM,MAAM,QAAQ,GAAG,gBAAgB,CAAC;AAKxC;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,UAAU,CAAC;CACpB;AASD;;;GAGG;AACH,MAAM,MAAM,QAAQ,GAAG,iBAAiB,CAAC;AAKzC,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,IAAI,iBAAiB,CAE7E"}

package/dist/core/TaskTypes.js

@@ -0,0 +1,10 @@
+/**
+ * Task Types - конкретные типы данных для задач
+ *
+ * Extensibility: добавляйте новые типы в TaskData union
+ */
+// При добавлении: AnalyzeModuleData | NewTypeData;
+// === TYPE GUARDS ===
+export function isAnalyzeModuleData(data) {
+    return 'module' in data && data.module !== null && typeof data.module === 'object';
+}

package/dist/core/VersionManager.d.ts

@@ -0,0 +1,166 @@
+/**
+ * VersionManager - управление версиями нод для incremental analysis
+ *
+ * КОНЦЕПЦИЯ:
+ * - Храним несколько версий кода одновременно (main, __local, branch names)
+ * - Используем stable IDs для сравнения версий
+ * - Поддерживаем fine-grained merge (только изменённые ноды)
+ *
+ * ВЕРСИИ:
+ * - "main" - committed код из git HEAD
+ * - "__local" - uncommitted изменения (working directory)
+ * - "branch-name" - другие ветки (будущее)
+ */
+/**
+ * Version constants
+ */
+export interface VersionConstants {
+    MAIN: 'main';
+    LOCAL: '__local';
+}
+/**
+ * Node types for stable ID generation
+ */
+export type StableIdNodeType = 'FUNCTION' | 'CLASS' | 'INTERFACE' | 'TYPE_ALIAS' | 'VARIABLE_DECLARATION' | 'MODULE' | 'SERVICE' | 'CALL_SITE' | 'SCOPE' | 'EXPRESSION' | 'STATEMENT' | 'DATABASE_QUERY' | 'HTTP_REQUEST' | 'FILESYSTEM' | 'NETWORK' | 'ENDPOINT';
+/**
+ * Node for stable ID generation
+ */
+export interface VersionedNode {
+    type: string;
+    name?: string;
+    file?: string;
+    line?: number;
+    column?: number;
+    query?: string;
+    url?: string;
+    path?: string;
+    endpoint?: string;
+    params?: unknown[];
+    returnType?: string;
+    async?: boolean;
+    exported?: boolean;
+    bodyHash?: string;
+    methods?: unknown[];
+    properties?: unknown[];
+    extends?: string;
+    implements?: string[];
+    kind?: string;
+    value?: unknown;
+    contentHash?: string;
+    imports?: unknown[];
+    exports?: unknown[];
+    arguments?: unknown[];
+    callee?: string;
+    operation?: string;
+    collection?: string;
+    method?: string;
+    handler?: string;
+    id?: string;
+    version?: string;
+    _stableId?: string;
+    _replaces?: string;
+    updatedAt?: number;
+}
+/**
+ * REPLACES edge structure
+ */
+export interface ReplacesEdge {
+    type: 'REPLACES';
+    fromId: string;
+    toId: string;
+    version: string;
+}
+/**
+ * Enrichment options
+ */
+export interface EnrichOptions {
+    replacesId?: string;
+}
+/**
+ * Modified node info
+ */
+export interface ModifiedNodeInfo {
+    old: VersionedNode;
+    new: VersionedNode;
+    stableId: string;
+}
+/**
+ * Changes summary
+ */
+export interface ChangesSummary {
+    addedCount: number;
+    modifiedCount: number;
+    unchangedCount: number;
+    deletedCount: number;
+    totalChanges: number;
+}
+/**
+ * Classification result
+ */
+export interface ClassifyChangesResult {
+    added: VersionedNode[];
+    modified: ModifiedNodeInfo[];
+    unchanged: VersionedNode[];
+    deleted: VersionedNode[];
+    summary: ChangesSummary;
+}
+export declare class VersionManager {
+    readonly versions: VersionConstants;
+    constructor();
+    /**
+     * Генерировать stable ID для ноды (без версии)
+     *
+     * Stable ID остаётся одинаковым для одной и той же сущности
+     * в разных версиях кода
+     */
+    generateStableId(node: VersionedNode): string;
+    /**
+     * Генерировать versioned ID для ноды
+     */
+    generateVersionedId(node: VersionedNode, version: string): string;
+    /**
+     * Извлечь stable ID из versioned ID
+     */
+    extractStableId(versionedId: string): string;
+    /**
+     * Извлечь версию из versioned ID
+     */
+    extractVersion(versionedId: string): string;
+    /**
+     * Проверить, имеет ли нода структурные изменения
+     */
+    hasStructuralChanges(oldNode: VersionedNode, newNode: VersionedNode): boolean;
+    /**
+     * Получить ключи для сравнения в зависимости от типа ноды
+     */
+    private _getComparisonKeys;
+    /**
+     * Вычислить хеш тела функции для сравнения
+     */
+    calculateBodyHash(bodySource: string | null | undefined): string | null;
+    /**
+     * Создать REPLACES ребро между версиями
+     */
+    createReplacesEdge(localNodeId: string, mainNodeId: string): ReplacesEdge;
+    /**
+     * Дополнить ноду полями для version-aware анализа
+     */
+    enrichNodeWithVersion(node: VersionedNode, version: string, options?: EnrichOptions): VersionedNode;
+    /**
+     * Классифицировать изменения между версиями
+     */
+    classifyChanges(mainNodes: VersionedNode[], localNodes: VersionedNode[]): ClassifyChangesResult;
+    /**
+     * Проверить, является ли версия локальной (uncommitted)
+     */
+    isLocalVersion(version: string): boolean;
+    /**
+     * Проверить, является ли версия основной (committed)
+     */
+    isMainVersion(version: string): boolean;
+}
+/**
+ * Singleton instance
+ */
+export declare const versionManager: VersionManager;
+//# sourceMappingURL=VersionManager.d.ts.map

package/dist/core/VersionManager.d.ts.map

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

package/dist/core/VersionManager.js

@@ -0,0 +1,237 @@
+/**
+ * VersionManager - управление версиями нод для incremental analysis
+ *
+ * КОНЦЕПЦИЯ:
+ * - Храним несколько версий кода одновременно (main, __local, branch names)
+ * - Используем stable IDs для сравнения версий
+ * - Поддерживаем fine-grained merge (только изменённые ноды)
+ *
+ * ВЕРСИИ:
+ * - "main" - committed код из git HEAD
+ * - "__local" - uncommitted изменения (working directory)
+ * - "branch-name" - другие ветки (будущее)
+ */
+import { createHash } from 'crypto';
+export class VersionManager {
+    versions;
+    constructor() {
+        this.versions = {
+            MAIN: 'main',
+            LOCAL: '__local'
+        };
+    }
+    /**
+     * Генерировать stable ID для ноды (без версии)
+     *
+     * Stable ID остаётся одинаковым для одной и той же сущности
+     * в разных версиях кода
+     */
+    generateStableId(node) {
+        const { type, name, file, line, column } = node;
+        // Для FUNCTION, CLASS - используем type:name:file
+        if (['FUNCTION', 'CLASS', 'INTERFACE', 'TYPE_ALIAS'].includes(type)) {
+            return `${type}:${name}:${file}`;
+        }
+        // Для VARIABLE_DECLARATION - добавляем line для различения локальных переменных
+        if (type === 'VARIABLE_DECLARATION') {
+            return `${type}:${name}:${file}:${line || 0}`;
+        }
+        // Для MODULE - только file
+        if (type === 'MODULE') {
+            return `MODULE:${file}`;
+        }
+        // Для SERVICE - используем имя или file
+        if (type === 'SERVICE') {
+            return `SERVICE:${name || file}`;
+        }
+        // Для вложенных нод (CALL_SITE, SCOPE, EXPRESSION) - используем file:line:column
+        if (['CALL_SITE', 'SCOPE', 'EXPRESSION', 'STATEMENT'].includes(type)) {
+            return `${type}:${file}:${line || 0}:${column || 0}`;
+        }
+        // Для EXTERNAL нод (DATABASE_QUERY, HTTP_REQUEST) - используем содержимое
+        if (['DATABASE_QUERY', 'HTTP_REQUEST', 'FILESYSTEM', 'NETWORK'].includes(type)) {
+            // Используем хеш содержимого для уникальности
+            const content = node.query || node.url || node.path || node.endpoint || '';
+            const hash = createHash('sha256').update(content).digest('hex').substring(0, 16);
+            return `${type}:${hash}`;
+        }
+        // По умолчанию - используем все доступные поля
+        const parts = [type, name, file, line, column].filter(p => p !== undefined && p !== null);
+        return parts.join(':');
+    }
+    /**
+     * Генерировать versioned ID для ноды
+     */
+    generateVersionedId(node, version) {
+        const stableId = this.generateStableId(node);
+        return `${stableId}:${version}`;
+    }
+    /**
+     * Извлечь stable ID из versioned ID
+     */
+    extractStableId(versionedId) {
+        const lastColonIndex = versionedId.lastIndexOf(':');
+        return versionedId.substring(0, lastColonIndex);
+    }
+    /**
+     * Извлечь версию из versioned ID
+     */
+    extractVersion(versionedId) {
+        const lastColonIndex = versionedId.lastIndexOf(':');
+        return versionedId.substring(lastColonIndex + 1);
+    }
+    /**
+     * Проверить, имеет ли нода структурные изменения
+     */
+    hasStructuralChanges(oldNode, newNode) {
+        // Список ключевых полей для сравнения (зависит от типа ноды)
+        const keysToCompare = this._getComparisonKeys(oldNode.type);
+        for (const key of keysToCompare) {
+            const oldValue = oldNode[key];
+            const newValue = newNode[key];
+            // Глубокое сравнение для массивов и объектов
+            if (JSON.stringify(oldValue) !== JSON.stringify(newValue)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Получить ключи для сравнения в зависимости от типа ноды
+     */
+    _getComparisonKeys(nodeType) {
+        const commonKeys = ['name', 'line', 'column'];
+        const typeSpecificKeys = {
+            FUNCTION: ['params', 'returnType', 'async', 'exported', 'bodyHash'],
+            CLASS: ['methods', 'properties', 'extends', 'implements', 'exported'],
+            VARIABLE_DECLARATION: ['kind', 'value', 'exported'],
+            MODULE: ['contentHash', 'imports', 'exports'],
+            CALL_SITE: ['arguments', 'callee'],
+            DATABASE_QUERY: ['query', 'operation', 'collection'],
+            HTTP_REQUEST: ['method', 'url', 'endpoint'],
+            ENDPOINT: ['path', 'method', 'handler']
+        };
+        return [...commonKeys, ...(typeSpecificKeys[nodeType] || [])];
+    }
+    /**
+     * Вычислить хеш тела функции для сравнения
+     */
+    calculateBodyHash(bodySource) {
+        if (!bodySource)
+            return null;
+        // Нормализуем код: убираем пробелы и комментарии для сравнения
+        const normalized = bodySource
+            .replace(/\/\*[\s\S]*?\*\//g, '') // Блочные комментарии
+            .replace(/\/\/.*/g, '') // Строчные комментарии
+            .replace(/\s+/g, ' ') // Множественные пробелы -> один пробел
+            .trim();
+        return createHash('sha256').update(normalized, 'utf-8').digest('hex');
+    }
+    /**
+     * Создать REPLACES ребро между версиями
+     */
+    createReplacesEdge(localNodeId, mainNodeId) {
+        return {
+            type: 'REPLACES',
+            fromId: localNodeId,
+            toId: mainNodeId,
+            version: '__local' // Edge тоже имеет версию
+        };
+    }
+    /**
+     * Дополнить ноду полями для version-aware анализа
+     */
+    enrichNodeWithVersion(node, version, options = {}) {
+        const stableId = this.generateStableId(node);
+        const versionedId = this.generateVersionedId(node, version);
+        const enriched = {
+            ...node,
+            id: versionedId,
+            version: version,
+            _stableId: stableId
+        };
+        // Добавляем _replaces если это замена main версии
+        if (options.replacesId) {
+            enriched._replaces = options.replacesId;
+        }
+        // Добавляем timestamp
+        if (!enriched.updatedAt) {
+            enriched.updatedAt = Date.now();
+        }
+        return enriched;
+    }
+    /**
+     * Классифицировать изменения между версиями
+     */
+    classifyChanges(mainNodes, localNodes) {
+        // Создаём Map по stable ID
+        const mainMap = new Map();
+        for (const node of mainNodes) {
+            const stableId = this.generateStableId(node);
+            mainMap.set(stableId, node);
+        }
+        const localMap = new Map();
+        for (const node of localNodes) {
+            const stableId = this.generateStableId(node);
+            localMap.set(stableId, node);
+        }
+        // Классификация
+        const added = [];
+        const modified = [];
+        const unchanged = [];
+        const deleted = [];
+        // Проверяем локальные ноды
+        for (const [stableId, localNode] of localMap) {
+            if (!mainMap.has(stableId)) {
+                // Нода добавлена
+                added.push(localNode);
+            }
+            else {
+                const mainNode = mainMap.get(stableId);
+                if (this.hasStructuralChanges(mainNode, localNode)) {
+                    // Нода изменена
+                    modified.push({ old: mainNode, new: localNode, stableId });
+                }
+                else {
+                    // Нода не изменилась
+                    unchanged.push(localNode);
+                }
+            }
+        }
+        // Проверяем удалённые ноды (есть в main, нет в local)
+        for (const [stableId, mainNode] of mainMap) {
+            if (!localMap.has(stableId)) {
+                deleted.push(mainNode);
+            }
+        }
+        return {
+            added, // Новые ноды
+            modified, // Изменённые ноды
+            unchanged, // Неизменённые ноды
+            deleted, // Удалённые ноды
+            summary: {
+                addedCount: added.length,
+                modifiedCount: modified.length,
+                unchangedCount: unchanged.length,
+                deletedCount: deleted.length,
+                totalChanges: added.length + modified.length + deleted.length
+            }
+        };
+    }
+    /**
+     * Проверить, является ли версия локальной (uncommitted)
+     */
+    isLocalVersion(version) {
+        return version === this.versions.LOCAL;
+    }
+    /**
+     * Проверить, является ли версия основной (committed)
+     */
+    isMainVersion(version) {
+        return version === this.versions.MAIN;
+    }
+}
+/**
+ * Singleton instance
+ */
+export const versionManager = new VersionManager();

package/dist/core/WorkerPool.d.ts

@@ -0,0 +1,82 @@
+/**
+ * WorkerPool - worker pool for parallel task execution
+ *
+ * Key property: HORIZONTAL SCALING
+ * More workers = faster processing (up to CPU/IO limit)
+ */
+import { EventEmitter } from 'events';
+import type { Task, QueueStats } from './PriorityQueue.js';
+/**
+ * Task handler function type
+ */
+export type TaskHandler = (task: Task) => Promise<unknown>;
+/**
+ * Handler registry
+ */
+export interface TaskHandlers {
+    [taskType: string]: TaskHandler;
+}
+/**
+ * Queue interface for WorkerPool
+ */
+export interface WorkerQueue {
+    isEmpty: boolean;
+    next(): Task | null;
+    complete(taskId: string, result: unknown): void;
+    fail(taskId: string, error: Error): void;
+    getStats(): QueueStats;
+}
+/**
+ * Worker pool statistics
+ */
+export interface WorkerPoolStats {
+    workerCount: number;
+    activeWorkers: number;
+    running: boolean;
+}
+export interface WorkerTaskStartEvent {
+    workerId: number;
+    task: Task;
+}
+export interface WorkerTaskCompletedEvent {
+    workerId: number;
+    task: Task;
+    result: unknown;
+}
+export interface WorkerTaskFailedEvent {
+    workerId: number;
+    task: Task;
+    error: unknown;
+}
+export declare class WorkerPool extends EventEmitter {
+    private workerCount;
+    private handlers;
+    private activeWorkers;
+    private running;
+    constructor(workerCount?: number, handlers?: TaskHandlers);
+    /**
+     * Register handler for task type
+     */
+    registerHandler(taskType: string, handler: TaskHandler): void;
+    /**
+     * Start queue processing
+     */
+    processQueue(queue: WorkerQueue): Promise<void>;
+    /**
+     * Worker - picks task from queue and executes
+     */
+    private _worker;
+    /**
+     * Sleep helper
+     */
+    private _sleep;
+    /**
+     * Stop pool (graceful shutdown)
+     */
+    stop(): Promise<void>;
+    /**
+     * Statistics
+     */
+    getStats(): WorkerPoolStats;
+}
+//# sourceMappingURL=WorkerPool.d.ts.map

package/dist/core/WorkerPool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkerPool.d.ts","sourceRoot":"","sources":["../../src/core/WorkerPool.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAE3D;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;AAE3D;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,CAAC;CACjC;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,IAAI,IAAI,GAAG,IAAI,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI,CAAC;IAChD,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACzC,QAAQ,IAAI,UAAU,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,OAAO,CAAC;CAClB;AAID,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,IAAI,CAAC;CACZ;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,IAAI,CAAC;IACX,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,IAAI,CAAC;IACX,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,qBAAa,UAAW,SAAQ,YAAY;IAC1C,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,QAAQ,CAAe;IAC/B,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,OAAO,CAAU;gBAEb,WAAW,GAAE,MAAW,EAAE,QAAQ,GAAE,YAAiB;IAQjE;;OAEG;IACH,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,GAAG,IAAI;IAI7D;;OAEG;IACG,YAAY,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBrD;;OAEG;YACW,OAAO;IA2CrB;;OAEG;IACH,OAAO,CAAC,MAAM;IAId;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAW3B;;OAEG;IACH,QAAQ,IAAI,eAAe;CAO5B"}