cozo-memory 1.0.4 → 1.0.6

package/dist/tui-launcher.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Launcher for Python Textual TUI
+ * This spawns the Python TUI process
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const path_1 = require("path");
+const fs_1 = require("fs");
+function findPythonCommand() {
+    // Try different Python commands
+    const commands = ['python3', 'python', 'py'];
+    for (const cmd of commands) {
+        try {
+            const result = (0, child_process_1.spawn)(cmd, ['--version'], { stdio: 'pipe' });
+            if (result) {
+                return cmd;
+            }
+        }
+        catch (e) {
+            continue;
+        }
+    }
+    return 'python3'; // Default fallback
+}
+function main() {
+    const tuiPath = (0, path_1.join)(__dirname, 'tui.py');
+    if (!(0, fs_1.existsSync)(tuiPath)) {
+        console.error('Error: tui.py not found at', tuiPath);
+        console.error('Please ensure the Python TUI file exists.');
+        process.exit(1);
+    }
+    const pythonCmd = findPythonCommand();
+    console.log('Starting CozoDB Memory TUI...');
+    console.log('Note: Requires Python 3.7+ and textual package');
+    console.log('Install with: pip install textual\n');
+    const tuiProcess = (0, child_process_1.spawn)(pythonCmd, [tuiPath], {
+        stdio: 'inherit',
+        shell: false
+    });
+    tuiProcess.on('error', (error) => {
+        console.error('Failed to start TUI:', error.message);
+        console.error('\nMake sure Python and textual are installed:');
+        console.error('  pip install textual');
+        process.exit(1);
+    });
+    tuiProcess.on('exit', (code) => {
+        if (code !== 0 && code !== null) {
+            console.error(`\nTUI exited with code ${code}`);
+            console.error('If you see import errors, install textual:');
+            console.error('  pip install textual');
+        }
+        process.exit(code || 0);
+    });
+    // Handle Ctrl+C gracefully
+    process.on('SIGINT', () => {
+        tuiProcess.kill('SIGINT');
+    });
+}
+main();

