navada-edge-cli 2.0.0 → 2.1.0

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

@@ -8,6 +8,7 @@ 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 cfg = config.getAll();
@@ -86,10 +87,13 @@ async function run(argv) {
   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();

package/lib/commands/ai.js

@@ -3,48 +3,39 @@
 const navada = require('navada-edge-sdk');
 const ui = require('../ui');
 const config = require('../config');
+const { chat: agentChat, reportTelemetry } = require('../agent');
 
 module.exports = function(reg) {
 
-  reg('chat', 'Chat with AI (uses configured model)', async (args) => {
+  // 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('Usage: /chat What is the ISA allowance for 2026?')); return; }
+    if (!msg) { console.log(ui.dim('Just type naturally — no /command needed.')); return; }
     const ora = require('ora');
-    const model = config.getModel();
+    const spinner = ora({ text: '  NAVADA thinking...', color: 'white' }).start();
 
-    if (model === 'qwen' || (!navada.config.openaiKey && navada.config.hfToken)) {
-      // Use Qwen (FREE)
-      const spinner = ora({ text: '  Qwen thinking...', color: 'white' }).start();
-      const result = await navada.ai.huggingface.qwen(msg);
-      spinner.stop();
-      console.log(ui.header('QWEN CODER'));
-      console.log(typeof result === 'object' ? ui.jsonColorize(result) : `  ${result}`);
-    } else if (navada.config.openaiKey) {
-      // Use OpenAI
-      const spinner = ora({ text: '  Thinking...', color: 'white' }).start();
-      const response = await navada.ai.openai.chat(msg);
+    try {
+      const response = await agentChat(msg, conversationHistory);
       spinner.stop();
-      console.log(ui.header('AI RESPONSE'));
+
+      // 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}`);
-    } else {
-      // Route through MCP if available
-      if (navada.config.mcp) {
-        const spinner = ora({ text: '  Asking NAVADA...', color: 'white' }).start();
-        try {
-          const result = await navada.mcp.call('chat', { message: msg });
-          spinner.stop();
-          console.log(ui.header('NAVADA'));
-          console.log(typeof result === 'object' ? ui.jsonColorize(result) : `  ${result}`);
-        } catch {
-          spinner.stop();
-          console.log(ui.warn('No AI provider configured. Set OPENAI_API_KEY, HF_TOKEN, or connect to MCP.'));
-          console.log(ui.dim('Run /setup to configure, or /model to choose a provider.'));
-        }
-      } else {
-        console.log(ui.warn('No AI provider configured.'));
-        console.log(ui.dim('Options: set OPENAI_API_KEY, HF_TOKEN, or connect to MCP server.'));
-        console.log(ui.dim('Run /setup to configure, or /model to choose a provider.'));
-      }
+
+      // 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'] });
 
@@ -56,7 +47,7 @@ module.exports = function(reg) {
     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}`);
+    console.log(`  ${typeof result === 'object' ? ui.jsonColorize(result) : result}`);
   }, { category: 'AI' });
 
   reg('yolo', 'YOLO object detection', async (args) => {
@@ -88,12 +79,12 @@ module.exports = function(reg) {
     const ora = require('ora');
 
     if (useDalle && navada.config.openaiKey) {
-      const spinner = ora({ text: `  DALL-E generating...`, color: 'white' }).start();
+      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 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();
@@ -103,7 +94,7 @@ module.exports = function(reg) {
 
   reg('model', 'Show/set default AI model', (args) => {
     if (args[0]) {
-      const valid = ['auto', 'gpt-4o', 'gpt-4o-mini', 'qwen', 'flux'];
+      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]}`));
@@ -113,15 +104,14 @@ module.exports = function(reg) {
       console.log(ui.label('Current', current));
       console.log('');
       console.log(ui.dim('Available:'));
-      console.log(ui.label('auto', 'Route to best available provider'));
+      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('gpt-4o-mini', 'OpenAI GPT-4o-mini (requires OPENAI_API_KEY)'));
       console.log(ui.label('qwen', 'Qwen Coder 32B (FREE via HuggingFace)'));
-      console.log(ui.label('flux', 'Cloudflare Flux (FREE image gen)'));
       console.log('');
-      console.log(ui.dim('Set with: /model qwen'));
+      console.log(ui.dim('Set with: /model claude'));
     }
-  }, { category: 'AI', subs: ['auto', 'gpt-4o', 'gpt-4o-mini', 'qwen', 'flux'] });
+  }, { category: 'AI', subs: ['auto', 'claude', 'gpt-4o', 'gpt-4o-mini', 'qwen'] });
 
   reg('research', 'RAG search via MCP', async (args) => {
     const query = args.join(' ');

package/lib/commands/system.js

@@ -217,13 +217,67 @@ module.exports = function(reg) {
   }, { category: 'SYSTEM' });
 
   // --- /email ---
-  reg('email', 'Send email via MCP', async (args) => {
-    if (args.length < 3) { console.log(ui.dim('Usage: /email <to> <subject> <body>')); return; }
+  reg('email', 'Send email (SMTP or MCP)', async (args) => {
+    if (args[0] === 'setup') {
+      // Configure SMTP
+      const readline = require('readline');
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      const ask = (q) => new Promise(r => rl.question(q, r));
+
+      console.log(ui.header('EMAIL SETUP'));
+      console.log(ui.dim('  Providers: Hotmail (smtp-mail.outlook.com), Gmail (smtp.gmail.com), Zoho (smtp.zoho.eu)'));
+      console.log('');
+      const host = await ask('  SMTP host: ');
+      const port = await ask('  SMTP port [587]: ');
+      const user = await ask('  Email/username: ');
+      const pass = await ask('  Password/app password: ');
+      const from = await ask('  From address: ');
+      rl.close();
+
+      config.setSmtp({ host: host.trim(), port: parseInt(port.trim() || '587'), user: user.trim(), pass: pass.trim(), from: from.trim() || user.trim() });
+      console.log(ui.success('SMTP configured'));
+      return;
+    }
+
+    if (args.length < 3) {
+      console.log(ui.dim('Usage: /email <to> <subject> <body>'));
+      console.log(ui.dim('Setup: /email setup'));
+      return;
+    }
+
     const [to, subject, ...bodyParts] = args;
     const body = bodyParts.join(' ');
-    const result = await navada.mcp.call('send-email', { to, subject, body });
-    console.log(ui.success(`Email sent to ${to}`));
-  }, { category: 'SYSTEM' });
+    const smtp = config.getSmtp();
+
+    // Try local SMTP first
+    if (smtp.host && smtp.user && smtp.pass) {
+      try {
+        const nodemailer = require('nodemailer');
+        const transport = nodemailer.createTransport({
+          host: smtp.host, port: smtp.port, secure: smtp.port === 465,
+          auth: { user: smtp.user, pass: smtp.pass },
+        });
+        await transport.sendMail({ from: smtp.from || smtp.user, to, subject, text: body });
+        console.log(ui.success(`Email sent to ${to} via ${smtp.host}`));
+        return;
+      } catch (e) {
+        console.log(ui.warn(`SMTP failed: ${e.message}. Trying MCP...`));
+      }
+    }
+
+    // Fall back to MCP
+    if (navada.config.mcp) {
+      try {
+        await navada.mcp.call('send-email', { to, subject, body });
+        console.log(ui.success(`Email sent to ${to} via MCP`));
+        return;
+      } catch (e) {
+        console.log(ui.error(`MCP email failed: ${e.message}`));
+      }
+    }
+
+    console.log(ui.error('No email provider configured. Run /email setup to configure SMTP.'));
+  }, { category: 'SYSTEM', subs: ['setup'] });
 
   // --- /activity ---
   reg('activity', 'Recent activity log', async () => {

package/lib/config.js

@@ -44,7 +44,19 @@ function getServePort() { return parseInt(load().servePort || process.env.NAVADA
 function getTier() { return load().tier || 'FREE'; }
 function setTier(tier) { const c = load(); c.tier = tier; save(c); }
 
-function get(key) { return process.env[`NAVADA_${key.toUpperCase()}`] || load()[key] || ''; }
+// SMTP email config
+function getSmtp() {
+  return load().smtp || {
+    host: process.env.SMTP_HOST || '',
+    port: parseInt(process.env.SMTP_PORT || '587'),
+    user: process.env.SMTP_USER || '',
+    pass: process.env.SMTP_PASS || '',
+    from: process.env.SMTP_FROM || '',
+  };
+}
+function setSmtp(smtp) { const c = load(); c.smtp = smtp; save(c); }
+
+function get(key) { return process.env[`NAVADA_${key.toUpperCase()}`] || process.env[key.toUpperCase()] || process.env[key] || load()[key] || ''; }
 function set(key, value) { const c = load(); c[key] = value; save(c); }
 
 function getAll() { return { ...load(), apiKey: getApiKey() }; }
@@ -59,4 +71,5 @@ module.exports = {
   getServePort,
   getTier, setTier,
   get, set, getAll,
+  getSmtp, setSmtp,
 };

package/lib/registry.js

@@ -23,30 +23,45 @@ function register(name, description, handler, opts = {}) {
 }
 
 async function execute(input) {
-  const parts = input.trim().replace(/^\//, '').split(/\s+/);
-  let name = parts[0]?.toLowerCase();
-  const args = parts.slice(1);
+  const trimmed = input.trim();
+  if (!trimmed) return;
 
-  if (!name) return;
+  // If input starts with /, treat as a command
+  if (trimmed.startsWith('/')) {
+    const parts = trimmed.slice(1).split(/\s+/);
+    let name = parts[0]?.toLowerCase();
+    const args = parts.slice(1);
 
-  // Check user-defined aliases
-  const aliases = config.getAliases();
-  if (aliases[name]) {
-    const expanded = aliases[name].split(/\s+/);
-    name = expanded[0];
-    args.unshift(...expanded.slice(1));
-  }
+    if (!name) return;
 
-  const cmd = commands[name];
-  if (!cmd) {
-    const ui = require('./ui');
-    console.log(ui.error(`Unknown command: /${parts[0]}`));
-    console.log(ui.dim('Type /help for available commands'));
+    // Check user-defined aliases
+    const aliases = config.getAliases();
+    if (aliases[name]) {
+      const expanded = aliases[name].split(/\s+/);
+      name = expanded[0];
+      args.unshift(...expanded.slice(1));
+    }
+
+    const cmd = commands[name];
+    if (!cmd) {
+      const ui = require('./ui');
+      console.log(ui.error(`Unknown command: /${parts[0]}`));
+      console.log(ui.dim('Type /help for available commands'));
+      return;
+    }
+
+    try {
+      await cmd.handler(args);
+    } catch (e) {
+      const ui = require('./ui');
+      console.log(ui.error(e.message));
+    }
     return;
   }
 
+  // No slash — treat as natural language → route to AI agent
   try {
-    await cmd.handler(args);
+    await commands['chat'].handler(trimmed.split(/\s+/));
   } catch (e) {
     const ui = require('./ui');
     console.log(ui.error(e.message));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "navada-edge-cli",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Interactive CLI for the NAVADA Edge Network — explore nodes, agents, Cloudflare, AI, Docker, and MCP from your terminal",
   "main": "lib/cli.js",
   "bin": {
@@ -36,7 +36,8 @@
     "ora": "^5.4.1"
   },
   "optionalDependencies": {
-    "qrcode-terminal": "^0.12.0"
+    "qrcode-terminal": "^0.12.0",
+    "nodemailer": "^6.9.0"
   },
   "publishConfig": {
     "access": "public"