@grafema/core 0.1.0-alpha.1

package/dist/core/NodeId.js

@@ -0,0 +1,170 @@
+/**
+ * Deterministic Node ID generation scheme for the graph
+ *
+ * Format: TYPE|SCOPE|FILE|IDENTIFIER|LINE:COL
+ *
+ * Components:
+ * - TYPE: node type (MODULE, FUNCTION, CLASS, METHOD, VARIABLE, etc.)
+ * - SCOPE: context/scope (path to parent or project)
+ * - FILE: relative file path from project root
+ * - IDENTIFIER: entity name (for MODULE can be empty)
+ * - LINE:COL: position in file (for uniqueness of anonymous functions)
+ *
+ * Examples:
+ * MODULE|/project|src/index.js||0:0
+ * FUNCTION|/project|src/index.js|handleRequest|42:5
+ * CLASS|/project|src/User.js|User|10:0
+ * METHOD|User|src/User.js|login|25:2
+ * VARIABLE|handleRequest|src/index.js|userId|45:10
+ * EXTERNAL_MODULE|/project||express|0:0
+ */
+import { createHash } from 'crypto';
+/**
+ * Compute deterministic Node ID
+ */
+export function computeNodeId({ type, scope = '', file = '', identifier = '', line = 0, column = 0 }) {
+    // Normalize: remove empty values
+    const parts = [
+        type,
+        scope || '',
+        file || '',
+        identifier || '',
+        `${line}:${column}`
+    ];
+    return parts.join('|');
+}
+/**
+ * Compute u128 numeric ID from string (for Rust backend)
+ * Uses SHA-256 hash and takes first 16 bytes
+ */
+export function computeNumericId(stringId) {
+    const hash = createHash('sha256').update(stringId).digest();
+    // Take first 16 bytes (128 bits) and convert to BigInt
+    let numericId = 0n;
+    for (let i = 0; i < 16; i++) {
+        numericId = (numericId << 8n) | BigInt(hash[i]);
+    }
+    return numericId;
+}
+/**
+ * Parse Node ID back into components
+ */
+export function parseNodeId(nodeId) {
+    const parts = nodeId.split('|');
+    if (parts.length !== 5) {
+        throw new Error(`Invalid Node ID format: ${nodeId}`);
+    }
+    const [lineStr, columnStr] = parts[4].split(':');
+    return {
+        type: parts[0],
+        scope: parts[1],
+        file: parts[2],
+        identifier: parts[3],
+        line: Number(lineStr),
+        column: Number(columnStr)
+    };
+}
+/**
+ * Helper for creating MODULE ID
+ */
+export function createModuleId(filePath, projectPath = '/project') {
+    return computeNodeId({
+        type: 'MODULE',
+        scope: projectPath,
+        file: filePath,
+        identifier: '',
+        line: 0,
+        column: 0
+    });
+}
+/**
+ * Helper for creating FUNCTION ID
+ */
+export function createFunctionId(filePath, functionName, line, column, scope = '/project') {
+    return computeNodeId({
+        type: 'FUNCTION',
+        scope,
+        file: filePath,
+        identifier: functionName,
+        line,
+        column
+    });
+}
+/**
+ * Helper for creating CLASS ID
+ */
+export function createClassId(filePath, className, line, column, scope = '/project') {
+    return computeNodeId({
+        type: 'CLASS',
+        scope,
+        file: filePath,
+        identifier: className,
+        line,
+        column
+    });
+}
+/**
+ * Helper for creating METHOD ID
+ */
+export function createMethodId(filePath, className, methodName, line, column) {
+    return computeNodeId({
+        type: 'METHOD',
+        scope: className, // Scope = parent class
+        file: filePath,
+        identifier: methodName,
+        line,
+        column
+    });
+}
+/**
+ * Helper for creating VARIABLE ID
+ */
+export function createVariableId(filePath, varName, line, column, scope) {
+    return computeNodeId({
+        type: 'VARIABLE',
+        scope, // Scope = containing function/class
+        file: filePath,
+        identifier: varName,
+        line,
+        column
+    });
+}
+/**
+ * Helper for creating EXTERNAL_MODULE ID
+ */
+export function createExternalModuleId(moduleName, projectPath = '/project') {
+    return computeNodeId({
+        type: 'EXTERNAL_MODULE',
+        scope: projectPath,
+        file: '',
+        identifier: moduleName,
+        line: 0,
+        column: 0
+    });
+}
+/**
+ * Helper for creating IMPORT ID
+ */
+export function createImportId(filePath, source, localName, line, scope = '/project') {
+    return computeNodeId({
+        type: 'IMPORT',
+        scope,
+        file: filePath,
+        identifier: `${source}:${localName}`,
+        line,
+        column: 0
+    });
+}
+/**
+ * Helper for creating EXPORT ID
+ */
+export function createExportId(filePath, exportName, line, scope = '/project') {
+    return computeNodeId({
+        type: 'EXPORT',
+        scope,
+        file: filePath,
+        identifier: exportName,
+        line,
+        column: 0
+    });
+}

