navada-edge-cli 2.4.1 → 2.5.0

package/bin/navada.js

@@ -1,5 +1,11 @@
 #!/usr/bin/env node
 'use strict';
 
+const [major] = process.versions.node.split('.').map(Number);
+if (major < 18) {
+  console.error(`\nNAVADA Edge CLI requires Node.js >= 18 (you have ${process.version}).\nUpdate: https://nodejs.org/\n`);
+  process.exit(1);
+}
+
 const { run } = require('../lib/cli');
 run(process.argv.slice(2));

package/lib/agent.js

@@ -4,6 +4,8 @@ const { execSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const https = require('https');
+const http = require('http');
 const navada = require('navada-edge-sdk');
 const ui = require('./ui');
 const config = require('./config');
@@ -26,6 +28,36 @@ When you don't have a tool for something, say so clearly and suggest an alternat
 Keep responses short. Code blocks when needed. No fluff.`,
 };
 
+// ---------------------------------------------------------------------------
+// Rate limit tracking (in-memory, per session)
+// ---------------------------------------------------------------------------
+const rateTracker = {
+  requests: [],  // timestamps of recent requests
+  windowMs: 60000,  // 1 minute window
+  limit: 30,
+
+  record() {
+    const now = Date.now();
+    this.requests.push(now);
+    this.cleanup();
+  },
+
+  cleanup() {
+    const cutoff = Date.now() - this.windowMs;
+    this.requests = this.requests.filter(t => t > cutoff);
+  },
+
+  remaining() {
+    this.cleanup();
+    return Math.max(0, this.limit - this.requests.length);
+  },
+
+  used() {
+    this.cleanup();
+    return this.requests.length;
+  },
+};
+
 // ---------------------------------------------------------------------------
 // Local tools — run on the USER's machine
 // ---------------------------------------------------------------------------
@@ -97,17 +129,18 @@ const localTools = {
 // ---------------------------------------------------------------------------
 // Free tier — proxied through NAVADA Edge Dashboard (key stays on ASUS)
 // ---------------------------------------------------------------------------
-// Dashboard proxy endpoints — tries Cloudflare tunnel first (works for everyone),
-// then falls back to direct Tailscale IP (faster but only works on VPN)
 const FREE_TIER_ENDPOINTS = [
   'https://api.navada-edge-server.uk/api/v1/chat',    // Cloudflare tunnel (public, works for all)
   'http://100.88.118.128:7900/api/v1/chat',           // Direct Tailscale (VPN users only)
 ];
 
-async function callFreeTier(messages) {
-  // Try each endpoint (public first, then Tailscale)
+async function callFreeTier(messages, stream = false) {
   for (const endpoint of FREE_TIER_ENDPOINTS) {
     try {
+      if (stream) {
+        return await streamFreeTier(endpoint, messages);
+      }
+
       const r = await navada.request(endpoint, {
         method: 'POST',
         body: { messages },
@@ -116,7 +149,7 @@ async function callFreeTier(messages) {
 
       if (r.status === 429) {
         return {
-          content: `Free tier limit reached (30 requests/min).
+          content: `Free tier limit reached (${rateTracker.used()}/${rateTracker.limit} RPM used).
 
 To continue, add your own API key:
   /login sk-ant-your-anthropic-key    (full agent with tool use)
@@ -129,37 +162,256 @@ Or wait a minute and try again.`,
       }
 
       if (r.status === 200) {
+        rateTracker.record();
         return { content: r.data?.choices?.[0]?.message?.content || '', isRateLimit: false };
       }
     } catch {
-      continue; // Try next endpoint
+      continue;
     }
   }
 
