@grafema/core 0.1.0-alpha.1

package/dist/core/ASTWorker.d.ts

@@ -0,0 +1,133 @@
+/**
+ * ASTWorker - worker thread script for parallel AST parsing
+ *
+ * Receives: { filePath, moduleId, moduleName }
+ * Returns: { collections } - extracted AST data for GraphBuilder
+ */
+/**
+ * Import node structure
+ */
+interface ImportNode {
+    id: string;
+    type: 'IMPORT';
+    name: string;
+    importedName: string;
+    source: string;
+    file: string;
+    line: number;
+}
+/**
+ * Export node structure
+ */
+interface ExportNode {
+    id: string;
+    type: 'EXPORT';
+    name: string;
+    exportType?: string;
+    localName?: string;
+    isDefault?: boolean;
+    file: string;
+    line: number;
+}
+/**
+ * Variable declaration node
+ */
+interface VariableDeclarationNode {
+    id: string;
+    type: 'CONSTANT' | 'VARIABLE';
+    name: string;
+    file: string;
+    line: number;
+    value?: unknown;
+    parentScopeId: string;
+}
+/**
+ * Class instantiation info
+ */
+interface ClassInstantiationInfo {
+    variableId: string;
+    variableName: string;
+    className: string;
+    line: number;
+    parentScopeId: string;
+}
+/**
+ * Function node structure
+ */
+interface FunctionNode {
+    id: string;
+    stableId: string;
+    type: 'FUNCTION' | 'METHOD';
+    name: string;
+    file: string;
+    line: number;
+    column: number;
+    async: boolean;
+    generator?: boolean;
+    exported?: boolean;
+    className?: string;
+    classId?: string;
+    isClassMethod?: boolean;
+    isConstructor?: boolean;
+    isStatic?: boolean;
+}
+/**
+ * Parameter node structure
+ */
+interface ParameterNode {
+    id: string;
+    type: 'PARAMETER';
+    name: string;
+    index: number;
+    functionId: string;
+    file: string;
+    line: number;
+}
+/**
+ * Class declaration node
+ */
+interface ClassDeclarationNode {
+    id: string;
+    type: 'CLASS';
+    name: string;
+    file: string;
+    line: number;
+    superClass: string | null;
+}
+/**
+ * Call site node
+ */
+interface CallSiteNode {
+    id: string;
+    type: 'CALL';
+    name: string;
+    file: string;
+    line: number;
+    parentScopeId: string;
+    targetFunctionName?: string;
+    object?: string;
+    method?: string;
+}
+/**
+ * Collections extracted from AST
+ */
+export interface ASTCollections {
+    functions: FunctionNode[];
+    parameters: ParameterNode[];
+    scopes: unknown[];
+    variableDeclarations: VariableDeclarationNode[];
+    callSites: CallSiteNode[];
+    methodCalls: CallSiteNode[];
+    eventListeners: unknown[];
+    classInstantiations: ClassInstantiationInfo[];
+    classDeclarations: ClassDeclarationNode[];
+    methodCallbacks: unknown[];
+    callArguments: unknown[];
+    imports: ImportNode[];
+    exports: ExportNode[];
+    httpRequests: unknown[];
+    literals: unknown[];
+    variableAssignments: unknown[];
+}
+export {};
+//# sourceMappingURL=ASTWorker.d.ts.map

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

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

package/dist/core/ASTWorker.js

