@grafema/core 0.1.0-alpha.5 → 0.2.0-beta

package/src/validation/PathValidator.ts

@@ -50,7 +50,7 @@ export interface PathValidationResult {
 /**
  * Endpoint diff info
  */
-interface EndpointDiff {
+export interface EndpointDiff {
   type: string;
   name: string;
   reason: string;

package/dist/core/AnalysisWorker.d.ts

@@ -1,14 +0,0 @@
-/**
- * AnalysisWorker - worker thread for parallel AST analysis
- *
- * Each worker:
- * 1. Connects to RFDB server
- * 2. Receives file paths to analyze
- * 3. Parses AST and writes nodes/edges directly to RFDB
- *
- * Communication:
- *   Main -> Worker: { type: 'analyze', file, moduleId, moduleName }
- *   Worker -> Main: { type: 'done', file, stats } | { type: 'error', file, error }
- */
-export {};
-//# sourceMappingURL=AnalysisWorker.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"AnalysisWorker.d.ts","sourceRoot":"","sources":["../../src/core/AnalysisWorker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG"}

package/dist/core/AnalysisWorker.js

@@ -1,307 +0,0 @@
-/**
- * AnalysisWorker - worker thread for parallel AST analysis
- *
- * Each worker:
- * 1. Connects to RFDB server
- * 2. Receives file paths to analyze
- * 3. Parses AST and writes nodes/edges directly to RFDB
- *
- * Communication:
- *   Main -> Worker: { type: 'analyze', file, moduleId, moduleName }
- *   Worker -> Main: { type: 'done', file, stats } | { type: 'error', file, error }
- */
-import { parentPort, workerData } from 'worker_threads';
-import { readFileSync } from 'fs';
-import { parse } from '@babel/parser';
-import traverseModule from '@babel/traverse';
-import { RFDBClient } from '@grafema/rfdb-client';
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const traverse = traverseModule.default || traverseModule;
-// Worker state
-let client = null;
-const workerId = workerData?.workerId || 0;
-let socketPath = workerData?.socketPath || '/tmp/rfdb.sock';
-let connected = false;
-/**
- * Connect to RFDB server
- */
-async function connect() {
-    if (connected)
-        return;
-    client = new RFDBClient(socketPath);
-    await client.connect();
-    connected = true;
-    parentPort?.postMessage({ type: 'ready', workerId });
-}
-/**
- * Parse a file and write results directly to RFDB
- */
-async function analyzeFile(filePath, moduleId, moduleName) {
-    const stats = { nodes: 0, edges: 0, functions: 0, calls: 0 };
-    try {
-        const code = readFileSync(filePath, 'utf-8');
-        const ast = parse(code, {
-            sourceType: 'module',
-            plugins: ['jsx', 'typescript'],
-            errorRecovery: true
-        });
-        // Collections to batch write
-        const nodes = [];
-        const edges = [];
-        // Counters for unique IDs
-        let callCounter = 0;
-        // Add module node
-        nodes.push({
-            id: moduleId,
-            type: 'MODULE',
-            name: moduleName,
-            file: filePath
-        });
-        // 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;
-                    }
-                    const importId = `IMPORT#${localName}#${filePath}#${node.loc.start.line}`;
-                    nodes.push({
-                        id: importId,
-                        type: 'IMPORT',
-                        name: localName,
-                        file: filePath,
-                        metadata: JSON.stringify({ importedName, source, line: node.loc.start.line })
-                    });
-                    edges.push({ src: moduleId, dst: importId, type: 'CONTAINS' });
-                });
-            }
-        });
-        // Extract functions
-        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}`;
-                nodes.push({
-                    id: functionId,
-                    type: 'FUNCTION',
-                    name: funcName,
-                    file: filePath,
-                    metadata: JSON.stringify({
-                        line: node.loc.start.line,
-                        async: node.async || false,
-                        generator: node.generator || false,
-                        exported: path.parent?.type?.includes('Export') || false
-                    })
-                });
-                edges.push({ src: moduleId, dst: functionId, type: 'CONTAINS' });
-                stats.functions++;
-                // Extract parameters
-                node.params.forEach((param, index) => {
-                    if (param.type === 'Identifier') {
-                        const paramId = `PARAMETER#${param.name}#${functionId}#${index}`;
-                        nodes.push({
-                            id: paramId,
-                            type: 'PARAMETER',
-                            name: param.name,
-                            file: filePath,
-                            metadata: JSON.stringify({ index, functionId })
-                        });
-                        edges.push({ src: functionId, dst: paramId, type: 'CONTAINS' });
-                    }
-                });
-            },
-            ArrowFunctionExpression(path) {
-                // Only process top-level arrow functions assigned to variables
-                if (path.getFunctionParent())
-                    return;
-                const parent = path.parent;
-                if (parent.type !== 'VariableDeclarator')
-                    return;
-                if (!('id' in parent) || !parent.id || parent.id.type !== 'Identifier')
-                    return;
-                const funcName = parent.id.name;
-                const functionId = `FUNCTION#${funcName}#${filePath}#${path.node.loc.start.line}`;
-                nodes.push({
-                    id: functionId,
-                    type: 'FUNCTION',
-                    name: funcName,
-                    file: filePath,
-                    metadata: JSON.stringify({
-                        line: path.node.loc.start.line,
-                        async: path.node.async || false,
-                        arrowFunction: true
-                    })
-                });
-                edges.push({ src: moduleId, dst: functionId, type: 'CONTAINS' });
-                stats.functions++;
-            }
-        });
-        // Extract classes
-        traverse(ast, {
-            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}`;
-                nodes.push({
-                    id: classId,
-                    type: 'CLASS',
-                    name: className,
-                    file: filePath,
-                    metadata: JSON.stringify({
-                        line: node.loc.start.line,
-                        superClass: node.superClass?.name || null
-                    })
-                });
-                edges.push({ src: moduleId, dst: classId, type: 'CONTAINS' });
-                // 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}`;
-                        nodes.push({
-                            id: methodId,
-                            type: 'METHOD',
-                            name: methodName,
-                            file: filePath,
-                            metadata: JSON.stringify({
-                                className,
-                                line: member.loc.start.line,
-                                async: member.async || false,
-                                static: member.static || false,
-                                isConstructor: member.kind === 'constructor'
-                            })
-                        });
-                        edges.push({ src: classId, dst: methodId, type: 'CONTAINS' });
-                        stats.functions++;
-                    }
-                });
-            }
-        });
-        // Extract call expressions (simplified)
-        traverse(ast, {
-            CallExpression(path) {
-                const node = path.node;
-                if (node.callee.type === 'Identifier') {
-                    const callId = `CALL#${node.callee.name}#${filePath}#${node.loc.start.line}:${callCounter++}`;
-                    nodes.push({
-                        id: callId,
-                        type: 'CALL',
-                        name: node.callee.name,
-                        file: filePath,
-                        metadata: JSON.stringify({
-                            line: node.loc.start.line,
-                            argsCount: node.arguments.length
-                        })
-                    });
-                    // Find parent function to connect
-                    const parentFunc = path.getFunctionParent();
-                    if (parentFunc) {
-                        const parentName = parentFunc.node.id?.name ||
-                            (parentFunc.parent?.id?.name) ||
-                            'anonymous';
-                        edges.push({
-                            src: `FUNCTION#${parentName}#${filePath}#${parentFunc.node.loc.start.line}`,
-                            dst: callId,
-                            type: 'CONTAINS'
-                        });
-                    }
-                    else {
-                        edges.push({ src: moduleId, dst: callId, type: 'CONTAINS' });
-                    }
-                    stats.calls++;
-                }
-            }
-        });
-        // Batch write to RFDB
-        if (nodes.length > 0 && client) {
-            await client.addNodes(nodes);
-            stats.nodes = nodes.length;
-        }
-        if (edges.length > 0 && client) {
-            await client.addEdges(edges, true); // skipValidation for speed
-            stats.edges = edges.length;
-        }
-        return stats;
-    }
-    catch (err) {
-        throw new Error(`Failed to analyze ${filePath}: ${err.message}`);
-    }
-}
-/**
- * Handle messages from main thread
- */
-if (parentPort) {
-    parentPort.on('message', async (msg) => {
-        switch (msg.type) {
-            case 'connect':
-                try {
-                    socketPath = msg.socketPath || socketPath;
-                    await connect();
-                }
-                catch (err) {
-                    parentPort.postMessage({ type: 'error', error: err.message });
-                }
-                break;
-            case 'analyze':
-                try {
-                    const stats = await analyzeFile(msg.file, msg.moduleId, msg.moduleName);
-                    parentPort.postMessage({
-                        type: 'done',
-                        file: msg.file,
-                        stats,
-                        workerId
-                    });
-                }
-                catch (err) {
-                    parentPort.postMessage({
-                        type: 'error',
-                        file: msg.file,
-                        error: err.message,
-                        workerId
-                    });
-                }
-                break;
-            case 'disconnect':
-                if (client) {
-                    await client.close();
-                    connected = false;
-                }
-                parentPort.postMessage({ type: 'disconnected', workerId });
-                break;
-            case 'exit':
-                if (client) {
-                    await client.close();
-                }
-                process.exit(0);
-                break;
-        }
-    });
-    // Auto-connect on start if socketPath provided
-    if (workerData?.autoConnect) {
-        connect().catch(err => {
-            parentPort.postMessage({ type: 'error', error: err.message });
-        });
-    }
-}

