@grafema/core 0.1.0-alpha.1

package/dist/plugins/enrichment/PrefixEvaluator.js

@@ -0,0 +1,415 @@
+/**
+ * PrefixEvaluator - ENRICHMENT plugin for evaluating dynamic prefixes
+ *
+ * Resolves placeholders in MOUNT_POINT.prefix:
+ * - ${variable} → finds VariableDeclaration in the same module
+ * - ${binary} → recursively resolves BinaryExpression
+ * - ${template} → resolves TemplateLiteral with variables
+ * - ${member} → finds object and its property
+ * - ${call} → not supported yet (requires runtime eval)
+ * - ${conditional} → not supported yet (requires runtime eval)
+ */
+import { Plugin, createSuccessResult, createErrorResult } from '../Plugin.js';
+import { parse } from '@babel/parser';
+import _traverse from '@babel/traverse';
+import { readFileSync } from 'fs';
+// ES module compatibility - handle default export
+const traverseFn = _traverse.default || _traverse;
+const traverse = traverseFn;
+export class PrefixEvaluator extends Plugin {
+    get metadata() {
+        return {
+            name: 'PrefixEvaluator',
+            phase: 'ENRICHMENT',
+            priority: 80, // After MountPointResolver (90)
+            creates: {
+                nodes: [],
+                edges: []
+            },
+            dependencies: ['JSModuleIndexer', 'JSASTAnalyzer', 'MountPointResolver']
+        };
+    }
+    async execute(context) {
+        try {
+            const { graph } = context;
+            const graphTyped = graph;
+            let mountPointsEvaluated = 0;
+            let successfulEvaluations = 0;
+            // Find all MOUNT_POINT nodes with placeholder prefixes
+            const mountPoints = [];
+            if (graphTyped.nodes) {
+                const allNodes = await graphTyped.nodes.values();
+                for (const node of allNodes) {
+                    // Cast through unknown since node types vary
+                    const typedNode = node;
+                    if (typedNode.type === 'MOUNT_POINT' && typedNode.prefix && typedNode.prefix.startsWith('${')) {
+                        mountPoints.push(typedNode);
+                    }
+                }
+            }
+            console.log(`[PrefixEvaluator] Found ${mountPoints.length} mount points with placeholders`);
+            // For each mount point try to evaluate prefix
+            for (const mountPoint of mountPoints) {
+                mountPointsEvaluated++;
+                // Find MODULE that defines this mount point
+                const definesEdges = this.findEdges(graphTyped, {
+                    type: 'DEFINES',
+                    dst: mountPoint.id
+                });
+                if (definesEdges.length === 0) {
+                    console.log(`[PrefixEvaluator] No DEFINES edge for mount point ${mountPoint.id}`);
+                    continue;
+                }
+                const moduleId = definesEdges[0].fromId;
+                const module = graphTyped.nodes.get(moduleId);
+                if (!module || module.type !== 'MODULE') {
+                    console.log(`[PrefixEvaluator] Module not found for ${mountPoint.id}`);
+                    continue;
+                }
+                // Parse module AST
+                let ast;
+                try {
+                    const code = readFileSync(module.file, 'utf-8');
+                    ast = parse(code, {
+                        sourceType: 'module',
+                        plugins: ['jsx', 'typescript']
+                    });
+                }
+                catch (error) {
+                    const err = error;
+                    console.log(`[PrefixEvaluator] Failed to parse ${module.file}:`, err.message);
+                    continue;
+                }
+                // Try to evaluate prefix based on placeholder type
+                const evaluatedPrefix = await this.evaluatePrefix(mountPoint.prefix, mountPoint.line, ast, module);
+                if (evaluatedPrefix && evaluatedPrefix !== mountPoint.prefix) {
+                    mountPoint.prefix = evaluatedPrefix;
+                    mountPoint.evaluated = true;
+                    successfulEvaluations++;
+                    console.log(`[PrefixEvaluator] Resolved ${mountPoint.file}:${mountPoint.line}: ${evaluatedPrefix}`);
+                }
+            }
+            console.log(`[PrefixEvaluator] Evaluated ${successfulEvaluations}/${mountPointsEvaluated} mount points`);
+            return createSuccessResult({ nodes: 0, edges: 0 }, { mountPointsEvaluated, successfulEvaluations });
+        }
+        catch (error) {
+            console.error(`[PrefixEvaluator] Error:`, error);
+            return createErrorResult(error);
+        }
+    }
+    /**
+     * Evaluate prefix based on placeholder type
+     */
+    async evaluatePrefix(placeholder, line, ast, _module) {
+        if (placeholder === '${variable}') {
+            return this.evaluateVariable(line, ast);
+        }
+        else if (placeholder === '${binary}') {
+            return this.evaluateBinary(line, ast);
+        }
+        else if (placeholder === '${template}') {
+            return this.evaluateTemplate(line, ast);
+        }
+        else if (placeholder === '${member}') {
+            return this.evaluateMember(line, ast);
+        }
+        // ${call}, ${conditional} - not supported yet
+        return null;
+    }
+    /**
+     * Resolve ${variable} - find VariableDeclaration
+     */
+    evaluateVariable(line, ast) {
+        let variableName = null;
+        let variableValue = null;
+        // First find app.use() on the target line and get variable name
+        traverse(ast, {
+            CallExpression: (path) => {
+                const node = path.node;
+                if (node.loc?.start.line === line) {
+                    // Check if this is app.use() or router.use()
+                    if (node.callee.type === 'MemberExpression' &&
+                        node.callee.property.name === 'use' &&
+                        node.arguments.length >= 2) {
+                        const firstArg = node.arguments[0];
+                        if (firstArg.type === 'Identifier') {
+                            variableName = firstArg.name;
+                        }
+                    }
+                }
+            }
+        });
+        if (!variableName) {
+            return null;
+        }
+        // Now find declaration of this variable
+        const targetName = variableName;
+        traverse(ast, {
+            VariableDeclarator: (path) => {
+                const node = path.node;
+                if (node.id.type === 'Identifier' && node.id.name === targetName) {
+                    if (node.init && node.init.type === 'StringLiteral') {
+                        variableValue = node.init.value;
+                    }
+                }
+            }
+        });
+        return variableValue;
+    }
+    /**
+     * Resolve ${binary} - BinaryExpression (a + b)
+     */
+    evaluateBinary(line, ast) {
+        let binaryExpression = null;
+        // Find app.use() on target line and get BinaryExpression
+        traverse(ast, {
+            CallExpression: (path) => {
+                const node = path.node;
+                if (node.loc?.start.line === line) {
+                    if (node.callee.type === 'MemberExpression' &&
+                        node.callee.property.name === 'use' &&
+                        node.arguments.length >= 2) {
+                        const firstArg = node.arguments[0];
+                        if (firstArg.type === 'BinaryExpression') {
+                            binaryExpression = firstArg;
+                        }
+                    }
+                }
+            }
+        });
+        if (!binaryExpression) {
+            return null;
+        }
+        // Cast to help TypeScript understand the narrowing after closure mutation
+        const expr = binaryExpression;
+        // Recursively resolve both sides of Binary Expression
+        const left = this.resolveExpression(expr.left, ast);
+        const right = this.resolveExpression(expr.right, ast);
+        if (left && right && expr.operator === '+') {
+            return left + right;
+        }
+        return null;
+    }
+    /**
+     * Recursively resolve arbitrary expression
+     */
+    resolveExpression(node, ast) {
+        if (node.type === 'StringLiteral') {
+            return node.value;
+        }
+        else if (node.type === 'Identifier') {
+            // Find variable declaration
+            let value = null;
+            const targetName = node.name;
+            traverse(ast, {
+                VariableDeclarator: (path) => {
+                    if (path.node.id.type === 'Identifier' &&
+                        path.node.id.name === targetName &&
+                        path.node.init &&
+                        path.node.init.type === 'StringLiteral') {
+                        value = path.node.init.value;
+                    }
+                }
+            });
+            return value;
+        }
+        else if (node.type === 'BinaryExpression') {
+            const binaryNode = node;
+            const left = this.resolveExpression(binaryNode.left, ast);
+            const right = this.resolveExpression(binaryNode.right, ast);
+            if (left && right && binaryNode.operator === '+') {
+                return left + right;
+            }
+        }
+        else if (node.type === 'MemberExpression') {
+            // Resolve MemberExpression (for TemplateLiteral with objects)
+            return this.resolveMemberExpression(node, ast);
+        }
+        return null;
+    }
+    /**
+     * Resolve ${template} - TemplateLiteral with variables
+     */
+    evaluateTemplate(line, ast) {
+        let templateLiteral = null;
+        // Find app.use() and TemplateLiteral
+        traverse(ast, {
+            CallExpression: (path) => {
+                const node = path.node;
+                if (node.loc?.start.line === line) {
+                    if (node.callee.type === 'MemberExpression' &&
+                        node.callee.property.name === 'use' &&
+                        node.arguments.length >= 2) {
+                        const firstArg = node.arguments[0];
+                        if (firstArg.type === 'TemplateLiteral') {
+                            templateLiteral = firstArg;
+                        }
+                    }
+                }
+            }
+        });
+        if (!templateLiteral) {
+            return null;
+        }
+        // Cast to help TypeScript understand the narrowing after closure mutation
+        const tmpl = templateLiteral;
+        // Assemble string from quasis and expressions
+        let result = '';
+        for (let i = 0; i < tmpl.quasis.length; i++) {
+            result += tmpl.quasis[i].value.raw;
+            if (i < tmpl.expressions.length) {
+                const expr = tmpl.expressions[i];
+                const resolvedValue = this.resolveExpression(expr, ast);
+                if (resolvedValue === null) {
+                    return null; // Couldn't resolve expression
+                }
+                result += resolvedValue;
+            }
+        }
+        return result;
+    }
+    /**
+     * Resolve ${member} - MemberExpression (config.apiPrefix)
+     */
+    evaluateMember(line, ast) {
+        let memberExpression = null;
+        // Find app.use() and MemberExpression
+        traverse(ast, {
+            CallExpression: (path) => {
+                const node = path.node;
+                if (node.loc?.start.line === line) {
+                    if (node.callee.type === 'MemberExpression' &&
+                        node.callee.property.name === 'use' &&
+                        node.arguments.length >= 2) {
+                        const firstArg = node.arguments[0];
+                        if (firstArg.type === 'MemberExpression') {
+                            memberExpression = firstArg;
+                        }
+                    }
+                }
+            }
+        });
+        if (!memberExpression) {
+            return null;
+        }
+        // Resolve MemberExpression (can be nested: config.nested.path)
+        return this.resolveMemberExpression(memberExpression, ast);
+    }
+    /**
+     * Recursively resolve MemberExpression
+     */
+    resolveMemberExpression(node, ast) {
+        if (node.type !== 'MemberExpression') {
+            return null;
+        }
+        // Get path to property: config.nested.path → ['config', 'nested', 'path']
+        const path = [];
+        let current = node;
+        while (current.type === 'MemberExpression') {
+            const memberNode = current;
+            if (memberNode.property.type === 'Identifier') {
+                path.unshift(memberNode.property.name);
+            }
+            else if (memberNode.property.type === 'NumericLiteral') {
+                // Array access: arr[0]
+                path.unshift(memberNode.property.value);
+            }
+            current = memberNode.object;
+        }
+        if (current.type === 'Identifier') {
+            path.unshift(current.name);
+        }
+        else {
+            return null;
+        }
+        // Now resolve via AST
+        // Find object declaration
+        const rootName = path[0];
+        let objectValue = null;
+        traverse(ast, {
+            VariableDeclarator: (varPath) => {
+                if (varPath.node.id.type === 'Identifier' &&
+                    varPath.node.id.name === rootName &&
+                    varPath.node.init &&
+                    varPath.node.init.type === 'ObjectExpression') {
+                    objectValue = this.evaluateObjectExpression(varPath.node.init);
+                }
+                else if (varPath.node.id.type === 'Identifier' &&
+                    varPath.node.id.name === rootName &&
+                    varPath.node.init &&
+                    varPath.node.init.type === 'ArrayExpression') {
+                    objectValue = this.evaluateArrayExpression(varPath.node.init);
+                }
+            }
+        });
+        if (!objectValue) {
+            return null;
+        }
+        // Walk through path and get value
+        let result = objectValue;
+        for (let i = 1; i < path.length; i++) {
+            const key = path[i];
+            if (result && typeof result === 'object' && key in result) {
+                result = result[key];
+            }
+            else {
+                return null;
+            }
+        }
+        return typeof result === 'string' ? result : null;
+    }
+    /**
+     * Evaluate ObjectExpression to plain JS object
+     */
+    evaluateObjectExpression(node) {
+        const obj = {};
+        for (const prop of node.properties) {
+            if (prop.type === 'ObjectProperty') {
+                const objProp = prop;
+                if (objProp.key.type === 'Identifier') {
+                    const key = objProp.key.name;
+                    if (objProp.value.type === 'StringLiteral') {
+                        obj[key] = objProp.value.value;
+                    }
+                    else if (objProp.value.type === 'ObjectExpression') {
+                        obj[key] = this.evaluateObjectExpression(objProp.value);
+                    }
+                }
+            }
+        }
+        return obj;
+    }
+    /**
+     * Evaluate ArrayExpression to plain JS array
+     */
+    evaluateArrayExpression(node) {
+        const arr = [];
+        for (const element of node.elements) {
+            if (element && element.type === 'StringLiteral') {
+                arr.push(element.value);
+            }
+        }
+        return arr;
+    }
+    /**
+     * Helper method for finding edges
+     */
+    findEdges(graph, criteria) {
+        const result = [];
+        if (!graph.edges)
+            return result;
+        for (const edge of graph.edges.values()) {
+            let matches = true;
+            for (const [key, value] of Object.entries(criteria)) {
+                if (edge[key] !== value) {
+                    matches = false;
+                    break;
+                }
+            }
+            if (matches) {
+                result.push(edge);
+            }
+        }
+        return result;
+    }
+}