@@ -0,0 +1,352 @@
+/**
+ * ASTWorker - worker thread script for parallel AST parsing
+ *
+ * Receives: { filePath, moduleId, moduleName }
+ * Returns: { collections } - extracted AST data for GraphBuilder
+ */
+import { parentPort } from 'worker_threads';
+import { readFileSync } from 'fs';
+import { parse } from '@babel/parser';
+import traverseModule from '@babel/traverse';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const traverse = traverseModule.default || traverseModule;
+// Simplified visitors for extraction (no graph access needed)
+import { ExpressionEvaluator } from '../plugins/analysis/ast/ExpressionEvaluator.js';
+/**
+ * Parse a single module and extract all collections
+ */
+function parseModule(filePath, moduleId, moduleName) {
+    const code = readFileSync(filePath, 'utf-8');
+    const ast = parse(code, {
+        sourceType: 'module',
+        plugins: ['jsx', 'typescript']
+    });
+    // Collections to extract
+    const collections = {
+        functions: [],
+        parameters: [],
+        scopes: [],
+        variableDeclarations: [],
+        callSites: [],
+        methodCalls: [],
+        eventListeners: [],
+        classInstantiations: [],
+        classDeclarations: [],
+        methodCallbacks: [],
+        callArguments: [],
+        imports: [],
+        exports: [],
+        httpRequests: [],
+        literals: [],
+        variableAssignments: []
+    };
+    // Counters for unique IDs
+    const counters = {
+        ifScope: 0,
+        scope: 0,
+        varDecl: 0,
+        callSite: 0,
+        function: 0,
+        httpRequest: 0,
+        literal: 0
+    };
+    // Processed nodes tracking
+    const processed = {
+        callSites: new Set(),
+        methodCalls: new Set(),
+        varDecls: new Set(),
+        eventListeners: new Set()
+    };
+    const module = { id: moduleId, file: filePath, name: moduleName };
+    // Extract imports
+    traverse(ast, {
+        ImportDeclaration(path) {
+            const node = path.node;
+            const source = node.source.value;
+            node.specifiers.forEach(spec => {
+                let importedName;
+                let localName;
+                if (spec.type === 'ImportDefaultSpecifier') {
+                    importedName = 'default';
+                    localName = spec.local.name;
+                }
+                else if (spec.type === 'ImportNamespaceSpecifier') {
+                    importedName = '*';
+                    localName = spec.local.name;
+                }
+                else {
+                    importedName = spec.imported?.name || spec.local.name;
+                    localName = spec.local.name;
+                }
+                collections.imports.push({
+                    id: `IMPORT#${localName}#${filePath}#${node.loc.start.line}`,
+                    type: 'IMPORT',
+                    name: localName,
+                    importedName,
+                    source,
+                    file: filePath,
+                    line: node.loc.start.line
+                });
+            });
+        }
+    });
+    // Extract exports
+    traverse(ast, {
+        ExportNamedDeclaration(path) {
+            const node = path.node;
+            if (node.declaration) {
+                if (node.declaration.type === 'FunctionDeclaration' && node.declaration.id) {
+                    collections.exports.push({
+                        id: `EXPORT#${node.declaration.id.name}#${filePath}#${node.loc.start.line}`,
+                        type: 'EXPORT',
+                        name: node.declaration.id.name,
+                        exportType: 'function',
+                        file: filePath,
+                        line: node.loc.start.line
+                    });
+                }
+                else if (node.declaration.type === 'ClassDeclaration' && node.declaration.id) {
+                    collections.exports.push({
+                        id: `EXPORT#${node.declaration.id.name}#${filePath}#${node.loc.start.line}`,
+                        type: 'EXPORT',
+                        name: node.declaration.id.name,
+                        exportType: 'class',
+                        file: filePath,
+                        line: node.loc.start.line
+                    });
+                }
+                else if (node.declaration.type === 'VariableDeclaration') {
+                    node.declaration.declarations.forEach(decl => {
+                        if (decl.id.type === 'Identifier') {
+                            collections.exports.push({
+                                id: `EXPORT#${decl.id.name}#${filePath}#${node.loc.start.line}`,
+                                type: 'EXPORT',
+                                name: decl.id.name,
+                                exportType: 'variable',
+                                file: filePath,
+                                line: node.loc.start.line
+                            });
+                        }
+                    });
+                }
+            }
+            if (node.specifiers) {
+                node.specifiers.forEach(spec => {
+                    if (spec.type !== 'ExportSpecifier')
+                        return;
+                    const exportedName = spec.exported.type === 'Identifier' ? spec.exported.name : spec.exported.value;
+                    collections.exports.push({
+                        id: `EXPORT#${exportedName}#${filePath}#${node.loc.start.line}`,
+                        type: 'EXPORT',
+                        name: exportedName,
+                        localName: spec.local.name,
+                        file: filePath,
+                        line: node.loc.start.line
+                    });
+                });
+            }
+        },
+        ExportDefaultDeclaration(path) {
+            const node = path.node;
+            let name = 'default';
+            if (node.declaration.type === 'Identifier') {
+                name = node.declaration.name;
+            }
+            else if ('id' in node.declaration && node.declaration.id) {
+                name = node.declaration.id.name;
+            }
+            collections.exports.push({
+                id: `EXPORT#default#${filePath}#${node.loc.start.line}`,
+                type: 'EXPORT',
+                name: 'default',
+                localName: name,
+                isDefault: true,
+                file: filePath,
+                line: node.loc.start.line
+            });
+        }
+    });
+    // Extract top-level variables
+    traverse(ast, {
+        VariableDeclaration(path) {
+            if (path.getFunctionParent())
+                return;
+            const node = path.node;
+            const isConst = node.kind === 'const';
+            node.declarations.forEach(decl => {
+                if (decl.id.type === 'Identifier') {
+                    const varName = decl.id.name;
+                    const line = decl.id.loc.start.line;
+                    const column = decl.id.loc.start.column;
+                    const literalValue = ExpressionEvaluator.extractLiteralValue(decl.init);
+                    const isLiteral = literalValue !== null;
+                    const isNewExpr = decl.init?.type === 'NewExpression';
+                    const shouldBeConstant = isConst && (isLiteral || isNewExpr);
+                    const varId = shouldBeConstant
+                        ? `CONSTANT#${varName}#${filePath}#${line}:${column}:${counters.varDecl++}`
+                        : `VARIABLE#${varName}#${filePath}#${line}:${column}:${counters.varDecl++}`;
+                    collections.variableDeclarations.push({
+                        id: varId,
+                        type: shouldBeConstant ? 'CONSTANT' : 'VARIABLE',
+                        name: varName,
+                        file: filePath,
+                        line,
+                        value: isLiteral ? literalValue : undefined,
+                        parentScopeId: moduleId
+                    });
+                    if (isNewExpr && decl.init.type === 'NewExpression' && decl.init.callee.type === 'Identifier') {
+                        collections.classInstantiations.push({
+                            variableId: varId,
+                            variableName: varName,
+                            className: (decl.init.callee).name,
+                            line,
+                            parentScopeId: moduleId
+                        });
+                    }
+                }
+            });
+        }
+    });
+    // Extract functions and classes
+    traverse(ast, {
+        FunctionDeclaration(path) {
+            if (path.getFunctionParent())
+                return;
+            const node = path.node;
+            if (!node.id)
+                return;
+            const funcName = node.id.name;
+            const functionId = `FUNCTION#${funcName}#${filePath}#${node.loc.start.line}:${node.loc.start.column}`;
+            collections.functions.push({
+                id: functionId,
+                stableId: functionId,
+                type: 'FUNCTION',
+                name: funcName,
+                file: filePath,
+                line: node.loc.start.line,
+                column: node.loc.start.column,
+                async: node.async || false,
+                generator: node.generator || false,
+                exported: path.parent?.type === 'ExportNamedDeclaration' || path.parent?.type === 'ExportDefaultDeclaration'
+            });
+            // Extract parameters
+            node.params.forEach((param, index) => {
+                if (param.type === 'Identifier') {
+                    collections.parameters.push({
+                        id: `PARAMETER#${param.name}#${functionId}#${index}`,
+                        type: 'PARAMETER',
+                        name: param.name,
+                        index,
+                        functionId,
+                        file: filePath,
+                        line: param.loc.start.line
+                    });
+                }
+            });
+        },
+        ClassDeclaration(path) {
+            if (path.getFunctionParent())
+                return;
+            const node = path.node;
+            if (!node.id)
+                return;
+            const className = node.id.name;
+            const classId = `CLASS#${className}#${filePath}#${node.loc.start.line}`;
+            collections.classDeclarations.push({
+                id: classId,
+                type: 'CLASS',
+                name: className,
+                file: filePath,
+                line: node.loc.start.line,
+                superClass: node.superClass?.name || null
+            });
+            // Extract methods
+            node.body.body.forEach(member => {
+                if (member.type === 'ClassMethod' && member.key.type === 'Identifier') {
+                    const methodName = member.key.name;
+                    const methodId = `METHOD#${className}.${methodName}#${filePath}#${member.loc.start.line}`;
+                    collections.functions.push({
+                        id: methodId,
+                        stableId: methodId,
+                        type: 'METHOD',
+                        name: methodName,
+                        className,
+                        classId,
+                        file: filePath,
+                        line: member.loc.start.line,
+                        column: member.loc.start.column,
+                        async: member.async || false,
+                        isClassMethod: true,
+                        isConstructor: member.kind === 'constructor',
+                        isStatic: member.static || false
+                    });
+                }
+            });
+        }
+    });
+    // Extract call expressions at module level
+    traverse(ast, {
+        CallExpression(path) {
+            if (path.getFunctionParent())
+                return;
+            const node = path.node;
+            const nodeKey = `${node.start}:${node.end}`;
+            if (node.callee.type === 'Identifier') {
+                if (processed.callSites.has(nodeKey))
+                    return;
+                processed.callSites.add(nodeKey);
+                collections.callSites.push({
+                    id: `CALL#${node.callee.name}#${filePath}#${node.loc.start.line}:${node.loc.start.column}:${counters.callSite++}`,
+                    type: 'CALL',
+                    name: node.callee.name,
+                    file: filePath,
+                    line: node.loc.start.line,
+                    parentScopeId: moduleId,
+                    targetFunctionName: node.callee.name
+                });
+            }
+            else if (node.callee.type === 'MemberExpression') {
+                const obj = node.callee.object;
+                const prop = node.callee.property;
+                if ((obj.type === 'Identifier' || obj.type === 'ThisExpression') && prop.type === 'Identifier') {
+                    if (processed.methodCalls.has(nodeKey))
+                        return;
+                    processed.methodCalls.add(nodeKey);
+                    const objectName = obj.type === 'Identifier' ? obj.name : 'this';
+                    const methodName = prop.name;
+                    const fullName = `${objectName}.${methodName}`;
+                    collections.methodCalls.push({
+                        id: `CALL#${fullName}#${filePath}#${node.loc.start.line}:${node.loc.start.column}:${counters.callSite++}`,
+                        type: 'CALL',
+                        name: fullName,
+                        object: objectName,
+                        method: methodName,
+                        file: filePath,
+                        line: node.loc.start.line,
+                        parentScopeId: moduleId
+                    });
+                }
+            }
+        }
+    });
+    return collections;
+}
+// Listen for messages from main thread
+if (parentPort) {
+    parentPort.on('message', (msg) => {
+        if (msg.type === 'parse') {
+            try {
+                const collections = parseModule(msg.filePath, msg.moduleId, msg.moduleName);
+                parentPort.postMessage({ type: 'result', taskId: msg.taskId, collections });
+            }
+            catch (error) {
+                parentPort.postMessage({ type: 'error', taskId: msg.taskId, error: error.message });
+            }
+        }
+        else if (msg.type === 'exit') {
+            process.exit(0);
+        }
+    });
+    // Signal ready
+    parentPort.postMessage({ type: 'ready' });
+}

