@grafema/cli 0.1.1-alpha

package/dist/commands/explore.js

@@ -0,0 +1,633 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Explore command - Interactive TUI for graph navigation
+ */
+import { Command } from 'commander';
+import { resolve, join, relative } from 'path';
+import { existsSync } from 'fs';
+import { execSync } from 'child_process';
+import { useState, useEffect } from 'react';
+import { render, Box, Text, useInput, useApp } from 'ink';
+import { RFDBServerBackend } from '@grafema/core';
+import { getCodePreview, formatCodePreview } from '../utils/codePreview.js';
+import { exitWithError } from '../utils/errorFormatter.js';
+// Main Explorer Component
+function Explorer({ backend, startNode, projectPath }) {
+    const { exit } = useApp();
+    const [state, setState] = useState({
+        currentNode: startNode,
+        callers: [],
+        callees: [],
+        fields: [],
+        methods: [],
+        dataFlowSources: [],
+        dataFlowTargets: [],
+        breadcrumbs: startNode ? [startNode] : [],
+        selectedIndex: 0,
+        selectedPanel: 'callers',
+        searchMode: false,
+        searchQuery: '',
+        searchResults: [],
+        modules: [],
+        loading: true,
+        error: null,
+        visibleCallers: 10,
+        visibleCallees: 10,
+        viewMode: 'function',
+        showCodePreview: false,
+        codePreviewLines: [],
+    });
+    // Load data when currentNode changes
+    useEffect(() => {
+        if (!state.currentNode)
+            return;
+        const load = async () => {
+            setState(s => ({ ...s, loading: true }));
+            try {
+                const nodeType = state.currentNode.type;
+                if (nodeType === 'CLASS') {
+                    // Load fields and methods for class
+                    const { fields, methods } = await getClassMembers(backend, state.currentNode.id);
+                    setState(s => ({
+                        ...s,
+                        fields,
+                        methods,
+                        viewMode: 'class',
+                        selectedPanel: 'fields',
+                        loading: false,
+                        selectedIndex: 0,
+                    }));
+                }
+                else if (nodeType === 'VARIABLE' || nodeType === 'PARAMETER') {
+                    // Load data flow for variable
+                    const { sources, targets } = await getDataFlow(backend, state.currentNode.id);
+                    setState(s => ({
+                        ...s,
+                        dataFlowSources: sources,
+                        dataFlowTargets: targets,
+                        viewMode: 'dataflow',
+                        selectedPanel: 'sources',
+                        loading: false,
+                        selectedIndex: 0,
+                    }));
+                }
+                else {
+                    // Load callers/callees for function
+                    const callers = await getCallers(backend, state.currentNode.id, 50);
+                    const callees = await getCallees(backend, state.currentNode.id, 50);
+                    setState(s => ({
+                        ...s,
+                        callers,
+                        callees,
+                        viewMode: 'function',
+                        selectedPanel: 'callers',
+                        loading: false,
+                        selectedIndex: 0,
+                        visibleCallers: 10,
+                        visibleCallees: 10,
+                    }));
+                }
+            }
+            catch (err) {
+                setState(s => ({
+                    ...s,
+                    error: err.message,
+                    loading: false,
+                }));
+            }
+        };
+        load();
+    }, [state.currentNode?.id]);
+    // Get current list based on view mode and panel
+    const getCurrentList = () => {
+        if (state.viewMode === 'search')
+            return state.searchResults;
+        if (state.viewMode === 'modules')
+            return state.modules;
+        if (state.viewMode === 'class') {
+            return state.selectedPanel === 'fields' ? state.fields : state.methods;
+        }
+        if (state.viewMode === 'dataflow') {
+            return state.selectedPanel === 'sources' ? state.dataFlowSources : state.dataFlowTargets;
+        }
+        return state.selectedPanel === 'callers' ? state.callers : state.callees;
+    };
+    // Keyboard input
+    useInput((input, key) => {
+        if (state.searchMode) {
+            if (key.escape) {
+                setState(s => ({ ...s, searchMode: false, searchQuery: '' }));
+            }
+            else if (key.return) {
+                performSearch(state.searchQuery);
+                setState(s => ({ ...s, searchMode: false }));
+            }
+            else if (key.backspace || key.delete) {
+                setState(s => ({ ...s, searchQuery: s.searchQuery.slice(0, -1) }));
+            }
+            else if (input && !key.ctrl && !key.meta) {
+                setState(s => ({ ...s, searchQuery: s.searchQuery + input }));
+            }
+            return;
+        }
+        // Normal mode
+        if (input === 'q') {
+            exit();
+            return;
+        }
+        if (input === '/') {
+            setState(s => ({ ...s, searchMode: true, searchQuery: '' }));
+            return;
+        }
+        if (input === '?') {
+            // TODO: show help
+            return;
+        }
+        // 'm' - show modules view
+        if (input === 'm') {
+            loadModules();
+            return;
+        }
+        // Space - toggle code preview
+        if (input === ' ') {
+            if (state.currentNode && state.currentNode.file && state.currentNode.line) {
+                if (state.showCodePreview) {
+                    // Hide code preview
+                    setState(s => ({ ...s, showCodePreview: false, codePreviewLines: [] }));
+                }
+                else {
+                    // Show code preview
+                    const preview = getCodePreview({
+                        file: state.currentNode.file,
+                        line: state.currentNode.line,
+                    });
+                    if (preview) {
+                        const formatted = formatCodePreview(preview, state.currentNode.line);
+                        setState(s => ({ ...s, showCodePreview: true, codePreviewLines: formatted }));
+                    }
+                }
+            }
+            return;
+        }
+        // 'o' - open in editor
+        if (input === 'o') {
+            if (state.currentNode && state.currentNode.file) {
+                const editor = process.env.EDITOR || 'code';
+                const file = state.currentNode.file;
+                const line = state.currentNode.line;
+                try {
+                    if (editor.includes('code')) {
+                        // VS Code supports --goto
+                        execSync(`${editor} --goto "${file}:${line || 1}"`, { stdio: 'ignore' });
+                    }
+                    else {
+                        // Generic editor
+                        execSync(`${editor} +${line || 1} "${file}"`, { stdio: 'ignore' });
+                    }
+                }
+                catch {
+                    // Ignore editor errors
+                }
+            }
+            return;
+        }
+        // Arrow keys for panel switching
+        if (key.leftArrow || input === 'h') {
+            if (state.viewMode === 'function') {
+                setState(s => ({ ...s, selectedPanel: 'callers', selectedIndex: 0 }));
+            }
+            else if (state.viewMode === 'class') {
+                setState(s => ({ ...s, selectedPanel: 'fields', selectedIndex: 0 }));
+            }
+            else if (state.viewMode === 'dataflow') {
+                setState(s => ({ ...s, selectedPanel: 'sources', selectedIndex: 0 }));
+            }
+            return;
+        }
+        if (key.rightArrow || input === 'l') {
+            if (state.viewMode === 'function') {
+                setState(s => ({ ...s, selectedPanel: 'callees', selectedIndex: 0 }));
+            }
+            else if (state.viewMode === 'class') {
+                setState(s => ({ ...s, selectedPanel: 'methods', selectedIndex: 0 }));
+            }
+            else if (state.viewMode === 'dataflow') {
+                setState(s => ({ ...s, selectedPanel: 'targets', selectedIndex: 0 }));
+            }
+            return;
+        }
+        // Up arrow - works in all modes
+        if (key.upArrow || input === 'k') {
+            setState(s => ({
+                ...s,
+                selectedIndex: Math.max(0, s.selectedIndex - 1),
+            }));
+            return;
+        }
+        // Down arrow - works in all modes
+        if (key.downArrow || input === 'j') {
+            const list = getCurrentList();
+            setState(s => {
+                const newIndex = Math.min(list.length - 1, s.selectedIndex + 1);
+                return { ...s, selectedIndex: newIndex };
+            });
+            return;
+        }
+        // Enter - select item
+        if (key.return) {
+            const list = getCurrentList();
+            const selected = list[state.selectedIndex];
+            if (selected) {
+                // Don't navigate into recursive calls (same function)
+                if (selected.id !== state.currentNode?.id) {
+                    navigateTo(selected);
+                    setState(s => ({ ...s, viewMode: 'function', selectedPanel: 'callers' }));
+                }
+            }
+            return;
+        }
+        if (key.backspace || key.delete) {
+            goBack();
+            return;
+        }
+        if (input === 'tab') {
+            setState(s => ({
+                ...s,
+                selectedPanel: s.selectedPanel === 'callers' ? 'callees' : 'callers',
+                selectedIndex: 0,
+            }));
+            return;
+        }
+    });
+    const navigateTo = (node) => {
+        setState(s => ({
+            ...s,
+            currentNode: node,
+            breadcrumbs: [...s.breadcrumbs, node],
+            selectedIndex: 0,
+        }));
+    };
+    const goBack = () => {
+        // From search/modules view, go back to function view
+        if (state.viewMode !== 'function') {
+            setState(s => ({
+                ...s,
+                viewMode: 'function',
+                selectedPanel: 'callers',
+                selectedIndex: 0,
+            }));
+            return;
+        }
+        // From function view with breadcrumbs, go back
+        if (state.breadcrumbs.length > 1) {
+            const newBreadcrumbs = state.breadcrumbs.slice(0, -1);
+            const previousNode = newBreadcrumbs[newBreadcrumbs.length - 1];
+            setState(s => ({
+                ...s,
+                currentNode: previousNode,
+                breadcrumbs: newBreadcrumbs,
+                selectedIndex: 0,
+            }));
+        }
+    };
+    const performSearch = async (query) => {
+        if (!query.trim())
+            return;
+        setState(s => ({ ...s, loading: true }));
+        try {
+            const results = await searchNodes(backend, query, 20);
+            setState(s => ({
+                ...s,
+                searchResults: results,
+                viewMode: 'search',
+                selectedPanel: 'search',
+                selectedIndex: 0,
+                loading: false,
+                error: results.length === 0 ? `No results for "${query}"` : null,
+            }));
+        }
+        catch (err) {
+            setState(s => ({
+                ...s,
+                error: err.message,
+                loading: false,
+            }));
+        }
+    };
+    const loadModules = async () => {
+        setState(s => ({ ...s, loading: true }));
+        try {
+            const modules = await getModules(backend, 50);
+            setState(s => ({
+                ...s,
+                modules,
+                viewMode: 'modules',
+                selectedPanel: 'modules',
+                selectedIndex: 0,
+                loading: false,
+            }));
+        }
+        catch (err) {
+            setState(s => ({
+                ...s,
+                error: err.message,
+                loading: false,
+            }));
+        }
+    };
+    const formatLoc = (node) => {
+        if (!node.file)
+            return '';
+        const rel = relative(projectPath, node.file);
+        return node.line ? `${rel}:${node.line}` : rel;
+    };
+    // Render
+    if (!state.currentNode) {
+        return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { color: "yellow", children: "No function selected." }), _jsx(Text, { children: "Press / to search, q to quit." }), state.searchMode && (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { children: "Search: " }), _jsx(Text, { color: "cyan", children: state.searchQuery }), _jsx(Text, { color: "gray", children: "_" })] }))] }));
+    }
+    // Build badges for current node
+    const badges = [];
+    if (state.currentNode.async)
+        badges.push('async');
+    if (state.currentNode.exported)
+        badges.push('exp');
+    if (state.currentNode.generator)
+        badges.push('gen');
+    if (state.currentNode.arrowFunction)
+        badges.push('arrow');
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "blue", padding: 1, children: [_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "Grafema Explorer" }), state.loading && _jsx(Text, { color: "yellow", children: " (loading...)" }), badges.length > 0 && (_jsxs(Text, { children: ['  ', badges.map((badge, i) => (_jsxs(Text, { children: [_jsxs(Text, { color: "magenta", children: ["[", badge, "]"] }), i < badges.length - 1 ? ' ' : ''] }, `badge-${i}`)))] }))] }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: "gray", children: state.breadcrumbs.map((b, i) => (_jsxs(Text, { children: [i > 0 ? ' → ' : '', _jsx(Text, { color: i === state.breadcrumbs.length - 1 ? 'white' : 'gray', children: b.name })] }, `bc-${i}-${b.id}`))) }) }), _jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Text, { children: [_jsx(Text, { color: "green", bold: true, children: state.currentNode.type }), _jsx(Text, { children: ": " }), _jsx(Text, { bold: true, children: state.currentNode.name })] }), state.currentNode.signature && (_jsx(Text, { color: "yellow", children: state.currentNode.signature })), state.currentNode.jsdocSummary && (_jsxs(Text, { color: "gray", italic: true, children: ["  ", state.currentNode.jsdocSummary] })), _jsx(Text, { color: "gray", children: formatLoc(state.currentNode) })] }), state.viewMode === 'search' && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { bold: true, color: "cyan", children: ["Search Results (", state.searchResults.length, "):"] }), state.searchResults.length === 0 ? (_jsx(Text, { color: "gray", children: "  No results" })) : (state.searchResults.map((item, i) => (_jsxs(Text, { children: [i === state.selectedIndex ? (_jsx(Text, { color: "cyan", bold: true, children: '> ' })) : (_jsx(Text, { children: '  ' })), _jsxs(Text, { color: i === state.selectedIndex ? 'white' : 'gray', children: [_jsx(Text, { color: "green", children: item.type }), " ", item.name] }), _jsxs(Text, { color: "gray", dimColor: true, children: [" ", formatLoc(item)] })] }, `search-${i}-${item.id}`))))] })), state.viewMode === 'modules' && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { bold: true, color: "cyan", children: ["Modules (", state.modules.length, "):"] }), state.modules.length === 0 ? (_jsx(Text, { color: "gray", children: "  No modules" })) : (state.modules.slice(0, 20).map((mod, i) => (_jsxs(Text, { children: [i === state.selectedIndex ? (_jsx(Text, { color: "cyan", bold: true, children: '> ' })) : (_jsx(Text, { children: '  ' })), _jsx(Text, { color: i === state.selectedIndex ? 'white' : 'gray', children: formatLoc(mod) })] }, `mod-${i}-${mod.id}`)))), state.modules.length > 20 && (_jsxs(Text, { color: "gray", children: ["  \u2193 ", state.modules.length - 20, " more"] }))] })), state.viewMode === 'function' && (_jsxs(Box, { children: [_jsxs(Box, { flexDirection: "column", width: "50%", paddingRight: 1, children: [_jsxs(Text, { bold: true, color: state.selectedPanel === 'callers' ? 'cyan' : 'gray', children: ["Called by (", state.callers.length, "):"] }), state.callers.length === 0 ? (_jsx(Text, { color: "gray", children: "  (none)" })) : (state.callers.slice(0, state.visibleCallers).map((caller, i) => {
+                                const isRecursive = caller.id === state.currentNode?.id;
+                                return (_jsxs(Text, { children: [state.selectedPanel === 'callers' && i === state.selectedIndex ? (_jsx(Text, { color: "cyan", bold: true, children: '> ' })) : (_jsx(Text, { children: '  ' })), _jsxs(Text, { color: isRecursive ? 'yellow' : (state.selectedPanel === 'callers' && i === state.selectedIndex ? 'white' : 'gray'), children: [caller.name, isRecursive ? ' ↻' : ''] })] }, `caller-${i}-${caller.id}`));
+                            })), state.callers.length > state.visibleCallers && (_jsxs(Text, { color: "gray", children: ["  \u2193 ", state.callers.length - state.visibleCallers, " more"] }))] }), _jsxs(Box, { flexDirection: "column", width: "50%", paddingLeft: 1, children: [_jsxs(Text, { bold: true, color: state.selectedPanel === 'callees' ? 'cyan' : 'gray', children: ["Calls (", state.callees.length, "):"] }), state.callees.length === 0 ? (_jsx(Text, { color: "gray", children: "  (none)" })) : (state.callees.slice(0, state.visibleCallees).map((callee, i) => {
+                                const isRecursive = callee.id === state.currentNode?.id;
+                                return (_jsxs(Text, { children: [state.selectedPanel === 'callees' && i === state.selectedIndex ? (_jsx(Text, { color: "cyan", bold: true, children: '> ' })) : (_jsx(Text, { children: '  ' })), _jsxs(Text, { color: isRecursive ? 'yellow' : (state.selectedPanel === 'callees' && i === state.selectedIndex ? 'white' : 'gray'), children: [callee.name, isRecursive ? ' ↻' : ''] })] }, `callee-${i}-${callee.id}`));
+                            })), state.callees.length > state.visibleCallees && (_jsxs(Text, { color: "gray", children: ["  \u2193 ", state.callees.length - state.visibleCallees, " more"] }))] })] })), state.viewMode === 'class' && (_jsxs(Box, { children: [_jsxs(Box, { flexDirection: "column", width: "50%", paddingRight: 1, children: [_jsxs(Text, { bold: true, color: state.selectedPanel === 'fields' ? 'cyan' : 'gray', children: ["Fields (", state.fields.length, "):"] }), state.fields.length === 0 ? (_jsx(Text, { color: "gray", children: "  (none)" })) : (state.fields.slice(0, 15).map((field, i) => (_jsxs(Text, { children: [state.selectedPanel === 'fields' && i === state.selectedIndex ? (_jsx(Text, { color: "cyan", bold: true, children: '> ' })) : (_jsx(Text, { children: '  ' })), _jsx(Text, { color: state.selectedPanel === 'fields' && i === state.selectedIndex ? 'white' : 'gray', children: field.name })] }, `field-${i}-${field.id}`)))), state.fields.length > 15 && (_jsxs(Text, { color: "gray", children: ["  \u2193 ", state.fields.length - 15, " more"] }))] }), _jsxs(Box, { flexDirection: "column", width: "50%", paddingLeft: 1, children: [_jsxs(Text, { bold: true, color: state.selectedPanel === 'methods' ? 'cyan' : 'gray', children: ["Methods (", state.methods.length, "):"] }), state.methods.length === 0 ? (_jsx(Text, { color: "gray", children: "  (none)" })) : (state.methods.slice(0, 15).map((method, i) => (_jsxs(Text, { children: [state.selectedPanel === 'methods' && i === state.selectedIndex ? (_jsx(Text, { color: "cyan", bold: true, children: '> ' })) : (_jsx(Text, { children: '  ' })), _jsxs(Text, { color: state.selectedPanel === 'methods' && i === state.selectedIndex ? 'white' : 'gray', children: [method.name, "()"] })] }, `method-${i}-${method.id}`)))), state.methods.length > 15 && (_jsxs(Text, { color: "gray", children: ["  \u2193 ", state.methods.length - 15, " more"] }))] })] })), state.viewMode === 'dataflow' && (_jsxs(Box, { children: [_jsxs(Box, { flexDirection: "column", width: "50%", paddingRight: 1, children: [_jsxs(Text, { bold: true, color: state.selectedPanel === 'sources' ? 'cyan' : 'gray', children: ["Data from (", state.dataFlowSources.length, "):"] }), state.dataFlowSources.length === 0 ? (_jsx(Text, { color: "gray", children: "  (none)" })) : (state.dataFlowSources.slice(0, 15).map((src, i) => (_jsxs(Text, { children: [state.selectedPanel === 'sources' && i === state.selectedIndex ? (_jsx(Text, { color: "cyan", bold: true, children: '> ' })) : (_jsx(Text, { children: '  ' })), _jsxs(Text, { color: state.selectedPanel === 'sources' && i === state.selectedIndex ? 'white' : 'gray', children: ["\u2190 ", src.name, " ", _jsxs(Text, { dimColor: true, children: ["(", src.type, ")"] })] })] }, `src-${i}-${src.id}`))))] }), _jsxs(Box, { flexDirection: "column", width: "50%", paddingLeft: 1, children: [_jsxs(Text, { bold: true, color: state.selectedPanel === 'targets' ? 'cyan' : 'gray', children: ["Flows to (", state.dataFlowTargets.length, "):"] }), state.dataFlowTargets.length === 0 ? (_jsx(Text, { color: "gray", children: "  (none)" })) : (state.dataFlowTargets.slice(0, 15).map((tgt, i) => (_jsxs(Text, { children: [state.selectedPanel === 'targets' && i === state.selectedIndex ? (_jsx(Text, { color: "cyan", bold: true, children: '> ' })) : (_jsx(Text, { children: '  ' })), _jsxs(Text, { color: state.selectedPanel === 'targets' && i === state.selectedIndex ? 'white' : 'gray', children: ["\u2192 ", tgt.name, " ", _jsxs(Text, { dimColor: true, children: ["(", tgt.type, ")"] })] })] }, `tgt-${i}-${tgt.id}`))))] })] })), state.showCodePreview && state.codePreviewLines.length > 0 && (_jsxs(Box, { flexDirection: "column", marginTop: 1, borderStyle: "single", borderColor: "yellow", paddingX: 1, children: [_jsx(Text, { bold: true, color: "yellow", children: "Code Preview:" }), state.codePreviewLines.map((line, i) => (_jsx(Text, { color: line.startsWith('>') ? 'white' : 'gray', children: line }, `code-${i}`)))] })), state.error && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "red", children: ["Error: ", state.error] }) })), state.searchMode && (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { children: "Search: " }), _jsx(Text, { color: "cyan", children: state.searchQuery }), _jsx(Text, { color: "gray", children: "_" })] })), _jsx(Box, { marginTop: 1, borderStyle: "single", borderColor: "gray", paddingX: 1, children: _jsx(Text, { color: "gray", children: "\u2191\u2193: Select | \u2190\u2192: Panel | Enter: Open | Backspace: Back | /: Search | m: Modules | Space: Code | o: Editor | q: Quit" }) })] }));
+}
+// Helper function to extract NodeInfo with extended fields from a raw node
+function extractNodeInfo(node) {
+    const nodeType = node.type || node.nodeType || 'UNKNOWN';
+    return {
+        id: node.id,
+        type: nodeType,
+        name: node.name || '<anonymous>',
+        file: node.file || '',
+        line: node.line,
+        // Function-specific fields
+        async: node.async,
+        exported: node.exported,
+        generator: node.generator,
+        arrowFunction: node.arrowFunction,
+        params: node.params,
+        paramTypes: node.paramTypes,
+        returnType: node.returnType,
+        signature: node.signature,
+        jsdocSummary: node.jsdocSummary,
+    };
+}
+// Helper functions
+async function getCallers(backend, nodeId, limit) {
+    const callers = [];
+    const seen = new Set();
+    try {
+        const callEdges = await backend.getIncomingEdges(nodeId, ['CALLS']);
+        for (const edge of callEdges) {
+            if (callers.length >= limit)
+                break;
+            const callNode = await backend.getNode(edge.src);
+            if (!callNode)
+                continue;
+            const containingFunc = await findContainingFunction(backend, callNode.id);
+            if (containingFunc && !seen.has(containingFunc.id)) {
+                seen.add(containingFunc.id);
+                callers.push(containingFunc);
+            }
+        }
+    }
+    catch {
+        // Ignore
+    }
+    return callers;
+}
+async function getCallees(backend, nodeId, limit) {
+    const callees = [];
+    const seen = new Set();
+    try {
+        const callNodes = await findCallsInFunction(backend, nodeId);
+        for (const callNode of callNodes) {
+            if (callees.length >= limit)
+                break;
+            const callEdges = await backend.getOutgoingEdges(callNode.id, ['CALLS']);
+            for (const edge of callEdges) {
+                if (callees.length >= limit)
+                    break;
+                const targetNode = await backend.getNode(edge.dst);
+                if (!targetNode || seen.has(targetNode.id))
+                    continue;
+                seen.add(targetNode.id);
+                callees.push(extractNodeInfo(targetNode));
+            }
+        }
+    }
+    catch {
+        // Ignore
+    }
+    return callees;
+}
+async function findContainingFunction(backend, nodeId) {
+    const visited = new Set();
+    const queue = [{ id: nodeId, depth: 0 }];
+    while (queue.length > 0) {
+        const { id, depth } = queue.shift();
+        if (visited.has(id) || depth > 15)
+            continue;
+        visited.add(id);
+        try {
+            const edges = await backend.getIncomingEdges(id, null);
+            for (const edge of edges) {
+                const edgeType = edge.edgeType || edge.type;
+                if (!['CONTAINS', 'HAS_SCOPE', 'DECLARES'].includes(edgeType))
+                    continue;
+                const parent = await backend.getNode(edge.src);
+                if (!parent || visited.has(parent.id))
+                    continue;
+                const parentType = parent.type || parent.nodeType;
+                if (parentType === 'FUNCTION' || parentType === 'CLASS' || parentType === 'MODULE') {
+                    return extractNodeInfo(parent);
+                }
+                queue.push({ id: parent.id, depth: depth + 1 });
+            }
+        }
+        catch {
+            // Ignore
+        }
+    }
+    return null;
+}
+async function findCallsInFunction(backend, nodeId) {
+    const calls = [];
+    const visited = new Set();
+    const queue = [{ id: nodeId, depth: 0 }];
+    while (queue.length > 0) {
+        const { id, depth } = queue.shift();
+        if (visited.has(id) || depth > 10)
+            continue;
+        visited.add(id);
+        try {
+            const edges = await backend.getOutgoingEdges(id, ['CONTAINS']);
+            for (const edge of edges) {
+                const child = await backend.getNode(edge.dst);
+                if (!child)
+                    continue;
+                const childType = child.type || child.nodeType;
+                if (childType === 'CALL') {
+                    calls.push({
+                        id: child.id,
+                        type: 'CALL',
+                        name: child.name || '',
+                        file: child.file || '',
+                        line: child.line,
+                    });
+                }
+                if (childType !== 'FUNCTION' && childType !== 'CLASS') {
+                    queue.push({ id: child.id, depth: depth + 1 });
+                }
+            }
+        }
+        catch {
+            // Ignore
+        }
+    }
+    return calls;
+}
+async function searchNode(backend, query) {
+    const results = await searchNodes(backend, query, 1);
+    return results[0] || null;
+}
+async function searchNodes(backend, query, limit) {
+    const results = [];
+    const lowerQuery = query.toLowerCase();
+    for (const nodeType of ['FUNCTION', 'CLASS', 'MODULE']) {
+        for await (const node of backend.queryNodes({ nodeType: nodeType })) {
+            const name = (node.name || '').toLowerCase();
+            if (name === lowerQuery || name.includes(lowerQuery)) {
+                results.push(extractNodeInfo(node));
+                if (results.length >= limit)
+                    return results;
+            }
+        }
+    }
+    return results;
+}
+async function getModules(backend, limit) {
+    const modules = [];
+    for await (const node of backend.queryNodes({ nodeType: 'MODULE' })) {
+        modules.push(extractNodeInfo(node));
+        if (modules.length >= limit)
+            break;
+    }
+    // Sort by file path for better navigation
+    modules.sort((a, b) => a.file.localeCompare(b.file));
+    return modules;
+}
+async function getClassMembers(backend, classId) {
+    const fields = [];
+    const methods = [];
+    try {
+        // Get children via CONTAINS edge
+        const edges = await backend.getOutgoingEdges(classId, ['CONTAINS']);
+        for (const edge of edges) {
+            const child = await backend.getNode(edge.dst);
+            if (!child)
+                continue;
+            const childType = child.type || child.nodeType;
+            const nodeInfo = extractNodeInfo(child);
+            if (childType === 'FUNCTION') {
+                methods.push(nodeInfo);
+            }
+            else if (childType === 'VARIABLE' || childType === 'PARAMETER') {
+                fields.push(nodeInfo);
+            }
+        }
+    }
+    catch {
+        // Ignore
+    }
+    return { fields, methods };
+}
+async function getDataFlow(backend, varId) {
+    const sources = [];
+    const targets = [];
+    try {
+        // Get incoming ASSIGNED_FROM edges (where data comes from)
+        const inEdges = await backend.getIncomingEdges(varId, ['ASSIGNED_FROM']);
+        for (const edge of inEdges) {
+            const src = await backend.getNode(edge.src);
+            if (src) {
+                sources.push(extractNodeInfo(src));
+            }
+        }
+        // Get outgoing ASSIGNED_FROM edges (where data flows to)
+        const outEdges = await backend.getOutgoingEdges(varId, ['ASSIGNED_FROM']);
+        for (const edge of outEdges) {
+            const tgt = await backend.getNode(edge.dst);
+            if (tgt) {
+                targets.push(extractNodeInfo(tgt));
+            }
+        }
+        // Also check DERIVES_FROM for additional flow info
+        const derivesIn = await backend.getIncomingEdges(varId, ['DERIVES_FROM']);
+        for (const edge of derivesIn) {
+            const src = await backend.getNode(edge.src);
+            if (src && !sources.find(s => s.id === src.id)) {
+                sources.push(extractNodeInfo(src));
+            }
+        }
+    }
+    catch {
+        // Ignore
+    }
+    return { sources, targets };
+}
+async function findStartNode(backend, startName) {
+    if (startName) {
+        return searchNode(backend, startName);
+    }
+    // Find first function with most callers
+    let bestNode = null;
+    let bestCallerCount = 0;
+    let checked = 0;
+    for await (const node of backend.queryNodes({ nodeType: 'FUNCTION' })) {
+        const incoming = await backend.getIncomingEdges(node.id, ['CALLS']);
+        if (incoming.length > bestCallerCount) {
+            bestCallerCount = incoming.length;
+            bestNode = extractNodeInfo(node);
+        }
+        checked++;
+        if (checked >= 100)
+            break; // Limit search
+    }
+    return bestNode;
+}
+// Command
+export const exploreCommand = new Command('explore')
+    .description('Interactive graph navigation')
+    .argument('[start]', 'Starting function name')
+    .option('-p, --project <path>', 'Project path', '.')
+    .action(async (start, options) => {
+    const projectPath = resolve(options.project);
+    const grafemaDir = join(projectPath, '.grafema');
+    const dbPath = join(grafemaDir, 'graph.rfdb');
+    if (!existsSync(dbPath)) {
+        exitWithError('No graph database found', ['Run: grafema analyze']);
+    }
+    const backend = new RFDBServerBackend({ dbPath });
+    try {
+        await backend.connect();
+        const startNode = await findStartNode(backend, start || null);
+        const { waitUntilExit } = render(_jsx(Explorer, { backend: backend, startNode: startNode, projectPath: projectPath }));
+        await waitUntilExit();
+    }
+    finally {
+        await backend.close();
+    }
+});

package/dist/commands/get.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Get command - Retrieve node by semantic ID
+ *
+ * Usage:
+ *   grafema get "file.js->scope->TYPE->name"
+ *   grafema get "file.js->scope->TYPE->name" --json
+ */
+import { Command } from 'commander';
+export declare const getCommand: Command;
+//# sourceMappingURL=get.d.ts.map

package/dist/commands/get.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get.d.ts","sourceRoot":"","sources":["../../src/commands/get.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAkCpC,eAAO,MAAM,UAAU,SAyCnB,CAAC"}