package/dist/plugins/enrichment/RustFFIEnricher.d.ts

@@ -0,0 +1,25 @@
+/**
+ * RustFFIEnricher - links JavaScript CALL nodes to Rust NAPI functions
+ * Creates FFI_CALLS edges between JS calls and their Rust implementations
+ */
+import { Plugin } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+export declare class RustFFIEnricher extends Plugin {
+    get metadata(): PluginMetadata;
+    execute(context: PluginContext): Promise<PluginResult>;
+    private buildNapiIndex;
+    private findRustCallingJsCalls;
+    private matchJsCallToRust;
+    /**
+     * Convert Rust snake_case to JavaScript camelCase
+     * add_nodes -> addNodes
+     * compute_node_id_js -> computeNodeIdJs
+     */
+    private rustNameToJs;
+    /**
+     * Convert JavaScript camelCase to Rust snake_case
+     * addNodes -> add_nodes
+     */
+    private jsNameToRust;
+}
+//# sourceMappingURL=RustFFIEnricher.d.ts.map

package/dist/plugins/enrichment/RustFFIEnricher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RustFFIEnricher.d.ts","sourceRoot":"","sources":["../../../src/plugins/enrichment/RustFFIEnricher.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAoBhF,qBAAa,eAAgB,SAAQ,MAAM;IACzC,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;YA+C9C,cAAc;YAiCd,sBAAsB;IAuCpC,OAAO,CAAC,iBAAiB;IAyCzB;;;;OAIG;IACH,OAAO,CAAC,YAAY;IAIpB;;;OAGG;IACH,OAAO,CAAC,YAAY;CAIrB"}

