navada-edge-cli 1.1.0 → 2.1.0

package/Dockerfile

@@ -0,0 +1,3 @@
+FROM node:22-slim
+RUN npm install -g navada-edge-cli@2.0.0
+ENTRYPOINT ["navada"]

package/docker-compose.yml

@@ -0,0 +1,10 @@
+services:
+  cli:
+    build: .
+    image: navada-edge-cli:2.0.0
+    container_name: navada-edge-cli
+    env_file: .env
+    stdin_open: true
+    tty: true
+    ports:
+      - "${SERVE_PORT:-7800}:7800"

package/lib/agent.js

@@ -0,0 +1,306 @@
+'use strict';
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const navada = require('navada-edge-sdk');
+const ui = require('./ui');
+const config = require('./config');
+
+// ---------------------------------------------------------------------------
+// NAVADA Edge Agent — personality + tools + routing
+// ---------------------------------------------------------------------------
+
+const IDENTITY = {
+  name: 'NAVADA Edge',
+  role: 'AI Infrastructure Agent',
+  personality: `You are NAVADA Edge — an AI agent that operates inside the user's terminal.
+You are professional, technical, concise, and helpful. You speak with authority about distributed systems, Docker, AI, and cloud infrastructure.
+You have full access to the user's computer: you can read/write files, run shell commands, manage processes, and connect to the NAVADA Edge Network.
+You can invoke two sub-agents:
+  - Lucas CTO: runs bash, SSH, Docker commands on remote NAVADA Edge nodes
+  - Claude CoS: sends emails, generates images, manages the network
+When users ask you to do something, DO it — don't just describe how. Use your tools.
+When you don't have a tool for something, say so clearly and suggest an alternative.
+Keep responses short. Code blocks when needed. No fluff.`,
+};
+
+// ---------------------------------------------------------------------------
+// Local tools — run on the USER's machine
+// ---------------------------------------------------------------------------
+const localTools = {
+  shell: {
+    description: 'Execute a shell command on this machine',
+    execute: (cmd) => {
+      try {
+        const output = execSync(cmd, { timeout: 30000, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+        return output.trim();
+      } catch (e) {
+        return `Error: ${e.stderr?.trim() || e.message}`;
+      }
+    },
+  },
+
+  readFile: {
+    description: 'Read a file from this machine',
+    execute: (filePath) => {
+      try {
+        return fs.readFileSync(path.resolve(filePath), 'utf-8');
+      } catch (e) { return `Error: ${e.message}`; }
+    },
+  },
+
+  writeFile: {
+    description: 'Write content to a file on this machine',
+    execute: (filePath, content) => {
+      try {
+        const resolved = path.resolve(filePath);
+        const dir = path.dirname(resolved);
+        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(resolved, content);
+        return `Written: ${resolved}`;
+      } catch (e) { return `Error: ${e.message}`; }
+    },
+  },
+
+  listFiles: {
+    description: 'List files in a directory on this machine',
+    execute: (dir) => {
+      try {
+        const items = fs.readdirSync(path.resolve(dir || '.'), { withFileTypes: true });
+        return items.map(i => `${i.isDirectory() ? 'd' : 'f'} ${i.name}`).join('\n');
+      } catch (e) { return `Error: ${e.message}`; }
+    },
+  },
+
+  systemInfo: {
+    description: 'Get system information',
+    execute: () => {
+      return JSON.stringify({
+        hostname: os.hostname(),
+        platform: os.platform(),
+        arch: os.arch(),
+        cpus: os.cpus().length,
+        totalMem: `${(os.totalmem() / 1024 / 1024 / 1024).toFixed(1)} GB`,
+        freeMem: `${(os.freemem() / 1024 / 1024 / 1024).toFixed(1)} GB`,
+        uptime: `${(os.uptime() / 3600).toFixed(1)} hours`,
+        user: os.userInfo().username,
+        home: os.homedir(),
+        cwd: process.cwd(),
+        nodeVersion: process.version,
+      }, null, 2);
+    },
+  },
+};
+
+// ---------------------------------------------------------------------------
+// Anthropic Claude API — conversational agent
+// ---------------------------------------------------------------------------
+async function chat(userMessage, conversationHistory = []) {
+  const anthropicKey = config.get('anthropicKey') || process.env.ANTHROPIC_API_KEY || '';
+
+  if (!anthropicKey) {
+    // Fall back to other providers
+    return fallbackChat(userMessage);
+  }
+
+  const tools = [
+    {
+      name: 'shell',
+      description: 'Execute a shell command on the user\'s local machine. Use for: file operations, git, npm, docker, system commands.',
+      input_schema: { type: 'object', properties: { command: { type: 'string', description: 'The shell command to run' } }, required: ['command'] },
+    },
+    {
+      name: 'read_file',
+      description: 'Read the contents of a file on the user\'s local machine.',
+      input_schema: { type: 'object', properties: { path: { type: 'string', description: 'File path to read' } }, required: ['path'] },
+    },
+    {
+      name: 'write_file',
+      description: 'Write content to a file on the user\'s local machine.',
+      input_schema: { type: 'object', properties: { path: { type: 'string', description: 'File path' }, content: { type: 'string', description: 'Content to write' } }, required: ['path', 'content'] },
+    },
+    {
+      name: 'list_files',
+      description: 'List files and directories.',
+      input_schema: { type: 'object', properties: { path: { type: 'string', description: 'Directory path (default: current dir)' } } },
+    },
+    {
+      name: 'system_info',
+      description: 'Get local system information (CPU, RAM, disk, OS, hostname).',
+      input_schema: { type: 'object', properties: {} },
+    },
+    {
+      name: 'network_status',
+      description: 'Ping all NAVADA Edge Network nodes and cloud services.',
+      input_schema: { type: 'object', properties: {} },
+    },
+    {
+      name: 'lucas_exec',
+      description: 'Run a bash command on EC2 via Lucas CTO agent.',
+      input_schema: { type: 'object', properties: { command: { type: 'string' } }, required: ['command'] },
+    },
+    {
+      name: 'lucas_ssh',
+      description: 'SSH to a NAVADA Edge node (hp, ec2, oracle) and run a command via Lucas CTO.',
+      input_schema: { type: 'object', properties: { node: { type: 'string' }, command: { type: 'string' } }, required: ['node', 'command'] },
+    },
+    {
+      name: 'lucas_docker',
+      description: 'Run a command inside a Docker container on EC2 via Lucas CTO.',
+      input_schema: { type: 'object', properties: { container: { type: 'string' }, command: { type: 'string' } }, required: ['container', 'command'] },
+    },
+    {
+      name: 'mcp_call',
+      description: 'Call a tool on the NAVADA Edge MCP server (18 tools: docker, ssh, files, database, monitoring).',
+      input_schema: { type: 'object', properties: { tool: { type: 'string' }, args: { type: 'object' } }, required: ['tool'] },
+    },
+    {
+      name: 'docker_registry',
+      description: 'List images or tags in the NAVADA private Docker registry.',
+      input_schema: { type: 'object', properties: { image: { type: 'string', description: 'Image name for tags (optional — omit to list all)' } } },
+    },
+    {
+      name: 'send_email',
+      description: 'Send an email via the NAVADA Edge MCP email tool.',
+      input_schema: { type: 'object', properties: { to: { type: 'string' }, subject: { type: 'string' }, body: { type: 'string' } }, required: ['to', 'subject', 'body'] },
+    },
+    {
+      name: 'generate_image',
+      description: 'Generate an image using Cloudflare Flux (FREE) or DALL-E.',
+      input_schema: { type: 'object', properties: { prompt: { type: 'string' }, provider: { type: 'string', description: 'flux (default, free) or dalle' } }, required: ['prompt'] },
+    },
+  ];
+
+  const messages = [
+    ...conversationHistory,
+    { role: 'user', content: userMessage },
+  ];
+
+  // Call Anthropic API
+  let response = await callAnthropic(anthropicKey, messages, tools);
+
+  // Handle tool use loop
+  let iterations = 0;
+  while (response.stop_reason === 'tool_use' && iterations < 10) {
+    iterations++;
+    const toolBlocks = response.content.filter(b => b.type === 'tool_use');
+    const results = [];
+
+    for (const block of toolBlocks) {
+      // Print what the agent is doing
+      console.log(ui.dim(`  [${block.name}] ${JSON.stringify(block.input).slice(0, 80)}`));
+      const result = await executeTool(block.name, block.input);
+      results.push({ type: 'tool_result', tool_use_id: block.id, content: typeof result === 'string' ? result : JSON.stringify(result) });
+    }
+
+    // Print any text blocks
+    for (const block of response.content) {
+      if (block.type === 'text' && block.text) console.log(`  ${block.text}`);
+    }
+
+    // Continue conversation with tool results
+    messages.push({ role: 'assistant', content: response.content });
+    messages.push({ role: 'user', content: results });
+    response = await callAnthropic(anthropicKey, messages, tools);
+  }
+
+  // Extract final text
+  const textBlocks = response.content?.filter(b => b.type === 'text') || [];
+  return textBlocks.map(b => b.text).join('\n');
+}
+
+async function callAnthropic(key, messages, tools) {
+  const r = await navada.request('https://api.anthropic.com/v1/messages', {
+    method: 'POST',
+    body: {
+      model: 'claude-sonnet-4-20250514',
+      max_tokens: 4096,
+      system: IDENTITY.personality,
+      messages,
+      tools,
+    },
+    headers: {
+      'x-api-key': key,
+      'anthropic-version': '2023-06-01',
+      'Content-Type': 'application/json',
+    },
+    timeout: 60000,
+  });
+
+  if (r.status !== 200) {
+    throw new Error(`Anthropic API error ${r.status}: ${JSON.stringify(r.data).slice(0, 200)}`);
+  }
+
+  return r.data;
+}
+
+async function executeTool(name, input) {
+  try {
+    switch (name) {
+      case 'shell': return localTools.shell.execute(input.command);
+      case 'read_file': return localTools.readFile.execute(input.path);
+      case 'write_file': return localTools.writeFile.execute(input.path, input.content);
+      case 'list_files': return localTools.listFiles.execute(input.path);
+      case 'system_info': return localTools.systemInfo.execute();
+      case 'network_status': return JSON.stringify(await navada.network.ping());
+      case 'lucas_exec': return JSON.stringify(await navada.lucas.exec(input.command));
+      case 'lucas_ssh': return JSON.stringify(await navada.lucas.ssh(input.node, input.command));
+      case 'lucas_docker': return JSON.stringify(await navada.lucas.docker(input.container, input.command));
+      case 'mcp_call': return JSON.stringify(await navada.mcp.call(input.tool, input.args || {}));
+      case 'docker_registry':
+        if (input.image) return JSON.stringify(await navada.registry.tags(input.image));
+        return JSON.stringify(await navada.registry.catalog());
+      case 'send_email': return JSON.stringify(await navada.mcp.call('send-email', input));
+      case 'generate_image':
+        if (input.provider === 'dalle') return JSON.stringify(await navada.ai.openai.image(input.prompt));
+        const { size } = await navada.cloudflare.flux.generate(input.prompt, { savePath: `navada-${Date.now()}.png` });
+        return `Image generated: ${size} bytes`;
+      default: return `Unknown tool: ${name}`;
+    }
+  } catch (e) {
+    return `Tool error: ${e.message}`;
+  }
+}
+
+async function fallbackChat(msg) {
+  // Try MCP → Qwen → OpenAI → error
+  if (navada.config.mcp) {
+    try { return JSON.stringify(await navada.mcp.call('chat', { message: msg })); } catch {}
+  }
+  if (navada.config.hfToken) {
+    try { return await navada.ai.huggingface.qwen(msg); } catch {}
+  }
+  if (navada.config.openaiKey) {
+    try { return await navada.ai.openai.chat(msg); } catch {}
+  }
+  return 'No AI provider configured. Run /setup or set ANTHROPIC_API_KEY.';
+}
+
+// ---------------------------------------------------------------------------
+// Telemetry — track installs + usage
+// ---------------------------------------------------------------------------
+async function reportTelemetry(event, data = {}) {
+  if (!navada.config.dashboard) return;
+  try {
+    await navada.request(navada.config.dashboard + '/api/agent-heartbeat', {
+      method: 'POST',
+      body: {
+        agent: 'navada-edge-cli',
+        event,
+        version: require('../package.json').version,
+        hostname: os.hostname(),
+        platform: os.platform(),
+        arch: os.arch(),
+        nodeVersion: process.version,
+        apiKey: config.getApiKey()?.slice(0, 8) || 'none',
+        ts: new Date().toISOString(),
+        ...data,
+      },
+      timeout: 5000,
+    });
+  } catch {}
+}
+
+module.exports = { IDENTITY, chat, localTools, reportTelemetry, fallbackChat };

package/lib/cli.js

@@ -3,41 +3,56 @@
 const readline = require('readline');
 const navada = require('navada-edge-sdk');
 const ui = require('./ui');
-const auth = require('./auth');
-const { execute, commands } = require('./commands');
+const config = require('./config');
+const history = require('./history');
+const { completer } = require('./completer');
+const { execute, getCompletions } = require('./registry');
+const { loadAll } = require('./commands/index');
+const { reportTelemetry } = require('./agent');
 
 function applyConfig() {
-  const config = auth.getConfig();
+  const cfg = config.getAll();
   const overrides = {};
-  if (config.apiKey) { overrides.mcpApiKey = config.apiKey; overrides.dashboardApiKey = config.apiKey; }
-  if (config.asus) overrides.asus = config.asus;
-  if (config.hp) overrides.hp = config.hp;
-  if (config.ec2) overrides.ec2 = config.ec2;
-  if (config.oracle) overrides.oracle = config.oracle;
-  if (config.mcp) overrides.mcp = config.mcp;
-  if (config.dashboard) overrides.dashboard = config.dashboard;
-  if (config.registry) overrides.registry = config.registry;
-  if (config.lucas) overrides.lucas = config.lucas;
+  const map = {
+    apiKey: ['mcpApiKey', 'dashboardApiKey'],
+    asus: ['asus'], hp: ['hp'], ec2: ['ec2'], oracle: ['oracle'],
+    mcp: ['mcp'], dashboard: ['dashboard'], registry: ['registry'],
+    lucas: ['lucas'], portainer: ['portainer'],
+    cfAccountId: ['cfAccountId'], cfApiToken: ['cfApiToken'],
+    cfR2Bucket: ['cfR2Bucket'], cfDomain: ['cfDomain'],
+    cfZoneId: ['cfZoneId'], cfStreamSubdomain: ['cfStreamSubdomain'],
+    azureN8nUrl: ['azureN8nUrl'], azureN8nRg: ['azureN8nRg'], azureN8nApp: ['azureN8nApp'],
+    yoloUrl: ['yoloUrl'], hfToken: ['hfToken'], openaiKey: ['openaiKey'],
+    pgHost: ['pgHost'], pgPort: ['pgPort'], pgDb: ['pgDb'], pgUser: ['pgUser'], pgPass: ['pgPass'],
+    opencodePassword: ['opencodePassword'],
+  };
+
+  for (const [cfgKey, sdkKeys] of Object.entries(map)) {
+    if (cfg[cfgKey]) {
+      for (const sk of sdkKeys) overrides[sk] = cfg[cfgKey];
+    }
+  }
+
   if (Object.keys(overrides).length > 0) navada.init(overrides);
 }
 
 function showWelcome() {
   console.clear();
-  console.log(ui.LOGO);
+  console.log(ui.banner());
   console.log(ui.dim('Type /help for commands. Tab to autocomplete. Ctrl+C to exit.'));
   console.log('');
 }
 
 function startRepl() {
+  const historyItems = history.load();
+
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
     prompt: ui.prompt(),
-    completer: (line) => {
-      const cmds = Object.keys(commands).map(c => '/' + c);
-      const hits = cmds.filter(c => c.startsWith(line));
-      return [hits.length ? hits : cmds, line];
-    },
+    completer,
+    history: historyItems,
+    historySize: 1000,
   });
 
   rl.prompt();
@@ -45,6 +60,7 @@ function startRepl() {
   rl.on('line', async (line) => {
     const input = line.trim();
     if (input) {
+      history.append(input);
       await execute(input);
     }
     console.log('');
@@ -58,14 +74,26 @@ function startRepl() {
 }
 
 async function runDirect(args) {
-  const input = args.join(' ');
-  await execute(input);
+  await execute(args.join(' '));
 }
 
-function run(argv) {
+async function run(argv) {
+  // Load all command modules
+  loadAll();
+
+  // Apply saved config
   applyConfig();
 
   if (argv.length === 0) {
+    // Check first run
+    if (config.isFirstRun()) {
+      reportTelemetry('install');
+      const { runSetup } = require('./commands/setup');
+      await runSetup();
+      return;
+    }
+    // Report session start
+    reportTelemetry('session_start');
     // Interactive mode
     showWelcome();
     startRepl();
@@ -73,24 +101,34 @@ function run(argv) {
     const pkg = require('../package.json');
     console.log(`navada-edge-cli v${pkg.version}`);
   } else if (argv[0] === '--help' || argv[0] === '-h') {
-    console.log(ui.LOGO);
+    console.log(ui.banner());
     console.log('  Usage:');
-    console.log('    navada                     Interactive mode');
+    console.log('    navada                     Interactive mode (first run triggers setup)');
+    console.log('    navada setup               Run onboarding wizard');
     console.log('    navada status              Ping all nodes');
+    console.log('    navada doctor              Test all connections');
     console.log('    navada mcp tools           List MCP tools');
     console.log('    navada registry            List Docker images');
-    console.log('    navada chat "question"     Chat with GPT-4o');
+    console.log('    navada agents              Show Lucas + Claude status');
+    console.log('    navada chat "question"     Chat with AI');
     console.log('    navada login <key>         Set API key');
+    console.log('    navada theme crow          Switch theme');
     console.log('    navada --version           Show version');
     console.log('');
     console.log('  Run `navada` with no args for interactive mode.');
     console.log('');
+  } else if (argv[0] === '--serve') {
+    const serve = require('./serve');
+    const port = parseInt(argv[1]) || config.getServePort();
+    serve.start(port);
   } else {
     // Direct command mode
-    runDirect(argv).then(() => process.exit(0)).catch(e => {
+    try {
+      await runDirect(argv);
+    } catch (e) {
       console.log(ui.error(e.message));
       process.exit(1);
-    });
+    }
   }
 }
 

package/lib/commands/agents.js

@@ -0,0 +1,70 @@
+'use strict';
+
+const navada = require('navada-edge-sdk');
+const ui = require('../ui');
+
+module.exports = function(reg) {
+
+  reg('agents', 'Show NAVADA Edge agents status', async () => {
+    console.log(ui.header('NAVADA EDGE AGENTS'));
+
+    // Lucas CTO
+    if (navada.config.lucas) {
+      try {
+        const r = await navada.request(navada.config.lucas + '/health', { timeout: 5000 });
+        console.log(ui.online('Lucas CTO', r.status < 500, `MCP ${navada.config.lucas}`));
+      } catch {
+        console.log(ui.online('Lucas CTO', false, 'unreachable'));
+      }
+    } else {
+      console.log(ui.online('Lucas CTO', false, 'not configured'));
+    }
+    console.log(ui.dim('  Tools: bash, ssh, docker_exec, deploy, read_file, write_file, list_files, network_status'));
+
+    console.log('');
+
+    // Claude CoS
+    if (navada.config.dashboard) {
+      try {
+        const r = await navada.request(navada.config.dashboard + '/api/agent-heartbeat', { timeout: 5000 });
+        console.log(ui.online('Claude CoS', r.status < 500, `Dashboard ${navada.config.dashboard}`));
+      } catch {
+        console.log(ui.online('Claude CoS', false, 'unreachable'));
+      }
+    } else {
+      console.log(ui.online('Claude CoS', false, 'not configured'));
+    }
+    console.log(ui.dim('  Controls: Telegram, email, SMS, image gen, R2, cost tracking'));
+
+    console.log('');
+    // MCP Server
+    if (navada.config.mcp) {
+      try {
+        const r = await navada.request(navada.config.mcp + '/health', { timeout: 5000 });
+        console.log(ui.online('MCP Server', r.status < 500, `${navada.config.mcp}`));
+        if (r.data?.version) console.log(ui.dim(`  Version: ${r.data.version}`));
+      } catch {
+        console.log(ui.online('MCP Server', false, 'unreachable'));
+      }
+    } else {
+      console.log(ui.online('MCP Server', false, 'not configured'));
+    }
+  }, { category: 'AGENTS' });
+
+  reg('claude', 'Send message to Claude CoS', async (args) => {
+    const msg = args.join(' ');
+    if (!msg) { console.log(ui.dim('Usage: /claude Check HP disk space')); return; }
+    const ora = require('ora');
+    const spinner = ora({ text: '  Asking Claude...', color: 'white' }).start();
+    try {
+      // Try via MCP first
+      const result = await navada.mcp.call('chat', { message: msg, agent: 'claude' });
+      spinner.stop();
+      console.log(ui.header('CLAUDE'));
+      console.log(typeof result === 'object' ? ui.jsonColorize(result) : `  ${result}`);
+    } catch {
+      spinner.stop();
+      console.log(ui.warn('Claude agent not available via MCP. Try /lucas exec for direct commands.'));
+    }
+  }, { category: 'AGENTS' });
+};

package/lib/commands/ai.js

@@ -0,0 +1,126 @@
+'use strict';
+
+const navada = require('navada-edge-sdk');
+const ui = require('../ui');
+const config = require('../config');
+const { chat: agentChat, reportTelemetry } = require('../agent');
+
+module.exports = function(reg) {
+
+  // Conversation history for multi-turn
+  const conversationHistory = [];
+
+  reg('chat', 'Chat with NAVADA Edge AI agent', async (args) => {
+    const msg = args.join(' ');
+    if (!msg) { console.log(ui.dim('Just type naturally — no /command needed.')); return; }
+    const ora = require('ora');
+    const spinner = ora({ text: '  NAVADA thinking...', color: 'white' }).start();
+
+    try {
+      const response = await agentChat(msg, conversationHistory);
+      spinner.stop();
+
+      // Update conversation history
+      conversationHistory.push({ role: 'user', content: msg });
+      conversationHistory.push({ role: 'assistant', content: response });
+
+      // Keep history manageable (last 20 turns)
+      while (conversationHistory.length > 40) conversationHistory.splice(0, 2);
+
+      console.log(ui.header('NAVADA'));
+      console.log(`  ${response}`);
+
+      // Track usage
+      reportTelemetry('chat', { messageLength: msg.length });
+    } catch (e) {
+      spinner.stop();
+      console.log(ui.error(e.message));
+      console.log(ui.dim('Check: /config to see which providers are set, or /setup to configure.'));
+    }
+  }, { category: 'AI', aliases: ['ask'] });
+
+  reg('qwen', 'Qwen Coder 32B (FREE via HuggingFace)', async (args) => {
+    const prompt = args.join(' ');
+    if (!prompt) { console.log(ui.dim('Usage: /qwen Write a function to validate UK postcodes')); return; }
+    const ora = require('ora');
+    const spinner = ora({ text: '  Qwen thinking...', color: 'white' }).start();
+    const result = await navada.ai.huggingface.qwen(prompt);
+    spinner.stop();
+    console.log(ui.header('QWEN CODER'));
+    console.log(`  ${typeof result === 'object' ? ui.jsonColorize(result) : result}`);
+  }, { category: 'AI' });
+
+  reg('yolo', 'YOLO object detection', async (args) => {
+    if (args[0] === 'detect' && args[1]) {
+      const ora = require('ora');
+      const spinner = ora({ text: '  Detecting...', color: 'white' }).start();
+      const result = await navada.ai.yolo.detect(args[1]);
+      spinner.stop();
+      console.log(ui.header(`DETECTIONS (${result.count || 0})`));
+      if (result.detections) {
+        result.detections.forEach(d => console.log(ui.label(d.class, `${(d.confidence * 100).toFixed(1)}%`)));
+      }
+      console.log(ui.dim(`Inference: ${result.inference_ms}ms`));
+    } else if (args[0] === 'model') {
+      const model = await navada.ai.yolo.model();
+      console.log(ui.header('YOLO MODEL'));
+      console.log(ui.jsonColorize(model));
+    } else {
+      const health = await navada.ai.yolo.health();
+      console.log(ui.header('YOLO'));
+      console.log(ui.online('YOLO Service', health.status === 'ok'));
+    }
+  }, { category: 'AI', subs: ['detect', 'model'] });
+
+  reg('image', 'Generate an image', async (args) => {
+    const prompt = args.filter(a => !a.startsWith('--')).join(' ');
+    if (!prompt) { console.log(ui.dim('Usage: /image a futuristic city | /image --dalle NAVADA logo')); return; }
+    const useDalle = args.includes('--dalle');
+    const ora = require('ora');
+
+    if (useDalle && navada.config.openaiKey) {
+      const spinner = ora({ text: '  DALL-E generating...', color: 'white' }).start();
+      const result = await navada.ai.openai.image(prompt);
+      spinner.stop();
+      console.log(ui.success(`Generated: ${result.url || result.revised_prompt || 'done'}`));
+    } else {
+      const spinner = ora({ text: '  Flux generating (FREE)...', color: 'white' }).start();
+      const savePath = `navada-image-${Date.now()}.png`;
+      const { size } = await navada.cloudflare.flux.generate(prompt, { savePath });
+      spinner.stop();
+      console.log(ui.success(`Generated: ${savePath} (${(size / 1024).toFixed(1)} KB)`));
+    }
+  }, { category: 'AI' });
+
+  reg('model', 'Show/set default AI model', (args) => {
+    if (args[0]) {
+      const valid = ['auto', 'claude', 'gpt-4o', 'gpt-4o-mini', 'qwen'];
+      if (!valid.includes(args[0])) { console.log(ui.error(`Invalid model. Options: ${valid.join(', ')}`)); return; }
+      config.setModel(args[0]);
+      console.log(ui.success(`Model set to: ${args[0]}`));
+    } else {
+      console.log(ui.header('AI MODELS'));
+      const current = config.getModel();
+      console.log(ui.label('Current', current));
+      console.log('');
+      console.log(ui.dim('Available:'));
+      console.log(ui.label('auto', 'Claude (Anthropic) with tool use — default'));
+      console.log(ui.label('claude', 'Claude Sonnet 4 via Anthropic API'));
+      console.log(ui.label('gpt-4o', 'OpenAI GPT-4o (requires OPENAI_API_KEY)'));
+      console.log(ui.label('qwen', 'Qwen Coder 32B (FREE via HuggingFace)'));
+      console.log('');
+      console.log(ui.dim('Set with: /model claude'));
+    }
+  }, { category: 'AI', subs: ['auto', 'claude', 'gpt-4o', 'gpt-4o-mini', 'qwen'] });
+
+  reg('research', 'RAG search via MCP', async (args) => {
+    const query = args.join(' ');
+    if (!query) { console.log(ui.dim('Usage: /research Docker networking best practices')); return; }
+    const ora = require('ora');
+    const spinner = ora({ text: '  Searching...', color: 'white' }).start();
+    const result = await navada.mcp.call('rag-search', { query });
+    spinner.stop();
+    console.log(ui.header('RESEARCH'));
+    console.log(typeof result === 'object' ? ui.jsonColorize(result) : `  ${result}`);
+  }, { category: 'AI' });
+};