@grafema/core 0.1.0-alpha.1

package/dist/core/QueueWorker.js

@@ -0,0 +1,567 @@
+/**
+ * QueueWorker - Worker thread for queue-based analysis
+ *
+ * Runs in a worker_thread, receives file tasks, runs applicable plugins,
+ * writes results directly to RFDB.
+ *
+ * Protocol:
+ *   Main -> Worker: { type: 'process', taskId, file, moduleId, moduleName, plugins }
+ *   Worker -> Main: { type: 'done', taskId, stats } | { type: 'error', taskId, 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;
+const socketPath = workerData?.socketPath || '/tmp/rfdb.sock';
+let connected = false;
+// Plugin registry - maps plugin names to analyzer functions
+const pluginAnalyzers = new Map();
+/**
+ * Register built-in analysis plugins
+ */
+function registerBuiltinPlugins() {
+    pluginAnalyzers.set('JSASTAnalyzer', analyzeJSAST);
+    pluginAnalyzers.set('ExpressRouteAnalyzer', analyzeExpressRoutes);
+    pluginAnalyzers.set('SocketIOAnalyzer', analyzeSocketIO);
+    pluginAnalyzers.set('DatabaseAnalyzer', analyzeDatabase);
+    pluginAnalyzers.set('FetchAnalyzer', analyzeFetch);
+    pluginAnalyzers.set('ReactAnalyzer', analyzeReact);
+}
+/**
+ * Connect to RFDB server
+ */
+async function connect() {
+    if (connected)
+        return;
+    client = new RFDBClient(socketPath);
+    await client.connect();
+    connected = true;
+    registerBuiltinPlugins();
+    parentPort?.postMessage({ type: 'ready', workerId });
+}
+/**
+ * Process a file with specified plugins
+ */
+async function processFile(taskId, filePath, moduleId, moduleName, pluginNames) {
+    const stats = {
+        nodes: 0,
+        edges: 0,
+        plugins: {},
+    };
+    try {
+        const code = readFileSync(filePath, 'utf-8');
+        const ast = parse(code, {
+            sourceType: 'module',
+            plugins: ['jsx', 'typescript'],
+            errorRecovery: true,
+        });
+        for (const pluginName of pluginNames) {
+            const analyzer = pluginAnalyzers.get(pluginName);
+            if (!analyzer) {
+                console.warn(`[Worker ${workerId}] Unknown plugin: ${pluginName}`);
+                continue;
+            }
+            try {
+                const pluginStats = await analyzer(filePath, moduleId, moduleName, ast, client);
+                stats.nodes += pluginStats.nodes || 0;
+                stats.edges += pluginStats.edges || 0;
+                stats.plugins[pluginName] = pluginStats;
+            }
+            catch (err) {
+                console.error(`[Worker ${workerId}] Plugin ${pluginName} error on ${filePath}:`, err.message);
+                stats.plugins[pluginName] = { error: err.message };
+            }
+        }
+        return stats;
+    }
+    catch (err) {
+        throw new Error(`Failed to process ${filePath}: ${err.message}`);
+    }
+}
+// =============================================================================
+// Plugin Implementations
+// =============================================================================
+/**
+ * JSASTAnalyzer - Base AST analysis
+ */
+async function analyzeJSAST(filePath, moduleId, moduleName, ast, client) {
+    const nodes = [];
+    const edges = [];
+    let callCounter = 0;
+    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 {
+                    const imported = spec.imported;
+                    importedName = imported.type === 'Identifier' ? imported.name : imported.value;
+                    localName = spec.local.name;
+                }
+                const importId = `IMPORT#${localName}#${filePath}#${node.loc?.start.line || 0}`;
+                nodes.push({
+                    id: importId,
+                    type: 'IMPORT',
+                    name: localName,
+                    file: filePath,
+                    line: node.loc?.start.line || 0,
+                    importedName,
+                    source,
+                });
+                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 line = node.loc?.start.line || 0;
+            const functionId = `FUNCTION#${funcName}#${filePath}#${line}`;
+            nodes.push({
+                id: functionId,
+                type: 'FUNCTION',
+                name: funcName,
+                file: filePath,
+                line,
+                async: node.async || false,
+                generator: node.generator || false,
+                exported: path.parent?.type?.includes('Export') || false,
+            });
+            edges.push({ src: moduleId, dst: functionId, type: 'CONTAINS' });
+            // 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,
+                        index,
+                    });
+                    edges.push({ src: functionId, dst: paramId, type: 'HAS_PARAMETER' });
+                }
+            });
+        },
+        ArrowFunctionExpression(path) {
+            if (path.getFunctionParent())
+                return;
+            const parent = path.parent;
+            if (parent.type !== 'VariableDeclarator')
+                return;
+            const varDecl = parent;
+            if (!varDecl.id || varDecl.id.type !== 'Identifier')
+                return;
+            const funcName = varDecl.id.name;
+            const line = path.node.loc?.start.line || 0;
+            const functionId = `FUNCTION#${funcName}#${filePath}#${line}`;
+            nodes.push({
+                id: functionId,
+                type: 'FUNCTION',
+                name: funcName,
+                file: filePath,
+                line,
+                async: path.node.async || false,
+                arrowFunction: true,
+            });
+            edges.push({ src: moduleId, dst: functionId, type: 'CONTAINS' });
+        },
+    });
+    // Extract classes
+    traverse(ast, {
+        ClassDeclaration(path) {
+            if (path.getFunctionParent())
+                return;
+            const node = path.node;
+            if (!node.id)
+                return;
+            const className = node.id.name;
+            const line = node.loc?.start.line || 0;
+            const classId = `CLASS#${className}#${filePath}#${line}`;
+            nodes.push({
+                id: classId,
+                type: 'CLASS',
+                name: className,
+                file: filePath,
+                line,
+                superClass: node.superClass && node.superClass.type === 'Identifier' ? 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 methodLine = member.loc?.start.line || 0;
+                    const methodId = `METHOD#${className}.${methodName}#${filePath}#${methodLine}`;
+                    nodes.push({
+                        id: methodId,
+                        type: 'METHOD',
+                        name: methodName,
+                        file: filePath,
+                        line: methodLine,
+                        className,
+                        async: member.async || false,
+                        static: member.static || false,
+                        isConstructor: member.kind === 'constructor',
+                    });
+                    edges.push({ src: classId, dst: methodId, type: 'CONTAINS' });
+                }
+            });
+        },
+    });
+    // Extract call expressions
+    traverse(ast, {
+        CallExpression(path) {
+            const node = path.node;
+            if (node.callee.type === 'Identifier') {
+                const line = node.loc?.start.line || 0;
+                const callId = `CALL#${node.callee.name}#${filePath}#${line}:${callCounter++}`;
+                nodes.push({
+                    id: callId,
+                    type: 'CALL',
+                    name: node.callee.name,
+                    file: filePath,
+                    line,
+                    argsCount: node.arguments.length,
+                });
+                const parentFunc = path.getFunctionParent();
+                if (parentFunc) {
+                    const parentNode = parentFunc.node;
+                    const parentName = parentNode.id?.name ||
+                        parentFunc.parent?.id?.name ||
+                        'anonymous';
+                    const parentLine = parentNode.loc?.start.line || 0;
+                    edges.push({
+                        src: `FUNCTION#${parentName}#${filePath}#${parentLine}`,
+                        dst: callId,
+                        type: 'CONTAINS'
+                    });
+                }
+                else {
+                    edges.push({ src: moduleId, dst: callId, type: 'CONTAINS' });
+                }
+            }
+        },
+    });
+    if (nodes.length > 0) {
+        await client.addNodes(nodes);
+    }
+    if (edges.length > 0) {
+        await client.addEdges(edges, true);
+    }
+    return { nodes: nodes.length, edges: edges.length };
+}
+/**
+ * ExpressRouteAnalyzer - HTTP routes
+ */
+async function analyzeExpressRoutes(filePath, moduleId, _moduleName, ast, client) {
+    const nodes = [];
+    const edges = [];
+    const HTTP_METHODS = ['get', 'post', 'put', 'delete', 'patch', 'options', 'head', 'all'];
+    traverse(ast, {
+        CallExpression(path) {
+            const node = path.node;
+            if (node.callee.type === 'MemberExpression' &&
+                node.callee.property?.type === 'Identifier' &&
+                HTTP_METHODS.includes(node.callee.property.name)) {
+                const method = node.callee.property.name.toUpperCase();
+                const pathArg = node.arguments[0];
+                if (pathArg?.type === 'StringLiteral') {
+                    const routePath = pathArg.value;
+                    const line = node.loc?.start.line || 0;
+                    const routeId = `http:route#${method}#${routePath}#${filePath}#${line}`;
+                    nodes.push({
+                        id: routeId,
+                        type: 'http:route',
+                        name: `${method} ${routePath}`,
+                        method,
+                        path: routePath,
+                        file: filePath,
+                        line,
+                    });
+                    edges.push({ src: moduleId, dst: routeId, type: 'CONTAINS' });
+                }
+            }
+        },
+    });
+    if (nodes.length > 0) {
+        await client.addNodes(nodes);
+    }
+    if (edges.length > 0) {
+        await client.addEdges(edges, true);
+    }
+    return { nodes: nodes.length, edges: edges.length, routes: nodes.length };
+}
+/**
+ * SocketIOAnalyzer - Socket.IO events
+ */
+async function analyzeSocketIO(filePath, moduleId, _moduleName, ast, client) {
+    const nodes = [];
+    const edges = [];
+    traverse(ast, {
+        CallExpression(path) {
+            const node = path.node;
+            if (node.callee.type === 'MemberExpression' &&
+                node.callee.property?.type === 'Identifier') {
+                const method = node.callee.property.name;
+                const line = node.loc?.start.line || 0;
+                if (method === 'on' && node.arguments[0]?.type === 'StringLiteral') {
+                    const eventName = node.arguments[0].value;
+                    const eventId = `socketio:on#${eventName}#${filePath}#${line}`;
+                    nodes.push({
+                        id: eventId,
+                        type: 'socketio:on',
+                        name: eventName,
+                        file: filePath,
+                        line,
+                    });
+                    edges.push({ src: moduleId, dst: eventId, type: 'CONTAINS' });
+                }
+                if (method === 'emit' && node.arguments[0]?.type === 'StringLiteral') {
+                    const eventName = node.arguments[0].value;
+                    const eventId = `socketio:emit#${eventName}#${filePath}#${line}`;
+                    nodes.push({
+                        id: eventId,
+                        type: 'socketio:emit',
+                        name: eventName,
+                        file: filePath,
+                        line,
+                    });
+                    edges.push({ src: moduleId, dst: eventId, type: 'CONTAINS' });
+                }
+            }
+        },
+    });
+    if (nodes.length > 0) {
+        await client.addNodes(nodes);
+    }
+    if (edges.length > 0) {
+        await client.addEdges(edges, true);
+    }
+    return { nodes: nodes.length, edges: edges.length };
+}
+/**
+ * DatabaseAnalyzer - SQL queries
+ */
+async function analyzeDatabase(filePath, moduleId, _moduleName, ast, client) {
+    const nodes = [];
+    const edges = [];
+    traverse(ast, {
+        CallExpression(path) {
+            const node = path.node;
+            if (node.callee.type === 'MemberExpression' &&
+                node.callee.property?.type === 'Identifier') {
+                const method = node.callee.property.name;
+                if (method === 'query' && node.arguments[0]?.type === 'StringLiteral') {
+                    const sql = node.arguments[0].value;
+                    const line = node.loc?.start.line || 0;
+                    const queryId = `db:query#${filePath}#${line}`;
+                    nodes.push({
+                        id: queryId,
+                        type: 'db:query',
+                        name: sql.slice(0, 50) + (sql.length > 50 ? '...' : ''),
+                        sql,
+                        file: filePath,
+                        line,
+                    });
+                    edges.push({ src: moduleId, dst: queryId, type: 'CONTAINS' });
+                }
+            }
+        },
+    });
+    if (nodes.length > 0) {
+        await client.addNodes(nodes);
+    }
+    if (edges.length > 0) {
+        await client.addEdges(edges, true);
+    }
+    return { nodes: nodes.length, edges: edges.length };
+}
+/**
+ * FetchAnalyzer - HTTP requests
+ */
+async function analyzeFetch(filePath, moduleId, _moduleName, ast, client) {
+    const nodes = [];
+    const edges = [];
+    traverse(ast, {
+        CallExpression(path) {
+            const node = path.node;
+            const line = node.loc?.start.line || 0;
+            if (node.callee.type === 'Identifier' && node.callee.name === 'fetch') {
+                const urlArg = node.arguments[0];
+                const url = urlArg?.type === 'StringLiteral' ? urlArg.value : '<dynamic>';
+                const requestId = `http:request#${filePath}#${line}`;
+                nodes.push({
+                    id: requestId,
+                    type: 'http:request',
+                    name: `fetch ${url.slice(0, 40)}`,
+                    url,
+                    file: filePath,
+                    line,
+                });
+                edges.push({ src: moduleId, dst: requestId, type: 'CONTAINS' });
+            }
+            if (node.callee.type === 'MemberExpression' &&
+                node.callee.object?.type === 'Identifier' &&
+                node.callee.object.name === 'axios') {
+                const prop = node.callee.property;
+                const method = (prop?.type === 'Identifier' ? prop.name : 'request').toUpperCase();
+                const urlArg = node.arguments[0];
+                const url = urlArg?.type === 'StringLiteral' ? urlArg.value : '<dynamic>';
+                const requestId = `http:request#${filePath}#${line}`;
+                nodes.push({
+                    id: requestId,
+                    type: 'http:request',
+                    name: `${method} ${url.slice(0, 40)}`,
+                    url,
+                    method,
+                    file: filePath,
+                    line,
+                });
+                edges.push({ src: moduleId, dst: requestId, type: 'CONTAINS' });
+            }
+        },
+    });
+    if (nodes.length > 0) {
+        await client.addNodes(nodes);
+    }
+    if (edges.length > 0) {
+        await client.addEdges(edges, true);
+    }
+    return { nodes: nodes.length, edges: edges.length };
+}
+/**
+ * ReactAnalyzer - React components
+ */
+async function analyzeReact(filePath, moduleId, _moduleName, ast, client) {
+    const nodes = [];
+    const edges = [];
+    traverse(ast, {
+        FunctionDeclaration(path) {
+            const node = path.node;
+            if (!node.id)
+                return;
+            const name = node.id.name;
+            if (name[0] === name[0].toUpperCase()) {
+                let returnsJSX = false;
+                path.traverse({
+                    ReturnStatement(retPath) {
+                        if (retPath.node.argument?.type === 'JSXElement' ||
+                            retPath.node.argument?.type === 'JSXFragment') {
+                            returnsJSX = true;
+                        }
+                    },
+                });
+                if (returnsJSX) {
+                    const line = node.loc?.start.line || 0;
+                    const componentId = `react:component#${name}#${filePath}#${line}`;
+                    nodes.push({
+                        id: componentId,
+                        type: 'react:component',
+                        name,
+                        file: filePath,
+                        line,
+                    });
+                    edges.push({ src: moduleId, dst: componentId, type: 'CONTAINS' });
+                }
+            }
+        },
+        CallExpression(path) {
+            const node = path.node;
+            if (node.callee.type === 'Identifier' && node.callee.name.startsWith('use')) {
+                const hookName = node.callee.name;
+                const line = node.loc?.start.line || 0;
+                const hookId = `react:hook#${hookName}#${filePath}#${line}`;
+                let hookType = 'react:hook';
+                if (hookName === 'useState')
+                    hookType = 'react:state';
+                if (hookName === 'useEffect' || hookName === 'useLayoutEffect')
+                    hookType = 'react:effect';
+                if (hookName === 'useRef')
+                    hookType = 'react:ref';
+                nodes.push({
+                    id: hookId,
+                    type: hookType,
+                    name: hookName,
+                    file: filePath,
+                    line,
+                });
+                edges.push({ src: moduleId, dst: hookId, type: 'CONTAINS' });
+            }
+        },
+    });
+    if (nodes.length > 0) {
+        await client.addNodes(nodes);
+    }
+    if (edges.length > 0) {
+        await client.addEdges(edges, true);
+    }
+    return { nodes: nodes.length, edges: edges.length };
+}
+// =============================================================================
+// Message Handler
+// =============================================================================
+parentPort?.on('message', async (msg) => {
+    switch (msg.type) {
+        case 'process':
+            try {
+                const stats = await processFile(msg.taskId, msg.file, msg.moduleId, msg.moduleName, msg.plugins);
+                parentPort?.postMessage({
+                    type: 'done',
+                    taskId: msg.taskId,
+                    file: msg.file,
+                    stats,
+                    workerId,
+                });
+            }
+            catch (err) {
+                parentPort?.postMessage({
+                    type: 'error',
+                    taskId: msg.taskId,
+                    file: msg.file,
+                    error: err.message,
+                    workerId,
+                });
+            }
+            break;
+        case 'exit':
+            if (client) {
+                await client.close();
+            }
+            process.exit(0);
+            break;
+    }
+});
+// Auto-connect on start
+connect().catch((err) => {
+    parentPort?.postMessage({ type: 'error', error: err.message });
+});