package/dist/core/ParallelAnalyzer.d.ts

@@ -0,0 +1,120 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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"}

package/dist/core/ParallelAnalyzer.js

@@ -0,0 +1,331 @@
+/**
+ * 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 { Worker } from 'worker_threads';
+import { EventEmitter } from 'events';
+import { cpus } from 'os';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { RFDBClient } from '@grafema/rfdb-client';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const WORKER_SCRIPT = join(__dirname, 'AnalysisWorker.js');
+export class ParallelAnalyzer extends EventEmitter {
+    socketPath;
+    maxWorkers;
+    workers;
+    readyWorkers;
+    taskQueue;
+    pendingTasks;
+    taskIdCounter;
+    running;
+    stats;
+    statsClient;
+    constructor(options = {}) {
+        super();
+        // Configuration
+        this.socketPath = options.socketPath || '/tmp/rfdb.sock';
+        this.maxWorkers = options.maxWorkers || cpus().length;
+        this.maxWorkers = Math.min(this.maxWorkers, 16); // Cap at 16
+        // State
+        this.workers = [];
+        this.readyWorkers = [];
+        this.taskQueue = [];
+        this.pendingTasks = new Map();
+        this.taskIdCounter = 0;
+        this.running = false;
+        // Stats (updated in real-time)
+        this.stats = {
+            filesTotal: 0,
+            filesProcessed: 0,
+            filesFailed: 0,
+            nodesCreated: 0,
+            edgesCreated: 0,
+            functionsFound: 0,
+            callsFound: 0,
+            startTime: null,
+            errors: []
+        };
+        // Stats client (for reading during analysis)
+        this.statsClient = null;
+    }
+    /**
+     * Start the analyzer (spawn workers)
+     */
+    async start() {
+        if (this.running)
+            return;
+        console.log(`[ParallelAnalyzer] Starting ${this.maxWorkers} workers...`);
+        // Connect stats client for real-time queries
+        this.statsClient = new RFDBClient(this.socketPath);
+        await this.statsClient.connect();
+        // Spawn workers
+        const initPromises = [];
+        for (let i = 0; i < this.maxWorkers; i++) {
+            const worker = new Worker(WORKER_SCRIPT, {
+                workerData: {
+                    workerId: i,
+                    socketPath: this.socketPath,
+                    autoConnect: true
+                }
+            });
+            const initPromise = new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => {
+                    reject(new Error(`Worker ${i} initialization timeout`));
+                }, 30000);
+                const onMessage = (msg) => {
+                    if (msg.type === 'ready') {
+                        clearTimeout(timeout);
+                        worker.removeListener('message', onMessage);
+                        resolve();
+                    }
+                    else if (msg.type === 'error' && !this.running) {
+                        clearTimeout(timeout);
+                        worker.removeListener('message', onMessage);
+                        reject(new Error(msg.error));
+                    }
+                };
+                worker.on('message', onMessage);
+                worker.once('error', (err) => {
+                    clearTimeout(timeout);
+                    reject(err);
+                });
+            });
+            worker.on('message', (msg) => this._handleWorkerMessage(worker, msg));
+            worker.on('error', (err) => this._handleWorkerError(worker, err));
+            worker.on('exit', (code) => this._handleWorkerExit(worker, code));
+            this.workers.push(worker);
+            initPromises.push(initPromise);
+        }
+        await Promise.all(initPromises);
+        this.readyWorkers = [...this.workers];
+        this.running = true;
+        console.log(`[ParallelAnalyzer] ${this.maxWorkers} workers ready`);
+        this.emit('started', { workerCount: this.maxWorkers });
+    }
+    /**
+     * Stop the analyzer (terminate workers)
+     */
+    async stop() {
+        if (!this.running)
+            return;
+        console.log('[ParallelAnalyzer] Stopping workers...');
+        // Close stats client
+        if (this.statsClient) {
+            await this.statsClient.close();
+            this.statsClient = null;
+        }
+        // Terminate workers
+        const terminatePromises = this.workers.map(worker => {
+            return new Promise((resolve) => {
+                worker.once('exit', () => resolve());
+                worker.postMessage({ type: 'exit' });
+            });
+        });
+        await Promise.all(terminatePromises);
+        this.workers = [];
+        this.readyWorkers = [];
+        this.running = false;
+        console.log('[ParallelAnalyzer] Stopped');
+        this.emit('stopped');
+    }
+    /**
+     * Analyze multiple files in parallel
+     */
+    async analyzeFiles(files) {
+        if (!this.running) {
+            throw new Error('Analyzer not started. Call start() first.');
+        }
+        this.stats = {
+            filesTotal: files.length,
+            filesProcessed: 0,
+            filesFailed: 0,
+            nodesCreated: 0,
+            edgesCreated: 0,
+            functionsFound: 0,
+            callsFound: 0,
+            startTime: Date.now(),
+            errors: []
+        };
+        console.log(`[ParallelAnalyzer] Analyzing ${files.length} files with ${this.maxWorkers} workers...`);
+        // Create promises for all files
+        const promises = files.map(f => this._analyzeFile(f));
+        // Wait for all to complete
+        await Promise.all(promises);
+        const duration = Date.now() - this.stats.startTime;
+        const filesPerSecond = (this.stats.filesProcessed / (duration / 1000)).toFixed(2);
+        console.log(`[ParallelAnalyzer] Done in ${duration}ms (${filesPerSecond} files/sec)`);
+        console.log(`[ParallelAnalyzer] ${this.stats.filesProcessed} succeeded, ${this.stats.filesFailed} failed`);
+        console.log(`[ParallelAnalyzer] ${this.stats.nodesCreated} nodes, ${this.stats.edgesCreated} edges`);
+        this.emit('completed', { ...this.stats, duration });
+        return this.stats;
+    }
+    /**
+     * Get current statistics (can be called during analysis)
+     */
+    getStats() {
+        return {
+            ...this.stats,
+            elapsed: this.stats.startTime ? Date.now() - this.stats.startTime : 0,
+            activeWorkers: this.maxWorkers - this.readyWorkers.length,
+            queuedTasks: this.taskQueue.length
+        };
+    }
+    /**
+     * Get graph statistics from RFDB (can be called during analysis)
+     */
+    async getGraphStats() {
+        if (!this.statsClient) {
+            throw new Error('Analyzer not started');
+        }
+        const [nodeCount, edgeCount, nodesByType, edgesByType] = await Promise.all([
+            this.statsClient.nodeCount(),
+            this.statsClient.edgeCount(),
+            this.statsClient.countNodesByType(),
+            this.statsClient.countEdgesByType()
+        ]);
+        return { nodeCount, edgeCount, nodesByType, edgesByType };
+    }
+    /**
+     * Query nodes from RFDB (can be called during analysis)
+     */
+    async queryNodes(nodeType) {
+        if (!this.statsClient) {
+            throw new Error('Analyzer not started');
+        }
+        return this.statsClient.findByType(nodeType);
+    }
+    // ===========================================================================
+    // Internal methods
+    // ===========================================================================
+    _analyzeFile(fileInfo) {
+        return new Promise((resolve, reject) => {
+            const taskId = this.taskIdCounter++;
+            const task = {
+                taskId,
+                file: fileInfo.file,
+                moduleId: fileInfo.moduleId || fileInfo.id || fileInfo.file,
+                moduleName: fileInfo.moduleName || fileInfo.name || fileInfo.file,
+                resolve,
+                reject
+            };
+            this.pendingTasks.set(taskId, task);
+            this._dispatchTask(task);
+        });
+    }
+    _dispatchTask(task) {
+        if (this.readyWorkers.length > 0) {
+            const worker = this.readyWorkers.pop();
+            worker.postMessage({
+                type: 'analyze',
+                file: task.file,
+                moduleId: task.moduleId,
+                moduleName: task.moduleName,
+                taskId: task.taskId
+            });
+            this.emit('taskStarted', { file: task.file });
+        }
+        else {
+            this.taskQueue.push(task);
+        }
+    }
+    _handleWorkerMessage(worker, msg) {
+        switch (msg.type) {
+            case 'done': {
+                // Find task by file (workers don't track taskId internally)
+                let task = null;
+                for (const [id, t] of this.pendingTasks) {
+                    if (t.file === msg.file) {
+                        task = t;
+                        this.pendingTasks.delete(id);
+                        break;
+                    }
+                }
+                if (task) {
+                    // Update stats
+                    this.stats.filesProcessed++;
+                    this.stats.nodesCreated += msg.stats?.nodes || 0;
+                    this.stats.edgesCreated += msg.stats?.edges || 0;
+                    this.stats.functionsFound += msg.stats?.functions || 0;
+                    this.stats.callsFound += msg.stats?.calls || 0;
+                    this.emit('fileCompleted', { file: msg.file, stats: msg.stats });
+                    task.resolve(msg.stats);
+                }
+                this._workerReady(worker);
+                break;
+            }
+            case 'error': {
+                let task = null;
+                for (const [id, t] of this.pendingTasks) {
+                    if (t.file === msg.file) {
+                        task = t;
+                        this.pendingTasks.delete(id);
+                        break;
+                    }
+                }
+                if (task) {
+                    this.stats.filesFailed++;
+                    this.stats.errors.push({ file: msg.file, error: msg.error });
+                    this.emit('fileError', { file: msg.file, error: msg.error });
+                    task.resolve(null); // Don't reject, just continue
+                }
+                this._workerReady(worker);
+                break;
+            }
+            case 'ready':
+                // Worker reconnected
+                if (!this.readyWorkers.includes(worker)) {
+                    this._workerReady(worker);
+                }
+                break;
+        }
+    }
+    _workerReady(worker) {
+        if (this.taskQueue.length > 0) {
+            const nextTask = this.taskQueue.shift();
+            worker.postMessage({
+                type: 'analyze',
+                file: nextTask.file,
+                moduleId: nextTask.moduleId,
+                moduleName: nextTask.moduleName,
+                taskId: nextTask.taskId
+            });
+            this.emit('taskStarted', { file: nextTask.file });
+        }
+        else {
+            this.readyWorkers.push(worker);
+        }
+    }
+    _handleWorkerError(worker, error) {
+        console.error('[ParallelAnalyzer] Worker error:', error);
+        this.emit('workerError', { error });
+    }
+    _handleWorkerExit(worker, code) {
+        if (code !== 0 && this.running) {
+            console.error(`[ParallelAnalyzer] Worker exited with code ${code}`);
+        }
+        // Remove from lists
+        const idx = this.workers.indexOf(worker);
+        if (idx !== -1)
+            this.workers.splice(idx, 1);
+        const readyIdx = this.readyWorkers.indexOf(worker);
+        if (readyIdx !== -1)
+            this.readyWorkers.splice(readyIdx, 1);
+    }
+}
+export default ParallelAnalyzer;