package/dist/core/ParallelAnalyzer.d.ts

@@ -1,120 +0,0 @@
-/**
- * ParallelAnalyzer - orchestrates parallel AST analysis using worker threads
- *
- * Features:
- * - Configurable number of workers (default: CPU cores)
- * - Each worker connects to RFDB server directly
- * - Real-time statistics available during analysis
- * - Concurrent reads while writes are happening
- *
- * Usage:
- *   const analyzer = new ParallelAnalyzer({
- *     socketPath: '/tmp/rfdb.sock',
- *     maxWorkers: 4,
- *   });
- *   await analyzer.start();
- *   const stats = await analyzer.analyzeFiles(files);
- *   await analyzer.stop();
- */
-import { EventEmitter } from 'events';
-/**
- * Analyzer options
- */
-export interface ParallelAnalyzerOptions {
-    socketPath?: string;
-    maxWorkers?: number;
-}
-/**
- * File info for analysis
- */
-export interface FileInfo {
-    file: string;
-    id?: string;
-    moduleId?: string;
-    name?: string;
-    moduleName?: string;
-}
-/**
- * Analysis stats per file
- */
-export interface FileStats {
-    nodes?: number;
-    edges?: number;
-    functions?: number;
-    calls?: number;
-}
-/**
- * Overall analysis statistics
- */
-export interface AnalysisStats {
-    filesTotal: number;
-    filesProcessed: number;
-    filesFailed: number;
-    nodesCreated: number;
-    edgesCreated: number;
-    functionsFound: number;
-    callsFound: number;
-    startTime: number | null;
-    errors: Array<{
-        file: string;
-        error: string;
-    }>;
-}
-/**
- * Graph stats from RFDB
- */
-export interface GraphStats {
-    nodeCount: number;
-    edgeCount: number;
-    nodesByType: Record<string, number>;
-    edgesByType: Record<string, number>;
-}
-export declare class ParallelAnalyzer extends EventEmitter {
-    private socketPath;
-    private maxWorkers;
-    private workers;
-    private readyWorkers;
-    private taskQueue;
-    private pendingTasks;
-    private taskIdCounter;
-    private running;
-    private stats;
-    private statsClient;
-    constructor(options?: ParallelAnalyzerOptions);
-    /**
-     * Start the analyzer (spawn workers)
-     */
-    start(): Promise<void>;
-    /**
-     * Stop the analyzer (terminate workers)
-     */
-    stop(): Promise<void>;
-    /**
-     * Analyze multiple files in parallel
-     */
-    analyzeFiles(files: FileInfo[]): Promise<AnalysisStats>;
-    /**
-     * Get current statistics (can be called during analysis)
-     */
-    getStats(): AnalysisStats & {
-        elapsed: number;
-        activeWorkers: number;
-        queuedTasks: number;
-    };
-    /**
-     * Get graph statistics from RFDB (can be called during analysis)
-     */
-    getGraphStats(): Promise<GraphStats>;
-    /**
-     * Query nodes from RFDB (can be called during analysis)
-     */
-    queryNodes(nodeType: string): Promise<string[]>;
-    private _analyzeFile;
-    private _dispatchTask;
-    private _handleWorkerMessage;
-    private _workerReady;
-    private _handleWorkerError;
-    private _handleWorkerExit;
-}
-export default ParallelAnalyzer;
-//# sourceMappingURL=ParallelAnalyzer.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"ParallelAnalyzer.d.ts","sourceRoot":"","sources":["../../src/core/ParallelAnalyzer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAWtC;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAChD;AAsCD;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACrC;AAED,qBAAa,gBAAiB,SAAQ,YAAY;IAChD,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,OAAO,CAAW;IAC1B,OAAO,CAAC,YAAY,CAAW;IAC/B,OAAO,CAAC,SAAS,CAAiB;IAClC,OAAO,CAAC,YAAY,CAA4B;IAChD,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,KAAK,CAAgB;IAC7B,OAAO,CAAC,WAAW,CAAoB;gBAE3B,OAAO,GAAE,uBAA4B;IAiCjD;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IA8D5B;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IA6B3B;;OAEG;IACG,YAAY,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC,aAAa,CAAC;IAqC7D;;OAEG;IACH,QAAQ,IAAI,aAAa,GAAG;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE;IAS3F;;OAEG;IACG,aAAa,IAAI,OAAO,CAAC,UAAU,CAAC;IAe1C;;OAEG;IACG,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAWrD,OAAO,CAAC,YAAY;IAiBpB,OAAO,CAAC,aAAa;IAgBrB,OAAO,CAAC,oBAAoB;IA4D5B,OAAO,CAAC,YAAY;IAgBpB,OAAO,CAAC,kBAAkB;IAK1B,OAAO,CAAC,iBAAiB;CAY1B;AAED,eAAe,gBAAgB,CAAC"}