package/dist/core/ASTWorkerPool.d.ts

@@ -0,0 +1,85 @@
+/**
+ * ASTWorkerPool - pool of worker_threads for parallel AST parsing
+ *
+ * Uses actual OS threads via Node.js worker_threads module
+ * for true parallel CPU-intensive parsing with Babel.
+ */
+import { EventEmitter } from 'events';
+import type { ASTCollections } from './ASTWorker.js';
+/**
+ * Module info for parsing
+ */
+export interface ModuleInfo {
+    id: string;
+    file: string;
+    name: string;
+}
+/**
+ * Parse result
+ */
+export interface ParseResult {
+    module: ModuleInfo;
+    collections: ASTCollections | null;
+    error: Error | null;
+}
+/**
+ * Pool stats
+ */
+export interface ASTWorkerPoolStats {
+    workerCount: number;
+    activeWorkers: number;
+    queuedTasks: number;
+    pendingTasks: number;
+}
+export declare class ASTWorkerPool extends EventEmitter {
+    private workerCount;
+    private workers;
+    private taskQueue;
+    private pendingTasks;
+    private taskIdCounter;
+    private readyWorkers;
+    private initialized;
+    constructor(workerCount?: number);
+    /**
+     * Initialize the worker pool
+     */
+    init(): Promise<void>;
+    /**
+     * Parse a module using a worker thread
+     * Returns promise that resolves to collections
+     */
+    parseModule(filePath: string, moduleId: string, moduleName: string): Promise<ASTCollections>;
+    /**
+     * Parse multiple modules in parallel
+     */
+    parseModules(modules: ModuleInfo[]): Promise<ParseResult[]>;
+    /**
+     * Dispatch task to available worker or queue it
+     */
+    private _dispatchNext;
+    /**
+     * Handle message from worker
+     */
+    private _handleMessage;
+    /**
+     * Mark worker as ready and dispatch queued task
+     */
+    private _workerReady;
+    /**
+     * Handle worker error
+     */
+    private _handleError;
+    /**
+     * Handle worker exit
+     */
+    private _handleExit;
+    /**
+     * Terminate all workers
+     */
+    terminate(): Promise<void>;
+    /**
+     * Get pool stats
+     */
+    getStats(): ASTWorkerPoolStats;
+}
+//# sourceMappingURL=ASTWorkerPool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ASTWorkerPool.d.ts","sourceRoot":"","sources":["../../src/core/ASTWorkerPool.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAGtC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAMrD;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAcD;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,UAAU,CAAC;IACnB,WAAW,EAAE,cAAc,GAAG,IAAI,CAAC;IACnC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CACrB;AAuBD;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,qBAAa,aAAc,SAAQ,YAAY;IAC7C,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,OAAO,CAAW;IAC1B,OAAO,CAAC,SAAS,CAAc;IAC/B,OAAO,CAAC,YAAY,CAAyB;IAC7C,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,YAAY,CAAW;IAC/B,OAAO,CAAC,WAAW,CAAU;gBAEjB,WAAW,GAAE,MAAU;IAWnC;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IA0C3B;;;OAGG;IACH,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;IAY5F;;OAEG;IACG,YAAY,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAYjE;;OAEG;IACH,OAAO,CAAC,aAAa;IAiBrB;;OAEG;IACH,OAAO,CAAC,cAAc;IAwBtB;;OAEG;IACH,OAAO,CAAC,YAAY;IAgBpB;;OAEG;IACH,OAAO,CAAC,YAAY;IAKpB;;OAEG;IACH,OAAO,CAAC,WAAW;IAkBnB;;OAEG;IACG,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAehC;;OAEG;IACH,QAAQ,IAAI,kBAAkB;CAQ/B"}