-  throw new Error('Free tier unavailable. Add your own key: /login <key>');
+  return {
+    content: `NAVADA Edge server is currently offline.
+
+Options:
+  /login sk-ant-your-key    Use your own Anthropic key (works offline from our server)
+  /login sk-your-key        Use OpenAI key
+  /doctor                   Check which services are reachable
+
+The free tier requires the NAVADA Edge server to be online.
+It will come back automatically — try again in a few minutes.`,
+    isRateLimit: false,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Streaming — free tier (Grok via dashboard)
+// ---------------------------------------------------------------------------
+function streamFreeTier(endpoint, messages) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(endpoint);
+    const transport = url.protocol === 'https:' ? https : http;
+    const body = JSON.stringify({ messages, stream: true });
+
+    const req = transport.request(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) },
+      timeout: endpoint.includes('navada-edge-server.uk') ? 30000 : 5000,
+    }, (res) => {
+      // If server doesn't support streaming, collect full response
+      if (!res.headers['content-type']?.includes('text/event-stream')) {
+        let data = '';
+        res.on('data', c => data += c);
+        res.on('end', () => {
+          try {
+            const parsed = JSON.parse(data);
+            if (res.statusCode === 429) {
+              resolve({ content: `Free tier limit reached (${rateTracker.used()}/${rateTracker.limit} RPM).`, isRateLimit: true });
+            } else if (res.statusCode === 200) {
+              rateTracker.record();
+              resolve({ content: parsed?.choices?.[0]?.message?.content || '', isRateLimit: false });
+            } else {
+              reject(new Error(`HTTP ${res.statusCode}`));
+            }
+          } catch { reject(new Error(`HTTP ${res.statusCode}`)); }
+        });
+        return;
+      }
+
+      // SSE streaming
+      rateTracker.record();
+      let fullContent = '';
+      let buffer = '';
+
+      res.on('data', (chunk) => {
+        buffer += chunk.toString();
+        const lines = buffer.split('\n');
+        buffer = lines.pop(); // keep incomplete line
+
+        for (const line of lines) {
+          if (!line.startsWith('data: ')) continue;
+          const data = line.slice(6).trim();
+          if (data === '[DONE]') continue;
+          try {
+            const parsed = JSON.parse(data);
+            const delta = parsed.choices?.[0]?.delta?.content || '';
+            if (delta) {
+              process.stdout.write(delta);
+              fullContent += delta;
+            }
+          } catch {}
+        }
+      });
+
+      res.on('end', () => {
+        if (fullContent) process.stdout.write('\n');
+        resolve({ content: fullContent, isRateLimit: false, streamed: true });
+      });
+    });
+
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error('Timeout')); });
+    req.write(body);
+    req.end();
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Streaming — Anthropic Claude API
+// ---------------------------------------------------------------------------
+function streamAnthropic(key, messages, tools, system) {
+  return new Promise((resolve, reject) => {
+    const body = JSON.stringify({
+      model: 'claude-sonnet-4-20250514',
+      max_tokens: 4096,
+      system: system || IDENTITY.personality,
+      messages,
+      tools,
+      stream: true,
+    });
+
+    const req = https.request('https://api.anthropic.com/v1/messages', {
+      method: 'POST',
+      headers: {
+        'x-api-key': key,
+        'anthropic-version': '2023-06-01',
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(body),
+      },
+      timeout: 120000,
+    }, (res) => {
+      if (res.statusCode !== 200) {
+        let data = '';
+        res.on('data', c => data += c);
+        res.on('end', () => reject(new Error(`Anthropic API error ${res.statusCode}: ${data.slice(0, 200)}`)));
+        return;
+      }
+
+      let buffer = '';
+      const contentBlocks = [];
+      let currentText = '';
+      let stopReason = null;
+
+      res.on('data', (chunk) => {
+        buffer += chunk.toString();
+        const lines = buffer.split('\n');
+        buffer = lines.pop();
+
+        for (const line of lines) {
+          if (!line.startsWith('data: ')) continue;
+          try {
+            const event = JSON.parse(line.slice(6));
+
+            switch (event.type) {
+              case 'content_block_start':
+                if (event.content_block?.type === 'text') {
+                  currentText = '';
+                } else if (event.content_block?.type === 'tool_use') {
+                  contentBlocks.push({ type: 'tool_use', id: event.content_block.id, name: event.content_block.name, input: '' });
+                }
+                break;
+
+              case 'content_block_delta':
+                if (event.delta?.type === 'text_delta') {
+                  process.stdout.write(event.delta.text);
+                  currentText += event.delta.text;
+                } else if (event.delta?.type === 'input_json_delta') {
+                  const last = contentBlocks[contentBlocks.length - 1];
+                  if (last?.type === 'tool_use') last.input += event.delta.partial_json;
+                }
+                break;
+
+              case 'content_block_stop':
+                if (currentText) {
+                  contentBlocks.push({ type: 'text', text: currentText });
+                  currentText = '';
+                }
+                // Parse tool input JSON
+                const lastBlock = contentBlocks[contentBlocks.length - 1];
+                if (lastBlock?.type === 'tool_use' && typeof lastBlock.input === 'string') {
+                  try { lastBlock.input = JSON.parse(lastBlock.input); } catch { lastBlock.input = {}; }
+                }
+                break;
+
+              case 'message_delta':
+                stopReason = event.delta?.stop_reason;
+                break;
+            }
+          } catch {}
+        }
+      });
+
+      res.on('end', () => {
+        if (contentBlocks.some(b => b.type === 'text')) process.stdout.write('\n');
+        resolve({ content: contentBlocks, stop_reason: stopReason });
+      });
+    });
+
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error('Timeout')); });
+    req.write(body);
+    req.end();
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Smart model routing — detect intent and pick best provider
+// ---------------------------------------------------------------------------
+const CODE_PATTERNS = /\b(function|class|const |let |var |import |export |def |async |await |return |console\.|print\(|=>|\.map\(|\.filter\(|\.reduce\(|npm |pip |git |docker |curl |ssh |sudo )\b|```|\.js\b|\.py\b|\.ts\b/i;
+const COMPLEX_PATTERNS = /\b(explain|analyze|compare|design|architect|plan|review|debug|refactor|deploy|migrate|optimize)\b/i;
+
+function detectIntent(message) {
+  const lower = message.toLowerCase();
+  const isCode = CODE_PATTERNS.test(message);
+  const isComplex = COMPLEX_PATTERNS.test(lower) || message.length > 500;
+  const isAction = /\b(run|execute|create|delete|install|start|stop|restart|build|push|pull)\b/i.test(lower);
+
+  if (isAction) return 'action';     // needs tool use → Anthropic
+  if (isCode && !isComplex) return 'code';  // code help → Qwen (free) or Grok
+  if (isComplex) return 'complex';    // deep analysis → Anthropic
+  return 'general';                   // general chat → Grok (free)
 }
 
 // ---------------------------------------------------------------------------
 // Anthropic Claude API — conversational agent with tool use
 // ---------------------------------------------------------------------------
 async function chat(userMessage, conversationHistory = []) {
-  // Smart key detection — check all possible locations
   const anthropicKey = config.get('anthropicKey')
-    || config.getApiKey()  // /setup saves here
+    || config.getApiKey()
     || process.env.ANTHROPIC_API_KEY
     || '';
 
-  // Auto-detect: if the key starts with sk-ant, it's Anthropic
   const apiKey = config.getApiKey();
   const effectiveKey = anthropicKey
     || (apiKey && apiKey.startsWith('sk-ant') ? apiKey : '')
     || '';
 
-  // No personal key — use Grok free tier
+  // Smart routing when model is set to 'auto'
+  const modelPref = config.getModel();
+  const intent = detectIntent(userMessage);
+
+  // No personal key — use free tier
   if (!effectiveKey) {
+    // Try Qwen for code if HuggingFace token available
+    if (intent === 'code' && navada.config.hfToken) {
+      try {
+        const r = await navada.ai.huggingface.qwen(userMessage);
+        return typeof r === 'object' ? JSON.stringify(r) : r;
+      } catch {}
+    }
     return grokChat(userMessage, conversationHistory);
   }
 
+  // Has Anthropic key but could route to cheaper options for simple queries
+  if (modelPref === 'auto' && intent === 'general' && !conversationHistory.length) {
+    // General questions don't need tool use — use Grok free tier to save API cost
+    try {
+      const result = await callFreeTier([{ role: 'user', content: userMessage }], true);
+      if (result.content) return result.content;
+    } catch {}
+    // Fall through to Anthropic if free tier fails
+  }
+
   const tools = [
     {
       name: 'shell',
@@ -233,8 +485,8 @@ async function chat(userMessage, conversationHistory = []) {
     { role: 'user', content: userMessage },
   ];
 
-  // Call Anthropic API
-  let response = await callAnthropic(effectiveKey, messages, tools);
+  // Stream the response
+  let response = await streamAnthropic(effectiveKey, messages, tools);
 
   // Handle tool use loop
   let iterations = 0;
@@ -244,53 +496,21 @@ async function chat(userMessage, conversationHistory = []) {
     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);
+    response = await streamAnthropic(effectiveKey, messages, tools);
   }
 
-  // Extract final text
+  // Extract final text (already streamed to stdout)
   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) {
@@ -328,12 +548,16 @@ async function grokChat(userMessage, conversationHistory = []) {
     { role: 'user', content: userMessage },
   ];
 
-  const result = await callFreeTier(messages);
+  // Try streaming first
+  const result = await callFreeTier(messages, true);
+  if (result.streamed) {
+    // Already printed to stdout, return for history
+    return result.content || 'No response from free tier. Try /login <key> for full agent.';
+  }
   return result.content || 'No response from free tier. Try /login <key> for full agent.';
 }
 
 async function fallbackChat(msg) {
-  // Try MCP → Qwen → OpenAI → Grok free tier
   if (navada.config.mcp) {
     try {
       const r = await navada.mcp.call('chat', { message: msg });
@@ -349,7 +573,6 @@ async function fallbackChat(msg) {
   if (navada.config.openaiKey) {
     try { return await navada.ai.openai.chat(msg); } catch {}
   }
-  // Grok is always available as the free fallback
   try {
     const result = await callFreeTier([{ role: 'user', content: msg }]);
     return result.content;
@@ -358,28 +581,53 @@ async function fallbackChat(msg) {
 }
 
 // ---------------------------------------------------------------------------
-// Telemetry — track installs + usage
+// Update checker (non-blocking, runs once per session)
 // ---------------------------------------------------------------------------
-async function reportTelemetry(event, data = {}) {
-  if (!navada.config.dashboard) return;
+let _updateInfo = null;
+
+async function checkForUpdate() {
   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,
-    });
+    const pkg = require('../package.json');
+    const r = await navada.request('https://registry.npmjs.org/navada-edge-cli/latest', { timeout: 5000 });
+    if (r.status === 200 && r.data?.version && r.data.version !== pkg.version) {
+      _updateInfo = { current: pkg.version, latest: r.data.version };
+    }
   } catch {}
 }
 
-module.exports = { IDENTITY, chat, localTools, reportTelemetry, fallbackChat };
+function getUpdateInfo() { return _updateInfo; }
+
+// ---------------------------------------------------------------------------
+// Telemetry — track installs + usage
+// ---------------------------------------------------------------------------
+async function reportTelemetry(event, data = {}) {
+  // Try dashboard first, then public tunnel
+  const endpoints = [
+    'http://100.88.118.128:7900',
+    'https://api.navada-edge-server.uk',
+  ];
+
+  for (const base of endpoints) {
+    try {
+      await navada.request(base + '/api/agent-heartbeat', {
+        method: 'POST',
+        body: {
+          agent: 'navada-edge-cli',
+          event,
+          version: require('../package.json').version,
+          hostname: require('crypto').createHash('sha256').update(os.hostname()).digest('hex').slice(0, 12),
+          platform: os.platform(),
+          arch: os.arch(),
+          nodeVersion: process.version,
+          tier: config.getTier(),
+          ts: new Date().toISOString(),
+          ...data,
+        },
+        timeout: 3000,
+      });
+      return; // success
+    } catch { continue; }
+  }
+}
+
+module.exports = { IDENTITY, chat, localTools, reportTelemetry, fallbackChat, checkForUpdate, getUpdateInfo, rateTracker };

package/lib/cli.js

@@ -8,7 +8,7 @@ const history = require('./history');
 const { completer } = require('./completer');
 const { execute, getCompletions } = require('./registry');
 const { loadAll } = require('./commands/index');
-const { reportTelemetry } = require('./agent');
+const { reportTelemetry, checkForUpdate, getUpdateInfo, rateTracker } = require('./agent');
 
 function applyConfig() {
   const cfg = config.getAll();
@@ -43,6 +43,23 @@ function showWelcome() {
   console.log('');
 }
 
+function showTierInfo() {
+  const hasPersonalKey = config.getApiKey() || config.get('anthropicKey') || process.env.ANTHROPIC_API_KEY;
+  if (!hasPersonalKey) {
+    console.log(ui.dim(`Free tier active (Grok, ${rateTracker.remaining()}/${rateTracker.limit} RPM). /login <key> for full agent.`));
+    console.log('');
+  }
+}
+
+function showUpdateBanner() {
+  const info = getUpdateInfo();
+  if (info) {
+    console.log(ui.warn(`Update available: v${info.current} → v${info.latest}`));
+    console.log(ui.dim('Run: npm install -g navada-edge-cli'));
+    console.log('');
+  }
+}
+
 function startRepl() {
   const historyItems = history.load();
 
@@ -62,6 +79,15 @@ function startRepl() {
     if (input) {
       history.append(input);
       await execute(input);
+
+      // Show rate limit after free tier usage
+      const hasKey = config.getApiKey() || config.get('anthropicKey') || process.env.ANTHROPIC_API_KEY;
+      if (!hasKey && rateTracker.used() > 0) {
+        const remaining = rateTracker.remaining();
+        if (remaining <= 5 && remaining > 0) {
+          console.log(ui.warn(`${remaining} free requests remaining this minute`));
+        }
+      }
     }
     console.log('');
     rl.prompt();
@@ -85,20 +111,19 @@ async function run(argv) {
   applyConfig();
 
   if (argv.length === 0) {
-    // Report telemetry
+    // Check for updates (non-blocking)
+    checkForUpdate().then(() => {
+      // Show update banner after a short delay (if in REPL)
+      setTimeout(showUpdateBanner, 2000);
+    });
+
+    // Report telemetry (non-blocking)
     if (config.isFirstRun()) reportTelemetry('install');
     else reportTelemetry('session_start');
 
-    // Interactive mode — always start. User can /setup if needed.
+    // Interactive mode
     showWelcome();
-
-    // Show tier info
-    const hasPersonalKey = config.getApiKey() || config.get('anthropicKey') || process.env.ANTHROPIC_API_KEY;
-    if (!hasPersonalKey) {
-      console.log(ui.dim('Free tier active (Grok). /login <your-key> for full agent with tool use.'));
-      console.log('');
-    }
-
+    showTierInfo();
     startRepl();
   } else if (argv[0] === '--version' || argv[0] === '-v') {
     const pkg = require('../package.json');
@@ -106,7 +131,7 @@ async function run(argv) {
   } else if (argv[0] === '--help' || argv[0] === '-h') {
     console.log(ui.banner());
     console.log('  Usage:');
-    console.log('    navada                     Interactive mode (first run triggers setup)');
+    console.log('    navada                     Interactive mode');
     console.log('    navada setup               Run onboarding wizard');
     console.log('    navada status              Ping all nodes');
     console.log('    navada doctor              Test all connections');
@@ -116,6 +141,7 @@ async function run(argv) {
     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 upgrade             Check for updates');
     console.log('    navada --version           Show version');
     console.log('');
     console.log('  Run `navada` with no args for interactive mode.');

package/lib/commands/ai.js

@@ -3,7 +3,7 @@
 const navada = require('navada-edge-sdk');
 const ui = require('../ui');
 const config = require('../config');
-const { chat: agentChat, reportTelemetry } = require('../agent');
+const { chat: agentChat, reportTelemetry, rateTracker } = require('../agent');
 
 module.exports = function(reg) {
 
@@ -13,12 +13,21 @@ module.exports = function(reg) {
   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();
+
+    const hasKey = config.getApiKey() || config.get('anthropicKey') || process.env.ANTHROPIC_API_KEY;
+
+    // Show a brief "thinking" indicator, then clear it when streaming starts
+    if (!hasKey) {
+      process.stdout.write(ui.dim('  NAVADA > '));
+    } else {
+      const ora = require('ora');
+      var spinner = ora({ text: '  NAVADA thinking...', color: 'white' }).start();
+    }
 
     try {
       const response = await agentChat(msg, conversationHistory);
-      spinner.stop();
+
+      if (spinner) spinner.stop();
 
       // Update conversation history
       conversationHistory.push({ role: 'user', content: msg });
@@ -27,13 +36,16 @@ module.exports = function(reg) {
       // Keep history manageable (last 20 turns)
       while (conversationHistory.length > 40) conversationHistory.splice(0, 2);
 
-      console.log(ui.header('NAVADA'));
-      console.log(`  ${response}`);
+      // Only print if not already streamed
+      if (!response._streamed) {
+        console.log(ui.header('NAVADA'));
+        console.log(`  ${response}`);
+      }
 
       // Track usage
       reportTelemetry('chat', { messageLength: msg.length });
     } catch (e) {
-      spinner.stop();
+      if (spinner) spinner.stop();
       console.log(ui.error(e.message));
       console.log(ui.dim('Check: /config to see which providers are set, or /setup to configure.'));
     }

package/lib/ui.js

@@ -28,7 +28,8 @@ function banner() {
     style('banner3', '╚═╝  ╚═══╝╚═╝  ╚═╝  ╚═══╝  ╚═╝  ╚═╝╚═════╝ ╚═╝  ╚═╝'),
   ];
 
-  const titleLine = style('header', 'E D G E   N E T W O R K') + '   ' + style('dim', 'v2.0.0');
+  const ver = require('../package.json').version;
+  const titleLine = style('header', 'E D G E   N E T W O R K') + '   ' + style('dim', `v${ver}`);
 
   let out = '\n' + topBorder + '\n';
   out += sp + side + ' '.repeat(w) + side + '\n';

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "navada-edge-cli",
-  "version": "2.4.1",
+  "version": "2.5.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": {
-    "navada": "./bin/navada.js"
+    "navada": "bin/navada.js"
   },
   "type": "commonjs",
   "engines": {
@@ -15,8 +15,19 @@
     "test": "node -e \"require('./lib/registry'); require('./lib/commands/index').loadAll(); console.log('OK — ' + Object.keys(require('./lib/registry').commands).length + ' commands loaded');\""
   },
   "keywords": [
-    "navada", "edge", "cli", "tui", "distributed", "cloudflare",
-    "docker", "ai", "mcp", "sdk", "agents", "yolo", "terminal"
+    "navada",
+    "edge",
+    "cli",
+    "tui",
+    "distributed",
+    "cloudflare",
+    "docker",
+    "ai",
+    "mcp",
+    "sdk",
+    "agents",
+    "yolo",
+    "terminal"
   ],
   "author": {
     "name": "Leslie Akpareva",
@@ -27,7 +38,7 @@
   "homepage": "https://github.com/Navada25/edge-sdk",
   "repository": {
     "type": "git",
-    "url": "https://github.com/Navada25/edge-sdk.git"
+    "url": "git+https://github.com/Navada25/edge-sdk.git"
   },
   "dependencies": {
     "navada-edge-sdk": "^1.1.0",