package/dist/tui.js

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Modern TUI for CozoDB Memory using Ink (React for CLI)
+ * Usage: cozo-memory-tui
+ *
+ * Note: This requires dynamic import due to Ink being ESM-only
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+async function main() {
+    try {
+        // Dynamic import for ESM modules
+        const { render, Box, Text, useInput, useApp } = await import('ink');
+        const React = await import('react');
+        const { CLICommands } = await import('./cli-commands.js');
+        const { useState, useEffect } = React;
+        const cli = new CLICommands();
+        let initialized = false;
+        const App = () => {
+            const { exit } = useApp();
+            const [state, setState] = useState({
+                screen: 'menu',
+                selectedIndex: 0,
+                result: null,
+                loading: false,
+                error: null
+            });
+            useEffect(() => {
+                const initCLI = async () => {
+                    if (!initialized) {
+                        try {
+                            await cli.init();
+                            initialized = true;
+                        }
+                        catch (error) {
+                            setState(prev => ({ ...prev, error: error.message }));
+                        }
+                    }
+                };
+                initCLI();
+                return () => {
+                    if (initialized) {
+                        cli.close();
+                    }
+                };
+            }, []);
+            useInput((input, key) => {
+                if (input === 'q' || (key.ctrl && input === 'c')) {
+                    exit();
+                    return;
+                }
+                if (key.escape) {
+                    setState(prev => ({ ...prev, screen: 'menu', selectedIndex: 0, result: null, error: null }));
+                    return;
+                }
+                if (state.screen === 'menu') {
+                    if (key.upArrow) {
+                        setState(prev => ({
+                            ...prev,
+                            selectedIndex: Math.max(0, prev.selectedIndex - 1)
+                        }));
+                    }
+                    else if (key.downArrow) {
+                        setState(prev => ({
+                            ...prev,
+                            selectedIndex: Math.min(5, prev.selectedIndex + 1)
+                        }));
+                    }
+                    else if (key.return) {
+                        const screens = ['entity', 'search', 'graph', 'system', 'result', 'menu'];
+                        const newScreen = screens[state.selectedIndex];
+                        if (state.selectedIndex === 4) {
+                            setState(prev => ({ ...prev, loading: true }));
+                            cli.health().then(result => {
+                                setState(prev => ({ ...prev, screen: 'result', result, loading: false }));
+                            }).catch(error => {
+                                setState(prev => ({ ...prev, error: error.message, loading: false }));
+                            });
+                        }
+                        else {
+                            setState(prev => ({ ...prev, screen: newScreen }));
+                        }
+                    }
+                }
+            });
+            if (state.loading) {
+                return React.createElement(Box, { flexDirection: 'column', padding: 1 }, React.createElement(Text, { color: 'yellow' }, '⏳ Loading...'));
+            }
+            if (state.error) {
+                return React.createElement(Box, { flexDirection: 'column', padding: 1 }, React.createElement(Text, { color: 'red' }, `❌ Error: ${state.error}`), React.createElement(Text, { dimColor: true }, 'Press ESC to return to menu'));
+            }
+            return React.createElement(Box, { flexDirection: 'column', padding: 1 }, React.createElement(Header), state.screen === 'menu' && React.createElement(MainMenu, { selectedIndex: state.selectedIndex }), state.screen === 'entity' && React.createElement(EntityScreen), state.screen === 'search' && React.createElement(SearchScreen), state.screen === 'graph' && React.createElement(GraphScreen), state.screen === 'system' && React.createElement(SystemScreen), state.screen === 'result' && React.createElement(ResultScreen, { result: state.result }), React.createElement(Footer));
+        };
+        const Header = () => React.createElement(Box, {
+            flexDirection: 'column',
+            marginBottom: 1,
+            borderStyle: 'round',
+            borderColor: 'cyan',
+            padding: 1
+        }, React.createElement(Text, { bold: true, color: 'cyan' }, '🧠 CozoDB Memory - Interactive TUI'), React.createElement(Text, { dimColor: true }, 'Local-first persistent memory for AI agents'));
+        const Footer = () => React.createElement(Box, {
+            marginTop: 1,
+            borderStyle: 'single',
+            borderColor: 'gray',
+            padding: 1
+        }, React.createElement(Text, { dimColor: true }, '↑↓: Navigate | Enter: Select | ESC: Back | Q: Quit'));
+        const MainMenu = ({ selectedIndex }) => {
+            const menuItems = [
+                { icon: '📦', label: 'Entity Operations', desc: 'Create, read, update, delete entities' },
+                { icon: '🔍', label: 'Search & Context', desc: 'Hybrid search, context retrieval' },
+                { icon: '🕸️', label: 'Graph Operations', desc: 'Explore, PageRank, communities' },
+                { icon: '⚙️', label: 'System Management', desc: 'Health, metrics, export/import' },
+                { icon: '💚', label: 'Quick Health Check', desc: 'Run system health check' },
+                { icon: '❌', label: 'Exit', desc: 'Quit application' }
+            ];
+            return React.createElement(Box, { flexDirection: 'column' }, React.createElement(Box, { marginBottom: 1 }, React.createElement(Text, { bold: true, color: 'yellow' }, 'Main Menu')), ...menuItems.map((item, index) => React.createElement(Box, { key: index, marginLeft: 2 }, React.createElement(Text, { color: selectedIndex === index ? 'green' : 'white' }, `${selectedIndex === index ? '▶ ' : '  '}${item.icon} ${item.label}`), selectedIndex === index && React.createElement(Text, { dimColor: true }, ` - ${item.desc}`))));
+        };
+        const EntityScreen = () => React.createElement(Box, { flexDirection: 'column' }, React.createElement(Text, { bold: true, color: 'cyan' }, '📦 Entity Operations'), React.createElement(Box, { marginTop: 1, flexDirection: 'column', marginLeft: 2 }, React.createElement(Text, null, '• Create Entity: ', React.createElement(Text, { dimColor: true }, 'cozo-memory entity create -n "Name" -t "Type"')), React.createElement(Text, null, '• Get Entity: ', React.createElement(Text, { dimColor: true }, 'cozo-memory entity get -i <id>')), React.createElement(Text, null, '• Delete Entity: ', React.createElement(Text, { dimColor: true }, 'cozo-memory entity delete -i <id>')), React.createElement(Text, null, '• Add Observation: ', React.createElement(Text, { dimColor: true }, 'cozo-memory obs add -i <id> -t "Text"'))), React.createElement(Box, { marginTop: 1 }, React.createElement(Text, { color: 'yellow' }, '💡 Use the CLI commands shown above for entity operations')));
+        const SearchScreen = () => React.createElement(Box, { flexDirection: 'column' }, React.createElement(Text, { bold: true, color: 'cyan' }, '🔍 Search & Context'), React.createElement(Box, { marginTop: 1, flexDirection: 'column', marginLeft: 2 }, React.createElement(Text, null, '• Search: ', React.createElement(Text, { dimColor: true }, 'cozo-memory search query -q "your query"')), React.createElement(Text, null, '• Context: ', React.createElement(Text, { dimColor: true }, 'cozo-memory search context -q "query" -w 5')), React.createElement(Text, null, '• Advanced: ', React.createElement(Text, { dimColor: true }, 'With filters, entity types, time ranges'))), React.createElement(Box, { marginTop: 1 }, React.createElement(Text, { color: 'yellow' }, '💡 Hybrid search combines vector, keyword, and graph signals')));
+        const GraphScreen = () => React.createElement(Box, { flexDirection: 'column' }, React.createElement(Text, { bold: true, color: 'cyan' }, '🕸️ Graph Operations'), React.createElement(Box, { marginTop: 1, flexDirection: 'column', marginLeft: 2 }, React.createElement(Text, null, '• Explore: ', React.createElement(Text, { dimColor: true }, 'cozo-memory graph explore -s <id> -h 3')), React.createElement(Text, null, '• PageRank: ', React.createElement(Text, { dimColor: true }, 'cozo-memory graph pagerank')), React.createElement(Text, null, '• Communities: ', React.createElement(Text, { dimColor: true }, 'cozo-memory graph communities')), React.createElement(Text, null, '• Path Finding: ', React.createElement(Text, { dimColor: true }, 'cozo-memory graph explore -s <id1> -e <id2>'))), React.createElement(Box, { marginTop: 1 }, React.createElement(Text, { color: 'yellow' }, '💡 Graph algorithms help discover implicit relationships')));
+        const SystemScreen = () => React.createElement(Box, { flexDirection: 'column' }, React.createElement(Text, { bold: true, color: 'cyan' }, '⚙️ System Management'), React.createElement(Box, { marginTop: 1, flexDirection: 'column', marginLeft: 2 }, React.createElement(Text, null, '• Health: ', React.createElement(Text, { dimColor: true }, 'cozo-memory system health')), React.createElement(Text, null, '• Metrics: ', React.createElement(Text, { dimColor: true }, 'cozo-memory system metrics')), React.createElement(Text, null, '• Export JSON: ', React.createElement(Text, { dimColor: true }, 'cozo-memory export json -o backup.json')), React.createElement(Text, null, '• Export Markdown: ', React.createElement(Text, { dimColor: true }, 'cozo-memory export markdown -o notes.md')), React.createElement(Text, null, '• Export Obsidian: ', React.createElement(Text, { dimColor: true }, 'cozo-memory export obsidian -o vault.zip')), React.createElement(Text, null, '• Import: ', React.createElement(Text, { dimColor: true }, 'cozo-memory import file -i data.json -f cozo'))), React.createElement(Box, { marginTop: 1 }, React.createElement(Text, { color: 'yellow' }, '💡 Regular exports recommended for backup')));
+        const ResultScreen = ({ result }) => React.createElement(Box, { flexDirection: 'column' }, React.createElement(Text, { bold: true, color: 'green' }, '✓ Result'), React.createElement(Box, { marginTop: 1, borderStyle: 'round', borderColor: 'green', padding: 1 }, React.createElement(Text, null, JSON.stringify(result, null, 2))));
+        render(React.createElement(App));
+    }
+    catch (error) {
+        console.error('Failed to start TUI:', error.message);
+        console.error('Make sure all dependencies are installed: npm install');
+        process.exit(1);
+    }
+}
+main();