package/dist/plugins/enrichment/RustFFIEnricher.js

@@ -0,0 +1,170 @@
+/**
+ * RustFFIEnricher - links JavaScript CALL nodes to Rust NAPI functions
+ * Creates FFI_CALLS edges between JS calls and their Rust implementations
+ */
+import { Plugin, createSuccessResult } from '../Plugin.js';
+export class RustFFIEnricher extends Plugin {
+    get metadata() {
+        return {
+            name: 'RustFFIEnricher',
+            phase: 'ENRICHMENT',
+            priority: 45, // After MethodCallResolver (50)
+            creates: {
+                nodes: [],
+                edges: ['FFI_CALLS']
+            },
+            dependencies: ['RustAnalyzer', 'MethodCallResolver']
+        };
+    }
+    async execute(context) {
+        const { graph } = context;
+        // 1. Build index of NAPI-exported Rust functions/methods
+        const napiIndex = await this.buildNapiIndex(graph);
+        if (napiIndex.size === 0) {
+            console.log('[RustFFIEnricher] No NAPI exports found, skipping');
+            return createSuccessResult({ nodes: 0, edges: 0 }, { skipped: true, reason: 'No NAPI exports' });
+        }
+        console.log(`[RustFFIEnricher] Indexed ${napiIndex.size} NAPI exports`);
+        // 2. Find JS CALL nodes that target Rust
+        const jsCalls = await this.findRustCallingJsCalls(graph);
+        console.log(`[RustFFIEnricher] Found ${jsCalls.length} candidate JS calls`);
+        // 3. Match and create FFI_CALLS edges
+        let edgesCreated = 0;
+        const unmatched = [];
+        for (const call of jsCalls) {
+            const rustTarget = this.matchJsCallToRust(call, napiIndex);
+            if (rustTarget) {
+                await graph.addEdge({
+                    src: call.id,
+                    dst: rustTarget.id,
+                    type: 'FFI_CALLS'
+                });
+                edgesCreated++;
+            }
+            else {
+                const callName = `${call.object || ''}.${call.method || call.name}`;
+                if (callName && !unmatched.includes(callName)) {
+                    unmatched.push(callName);
+                }
+            }
+        }
+        if (unmatched.length > 0 && unmatched.length <= 20) {
+            console.log(`[RustFFIEnricher] Unmatched calls:`, unmatched.slice(0, 10));
+        }
+        console.log(`[RustFFIEnricher] Created ${edgesCreated} FFI_CALLS edges`);
+        return createSuccessResult({ nodes: 0, edges: edgesCreated }, { unmatched: unmatched.length });
+    }
+    async buildNapiIndex(graph) {
+        const index = new Map();
+        // Index RUST_FUNCTION with napi=true
+        for await (const node of graph.queryNodes({ nodeType: 'RUST_FUNCTION' })) {
+            const rustNode = node;
+            if (rustNode.napi) {
+                const jsName = rustNode.napiJsName || this.rustNameToJs(rustNode.name);
+                index.set(jsName, rustNode);
+                // Also store with Rust name for direct matches
+                index.set(rustNode.name, rustNode);
+            }
+        }
+        // Index RUST_METHOD with napi=true
+        for await (const node of graph.queryNodes({ nodeType: 'RUST_METHOD' })) {
+            const rustNode = node;
+            if (rustNode.napi) {
+                const jsName = rustNode.napiJsName || this.rustNameToJs(rustNode.name);
+                // Methods are called as object.method() in JS
+                // Use implType to determine the class name
+                if (rustNode.implType) {
+                    // GraphEngine.addNodes -> maps to GraphEngine::add_nodes
+                    index.set(`${rustNode.implType}.${jsName}`, rustNode);
+                    // Also store just method name for loose matching
+                    index.set(jsName, rustNode);
+                }
+            }
+        }
+        return index;
+    }
+    async findRustCallingJsCalls(graph) {
+        const candidates = [];
+        const seen = new Set();
+        for await (const call of graph.queryNodes({ nodeType: 'CALL' })) {
+            const callNode = call;
+            // Skip duplicates
+            if (seen.has(callNode.id))
+                continue;
+            seen.add(callNode.id);
+            // Look for calls on objects that are likely Rust bindings:
+            // - engine.addNodes(), graph.bfs()
+            // - Direct function calls: computeNodeIdJs()
+            // - Method calls on GraphEngine instances
+            if (callNode.object === 'engine' ||
+                callNode.object === 'graph' ||
+                callNode.object === 'this.engine' ||
+                callNode.object === 'this.graph' ||
+                callNode.object === 'nativeBinding' ||
+                (callNode.name && callNode.name.startsWith('compute'))) {
+                candidates.push(callNode);
+                continue;
+            }
+            // Check if method name matches known NAPI pattern
+            if (callNode.method) {
+                const snakeName = this.jsNameToRust(callNode.method);
+                // Common NAPI patterns: add_*, get_*, set_*, query_*, etc.
+                if (snakeName && /^(add|get|set|query|compute|find|run|create|delete|update|list|check|flush|load|save|bfs|dfs)_/.test(snakeName)) {
+                    candidates.push(callNode);
+                }
+            }
+        }
+        return candidates;
+    }
+    matchJsCallToRust(call, napiIndex) {
+        // Try multiple matching strategies
+        // 1. Direct method match: object.method -> Class.method
+        if (call.method) {
+            // Try exact match with class name (GraphEngine.method)
+            for (const [key, node] of napiIndex) {
+                if (key.endsWith(`.${call.method}`)) {
+                    return node;
+                }
+            }
+            // Try just method name
+            if (napiIndex.has(call.method)) {
+                return napiIndex.get(call.method);
+            }
+            // Try snake_case version
+            const snakeName = this.jsNameToRust(call.method);
+            if (snakeName && napiIndex.has(snakeName)) {
+                return napiIndex.get(snakeName);
+            }
+        }
+        // 2. Direct function call match
+        if (call.name) {
+            const callName = call.name;
+            if (napiIndex.has(callName)) {
+                return napiIndex.get(callName);
+            }
+            // Try snake_case version
+            const snakeName = this.jsNameToRust(callName);
+            if (snakeName && napiIndex.has(snakeName)) {
+                return napiIndex.get(snakeName);
+            }
+        }
+        return null;
+    }
+    /**
+     * Convert Rust snake_case to JavaScript camelCase
+     * add_nodes -> addNodes
+     * compute_node_id_js -> computeNodeIdJs
+     */
+    rustNameToJs(rustName) {
+        return rustName.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+    }
+    /**
+     * Convert JavaScript camelCase to Rust snake_case
+     * addNodes -> add_nodes
+     */
+    jsNameToRust(jsName) {
+        if (!jsName)
+            return null;
+        return jsName.replace(/([A-Z])/g, '_$1').toLowerCase().replace(/^_/, '');
+    }
+}