package/dist/tui.py

@@ -0,0 +1,481 @@
+#!/usr/bin/env python3
+"""
+Modern TUI for CozoDB Memory using Textual
+Features: Mouse support, interactive menus, real-time updates
+"""
+
+from textual.app import App, ComposeResult
+from textual.containers import Container, Horizontal, Vertical, ScrollableContainer
+from textual.widgets import Header, Footer, Button, Static, Input, Tree, Label, DataTable, TabbedContent, TabPane
+from textual.binding import Binding
+from textual import events
+import subprocess
+import json
+import sys
+from pathlib import Path
+
+class CozoMemoryTUI(App):
+    """Textual TUI for CozoDB Memory"""
+    
+    CSS = """
+    Screen {
+        background: $surface;
+    }
+    
+    #sidebar {
+        width: 30;
+        background: $panel;
+        border-right: solid $primary;
+    }
+    
+    #main-content {
+        width: 1fr;
+        padding: 1 2;
+    }
+    
+    Button {
+        width: 100%;
+        margin: 1 0;
+    }
+    
+    .success {
+        color: $success;
+    }
+    
+    .error {
+        color: $error;
+    }
+    
+    .info {
+        color: $accent;
+    }
+    
+    #result-container {
+        height: 1fr;
+        border: solid $primary;
+        padding: 1;
+        margin-top: 1;
+    }
+    
+    Input {
+        margin: 1 0;
+    }
+    
+    Label {
+        margin: 1 0;
+    }
+    
+    DataTable {
+        height: 1fr;
+    }
+    """
+    
+    BINDINGS = [
+        Binding("q", "quit", "Quit"),
+        Binding("h", "show_help", "Help"),
+        Binding("r", "refresh", "Refresh"),
+    ]
+    
+    def __init__(self):
+        super().__init__()
+        self.cli_path = self._find_cli_path()
+        
+    def _find_cli_path(self) -> str:
+        """Find the cozo-memory CLI executable"""
+        # Try different locations
+        possible_paths = [
+            Path(__file__).parent.parent / "dist" / "cli.js",
+            Path.cwd() / "dist" / "cli.js",
+        ]
+        
+        for path in possible_paths:
+            if path.exists():
+                return str(path)
+        
+        # Fallback to global installation
+        return "cozo-memory"
+    
+    def compose(self) -> ComposeResult:
+        """Create child widgets"""
+        yield Header(show_clock=True)
+        
+        with Horizontal():
+            # Sidebar with navigation
+            with Vertical(id="sidebar"):
+                yield Static("🧠 CozoDB Memory", classes="info")
+                yield Button("📊 System Health", id="btn-health", variant="primary")
+                yield Button("➕ Create Entity", id="btn-create-entity")
+                yield Button("🔍 Search", id="btn-search")
+                yield Button("🕸️ Graph Operations", id="btn-graph")
+                yield Button("📤 Export", id="btn-export")
+                yield Button("📥 Import", id="btn-import")
+                yield Button("📋 List Entities", id="btn-list")
+            
+            # Main content area
+            with ScrollableContainer(id="main-content"):
+                yield Static("Welcome to CozoDB Memory TUI", id="welcome-text", classes="info")
+                yield Static("Click a button or use keyboard shortcuts", id="help-text")
+                
+                # Dynamic content container
+                with Container(id="result-container"):
+                    yield Static("Results will appear here...", id="result-text")
+        
+        yield Footer()
+    
+    def _run_cli_command(self, *args, use_json_format: bool = True) -> dict:
+        """Execute CLI command and return JSON result"""
+        try:
+            cmd = ["node", self.cli_path] + list(args)
+            # Only add -f json for commands that support it
+            if use_json_format:
+                cmd.extend(["-f", "json"])
+            
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=30
+            )
+            
+            if result.returncode != 0:
+                return {"error": result.stderr or "Command failed"}
+            
+            # Parse JSON output - stdout should be pure JSON
+            if use_json_format:
+                try:
+                    # Parse the JSON directly from stdout
+                    parsed = json.loads(result.stdout)
+                    return {"success": True, "data": parsed}
+                except json.JSONDecodeError as e:
+                    # If JSON parsing fails, return error with details
+                    return {"error": f"Failed to parse JSON: {str(e)}\nOutput: {result.stdout[:200]}"}
+            else:
+                # For non-JSON commands, return raw output
+                return {"success": True, "data": {"output": result.stdout}}
+                
+        except subprocess.TimeoutExpired:
+            return {"error": "Command timed out"}
+        except Exception as e:
+            return {"error": str(e)}
+    
+    def _update_result(self, data: dict):
+        """Update the result container with new data"""
+        # Always recreate the Static widget to avoid markup issues
+        container = self.query_one("#result-container", Container)
+        container.remove_children()
+        
+        if "error" in data:
+            # Show error without markup
+            content = f"ERROR:\n{data['error']}"
+        elif "success" in data and data["success"]:
+            # Format the data nicely
+            formatted = json.dumps(data["data"], indent=2)
+            # Truncate if too long
+            if len(formatted) > 5000:
+                formatted = formatted[:5000] + "\n... (truncated)"
+            content = f"SUCCESS:\n{formatted}"
+        else:
+            # Fallback
+            formatted = json.dumps(data, indent=2)
+            content = formatted
+        
+        # Create new Static widget with markup disabled
+        result_text = Static(content, id="result-text", markup=False)
+        container.mount(result_text)
+    
+
+    
+    async def action_show_health(self) -> None:
+        """Show system health"""
+        self.query_one("#welcome-text", Static).update("📊 System Health")
+        result = self._run_cli_command("system", "health")
+        self._update_result(result)
+    
+    async def action_create_entity(self) -> None:
+        """Show create entity form"""
+        self.query_one("#welcome-text", Static).update("➕ Create Entity")
+        
+        # Replace result container with form
+        container = self.query_one("#result-container", Container)
+        await container.remove_children()
+        
+        await container.mount(
+            Label("Entity Name:"),
+            Input(placeholder="Enter entity name", id="input-name"),
+            Label("Entity Type:"),
+            Input(placeholder="Enter entity type", id="input-type"),
+            Label("Metadata (JSON, optional):"),
+            Input(placeholder='{"key": "value"}', id="input-metadata"),
+            Button("Create", id="btn-submit-entity", variant="success")
+        )
+    
+    async def action_search(self) -> None:
+        """Show search form"""
+        self.query_one("#welcome-text", Static).update("🔍 Search Memory")
+        
+        container = self.query_one("#result-container", Container)
+        await container.remove_children()
+        
+        await container.mount(
+            Label("Search Query:"),
+            Input(placeholder="Enter search query", id="input-search-query"),
+            Label("Limit (optional):"),
+            Input(placeholder="10", id="input-search-limit"),
+            Button("Search", id="btn-submit-search", variant="primary")
+        )
+    
+    async def action_graph_menu(self) -> None:
+        """Show graph operations menu"""
+        self.query_one("#welcome-text", Static).update("🕸️ Graph Operations")
+        
+        container = self.query_one("#result-container", Container)
+        await container.remove_children()
+        
+        await container.mount(
+            Static("Select a graph operation:", classes="info"),
+            Button("📊 PageRank", id="btn-graph-pagerank"),
+            Button("🏘️ Communities", id="btn-graph-communities"),
+            Button("🔍 Explore from Entity", id="btn-graph-explore")
+        )
+    
+    async def action_export_menu(self) -> None:
+        """Show export menu"""
+        self.query_one("#welcome-text", Static).update("📤 Export Memory")
+        
+        container = self.query_one("#result-container", Container)
+        await container.remove_children()
+        
+        await container.mount(
+            Static("Select export format:", classes="info"),
+            Label("Output File:"),
+            Input(placeholder="export.json", id="input-export-file"),
+            Button("Export as JSON", id="btn-export-json"),
+            Button("Export as Markdown", id="btn-export-md"),
+            Button("Export as Obsidian ZIP", id="btn-export-obsidian")
+        )
+    
+    async def action_import_menu(self) -> None:
+        """Show import menu"""
+        self.query_one("#welcome-text", Static).update("📥 Import Memory")
+        
+        container = self.query_one("#result-container", Container)
+        await container.remove_children()
+        
+        await container.mount(
+            Static("Import data from file:", classes="info"),
+            Label("Input File:"),
+            Input(placeholder="import.json", id="input-import-file"),
+            Label("Format:"),
+            Input(placeholder="cozo", id="input-import-format"),
+            Button("Import", id="btn-submit-import", variant="warning")
+        )
+    
+    async def action_list_entities(self) -> None:
+        """List all entities"""
+        self.query_one("#welcome-text", Static).update("📋 Entity List")
+        
+        # Get health to show entity count
+        result = self._run_cli_command("system", "health")
+        
+        container = self.query_one("#result-container", Container)
+        await container.remove_children()
+        
+        if "success" in result and result["success"]:
+            health_data = result["data"]
+            await container.mount(
+                Static(f"Total Entities: {health_data.get('entities', 0)}"),
+                Static(f"Total Observations: {health_data.get('observations', 0)}"),
+                Static(f"Total Relationships: {health_data.get('relationships', 0)}"),
+                Static("\nUse CLI to get detailed entity list:\ncozo-memory entity get -i <entity-id>")
+            )
+        else:
+            await container.mount(Static(f"Error: {result.get('error', 'Unknown error')}"))
+    
+    async def on_button_pressed(self, event: Button.Pressed) -> None:
+        """Handle all button presses"""
+        button_id = event.button.id
+        
+        # Main menu buttons
+        if button_id == "btn-health":
+            await self.action_show_health()
+        elif button_id == "btn-create-entity":
+            await self.action_create_entity()
+        elif button_id == "btn-search":
+            await self.action_search()
+        elif button_id == "btn-graph":
+            await self.action_graph_menu()
+        elif button_id == "btn-export":
+            await self.action_export_menu()
+        elif button_id == "btn-import":
+            await self.action_import_menu()
+        elif button_id == "btn-list":
+            await self.action_list_entities()
+        
+        # Form submission buttons
+        elif button_id == "btn-submit-entity":
+            await self.handle_create_entity()
+        elif button_id == "btn-submit-search":
+            await self.handle_search()
+        elif button_id == "btn-submit-import":
+            await self.handle_import()
+        
+        # Graph operation buttons
+        elif button_id == "btn-graph-pagerank":
+            await self.handle_graph_pagerank()
+        elif button_id == "btn-graph-communities":
+            await self.handle_graph_communities()
+        elif button_id == "btn-graph-explore":
+            await self.handle_graph_explore_form()
+        
+        # Export buttons
+        elif button_id == "btn-export-json":
+            await self.handle_export("json")
+        elif button_id == "btn-export-md":
+            await self.handle_export("markdown")
+        elif button_id == "btn-export-obsidian":
+            await self.handle_export("obsidian")
+        
+        # Graph explore submit
+        elif button_id == "btn-submit-explore":
+            await self.handle_graph_explore()
+    
+    async def handle_create_entity(self) -> None:
+        """Handle entity creation form submission"""
+        name = self.query_one("#input-name", Input).value
+        entity_type = self.query_one("#input-type", Input).value
+        metadata = self.query_one("#input-metadata", Input).value
+        
+        if not name or not entity_type:
+            self._update_result({"error": "Name and type are required"})
+            return
+        
+        args = ["entity", "create", "-n", name, "-t", entity_type]
+        if metadata:
+            args.extend(["-m", metadata])
+        
+        result = self._run_cli_command(*args)
+        self._update_result(result)
+    
+    async def handle_search(self) -> None:
+        """Handle search form submission"""
+        query = self.query_one("#input-search-query", Input).value
+        limit = self.query_one("#input-search-limit", Input).value
+        
+        if not query:
+            self._update_result({"error": "Search query is required"})
+            return
+        
+        args = ["search", "query", "-q", query]
+        if limit:
+            args.extend(["-l", limit])
+        
+        result = self._run_cli_command(*args)
+        self._update_result(result)
+    
+    async def handle_import(self) -> None:
+        """Handle import form submission"""
+        file_path = self.query_one("#input-import-file", Input).value
+        format_type = self.query_one("#input-import-format", Input).value
+        
+        if not file_path:
+            self._update_result({"error": "File path is required"})
+            return
+        
+        args = ["import", "file", "-i", file_path, "-f", format_type or "cozo"]
+        # Import commands don't use -f json format
+        result = self._run_cli_command(*args, use_json_format=False)
+        self._update_result(result)
+    
+    async def handle_graph_pagerank(self) -> None:
+        """Execute PageRank"""
+        self.query_one("#welcome-text", Static).update("📊 Computing PageRank...")
+        result = self._run_cli_command("graph", "pagerank")
+        self._update_result(result)
+    
+    async def handle_graph_communities(self) -> None:
+        """Execute community detection"""
+        self.query_one("#welcome-text", Static).update("🏘️ Detecting Communities...")
+        result = self._run_cli_command("graph", "communities")
+        self._update_result(result)
+    
+    async def handle_graph_explore_form(self) -> None:
+        """Show graph explore form"""
+        container = self.query_one("#result-container", Container)
+        await container.remove_children()
+        
+        await container.mount(
+            Label("Start Entity ID:"),
+            Input(placeholder="Enter entity ID", id="input-explore-start"),
+            Label("Max Hops:"),
+            Input(placeholder="3", id="input-explore-hops"),
+            Button("Explore", id="btn-submit-explore", variant="primary")
+        )
+    
+    async def handle_graph_explore(self) -> None:
+        """Execute graph exploration"""
+        start_id = self.query_one("#input-explore-start", Input).value
+        hops = self.query_one("#input-explore-hops", Input).value
+        
+        if not start_id:
+            self._update_result({"error": "Start entity ID is required"})
+            return
+        
+        args = ["graph", "explore", "-s", start_id]
+        if hops:
+            args.extend(["-h", hops])
+        
+        result = self._run_cli_command(*args)
+        self._update_result(result)
+    
+    async def handle_export(self, format_type: str) -> None:
+        """Handle export"""
+        file_input = self.query_one("#input-export-file", Input)
+        file_path = file_input.value or f"export.{format_type}"
+        
+        if format_type == "json":
+            args = ["export", "json", "-o", file_path, "--include-metadata", "--include-relationships", "--include-observations"]
+        elif format_type == "markdown":
+            args = ["export", "markdown", "-o", file_path]
+        else:  # obsidian
+            args = ["export", "obsidian", "-o", file_path]
+        
+        # Export commands don't use -f json format
+        result = self._run_cli_command(*args, use_json_format=False)
+        if "success" in result and result["success"]:
+            result = {"success": True, "data": {"message": f"Exported to {file_path}"}}
+        self._update_result(result)
+    
+    def action_show_help(self) -> None:
+        """Show help information"""
+        self.query_one("#welcome-text", Static).update("❓ Help")
+        help_text = """
+[bold cyan]Keyboard Shortcuts:[/bold cyan]
+• q - Quit application
+• h - Show this help
+• r - Refresh current view
+
+[bold cyan]Mouse Support:[/bold cyan]
+• Click buttons to navigate
+• Scroll with mouse wheel
+• Click input fields to type
+
+[bold cyan]CLI Commands:[/bold cyan]
+All operations can also be done via CLI:
+• cozo-memory entity create -n "Name" -t "type"
+• cozo-memory search query -q "search term"
+• cozo-memory graph pagerank
+• cozo-memory export json -o backup.json
+        """
+        container = self.query_one("#result-container", Container)
+        container.remove_children()
+        container.mount(Static(help_text))
+    
+    def action_refresh(self) -> None:
+        """Refresh current view"""
+        self.query_one("#welcome-text", Static).update("🔄 Refreshed")
+        self.action_show_health()
+
+
+if __name__ == "__main__":
+    app = CozoMemoryTUI()
+    app.run()