navada-edge-cli 3.5.2 → 3.5.4

package/lib/agent.js

@@ -454,6 +454,7 @@ function streamFreeTier(endpoint, messages) {
 
       res.on('end', () => {
         if (fullContent) process.stdout.write('\n');
+        sessionState._lastStreamed = true;
         resolve({ content: fullContent, isRateLimit: false, streamed: true });
       });
     });
@@ -552,6 +553,7 @@ function streamAnthropic(key, messages, tools, system) {
 
       res.on('end', () => {
         if (contentBlocks.some(b => b.type === 'text')) process.stdout.write('\n');
+        sessionState._lastStreamed = true;
         resolve({ content: contentBlocks, stop_reason: stopReason });
       });
     });
@@ -637,6 +639,7 @@ function streamOpenAI(key, messages, model = 'gpt-4o') {
 
       res.on('end', () => {
         if (fullContent) process.stdout.write('\n');
+        sessionState._lastStreamed = true;
         toolCalls = toolCalls.filter(Boolean);
         resolve({ content: fullContent, tool_calls: toolCalls, finish_reason: finishReason });
       });
@@ -704,6 +707,7 @@ function streamGemini(key, messages, model = 'gemini-2.0-flash') {
 
       res.on('end', () => {
         if (fullContent) process.stdout.write('\n');
+        sessionState._lastStreamed = true;
         resolve({ content: fullContent });
       });
     });
@@ -746,10 +750,7 @@ async function openAIChat(key, userMessage, conversationHistory = []) {
     response = await streamOpenAI(key, messages, model);
   } catch (e) {
     if (e.message.includes('401') || e.message.includes('429') || e.message.includes('billing')) {
-      if (!sessionState._openaiWarned) {
-        console.log(ui.warn('OpenAI API unavailable, using Grok free tier. /login with a valid key to switch.'));
-        sessionState._openaiWarned = true;
-      }
+      sessionState._openaiWarned = true;
       return grokChat(userMessage, conversationHistory);
     }
     throw e;
@@ -842,15 +843,12 @@ async function chat(userMessage, conversationHistory = []) {
       ...conversationHistory.map(m => ({ role: m.role, content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content) })),
       { role: 'user', content: userMessage },
     ];
-    process.stdout.write(ui.dim('  NAVADA > '));
     try {
+      process.stdout.write(ui.dim('  '));
       const result = await streamGemini(effectiveGeminiKey, messages, geminiModel);
       return result.content;
     } catch (e) {
-      if (!sessionState._geminiWarned) {
-        console.log(ui.warn('Gemini API unavailable, using Grok free tier.'));
-        sessionState._geminiWarned = true;
-      }
+      sessionState._geminiWarned = true;
       return grokChat(userMessage, conversationHistory);
     }
   }
@@ -865,7 +863,7 @@ async function chat(userMessage, conversationHistory = []) {
       ...conversationHistory.map(m => ({ role: m.role, content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content) })),
       { role: 'user', content: userMessage },
     ];
-    process.stdout.write(ui.dim('  NAVADA > '));
+    process.stdout.write(ui.dim('  '));
     const result = await streamNvidia(effectiveNvidiaKey, messages, nvidiaModel);
     return result.content;
   }
@@ -999,10 +997,7 @@ async function chat(userMessage, conversationHistory = []) {
     const errMsg = e.message || '';
     // If billing/rate limit/auth error, fall back to free tier
     if (errMsg.includes('400') || errMsg.includes('401') || errMsg.includes('429') || errMsg.includes('usage limits')) {
-      if (!sessionState._anthropicWarned) {
-        console.log(ui.warn('Anthropic API unavailable, using Grok free tier. /login with a valid key to switch.'));
-        sessionState._anthropicWarned = true;
-      }
+      sessionState._anthropicWarned = true;
       return grokChat(userMessage, conversationHistory);
     }
     throw e;
@@ -1078,89 +1073,107 @@ async function executeTool(name, input) {
 // ---------------------------------------------------------------------------
 function tryLocalAction(userMessage) {
   const msg = userMessage.trim();
-  const lower = msg.toLowerCase();
   const home = os.homedir();
   const desktop = path.join(home, 'Desktop');
 
-  // Resolve common path references
-  function resolvePath(p) {
-    return p
-      .replace(/^~\//, home + '/')
-      .replace(/^~\\/, home + '\\')
-      .replace(/\bmy desktop\b/i, desktop)
-      .replace(/\bthe desktop\b/i, desktop)
-      .replace(/\bdesktop\b/i, desktop);
+  // Resolve a location phrase to an absolute path (use ORIGINAL case, not lowered)
+  function resolveLocation(phrase) {
+    const p = phrase.trim().replace(/[""'.,!]/g, '');
+    const low = p.toLowerCase();
+    if (low === 'my desktop' || low === 'the desktop' || low === 'desktop') return desktop;
+    if (low === 'home' || low === 'my home' || low === 'home directory') return home;
+    if (p.startsWith('~')) return p.replace(/^~[/\\]?/, home + path.sep);
+    if (path.isAbsolute(p)) return p;
+    return path.join(process.cwd(), p);
   }
 
+  // Extract the ORIGINAL-CASE name from the original message using a case-insensitive match
+  // We match on the original message to preserve casing
+  let m;
+
   // ── Create folder/directory ──
-  const mkdirMatch = lower.match(/(?:create|make|new)\s+(?:a\s+)?(?:new\s+)?(?:folder|directory|dir)\s+(?:called|named|on|at|in)?\s*[""']?(.+?)[""']?\s*(?:on|at|in)\s+(.+)/i)
-    || lower.match(/(?:create|make|new)\s+(?:a\s+)?(?:new\s+)?(?:folder|directory|dir)\s+(?:on|at|in)\s+(.+?)\s+(?:called|named)\s+[""']?(.+?)[""']?$/i)
-    || lower.match(/(?:create|make|new)\s+(?:a\s+)?(?:new\s+)?(?:folder|directory|dir)\s+(?:called|named)\s+[""']?(.+?)[""']?\s*(?:on|at|in)\s+(.+)/i)
-    || lower.match(/(?:create|make|new)\s+(?:a\s+)?(?:new\s+)?(?:folder|directory|dir)\s+(?:called|named)\s+[""']?(.+?)[""']?\s*$/i);
-
-  if (mkdirMatch) {
-    let folderName, location;
-    if (mkdirMatch.length === 3) {
-      folderName = mkdirMatch[1].trim().replace(/[""']/g, '');
-      location = mkdirMatch[2].trim().replace(/[""']/g, '');
-    } else {
-      folderName = mkdirMatch[1].trim().replace(/[""']/g, '');
-      location = lower.includes('desktop') ? desktop : process.cwd();
-    }
-    const resolved = path.resolve(resolvePath(location), folderName);
-    const result = localTools.shell.execute(process.platform === 'win32' ? `mkdir "${resolved}"` : `mkdir -p "${resolved}"`);
-    if (result.includes('Error')) return null; // let LLM handle
-    return `Created folder: ${resolved}`;
+  // Pattern: "create a folder called NAME on my desktop"
+  m = msg.match(/(?:create|make|new)\s+(?:a\s+)?(?:new\s+)?(?:folder|directory|dir)\s+(?:called|named)\s+[""']?([^""']+?)[""']?\s+(?:on|at|in)\s+(.+?)$/i);
+  if (m) {
+    const name = m[1].trim();
+    const loc = resolveLocation(m[2]);
+    const resolved = path.join(loc, name);
+    try { fs.mkdirSync(resolved, { recursive: true }); return `Created folder: ${resolved}`; }
+    catch (e) { return null; }
   }
 
-  // ── Create file ──
-  const touchMatch = lower.match(/(?:create|make|new|touch)\s+(?:a\s+)?(?:new\s+)?(?:file|empty file)\s+(?:called|named)\s+[""']?(.+?)[""']?\s*(?:on|at|in)\s+(.+)/i)
-    || lower.match(/(?:create|make|new|touch)\s+(?:a\s+)?(?:new\s+)?(?:file)\s+(?:called|named)\s+[""']?(.+?)[""']?\s*$/i);
+  // Pattern: "create a folder on my desktop called NAME"
+  m = msg.match(/(?:create|make|new)\s+(?:a\s+)?(?:new\s+)?(?:folder|directory|dir)\s+(?:on|at|in)\s+(.+?)\s+(?:called|named)\s+[""']?([^""']+?)[""']?\s*$/i);
+  if (m) {
+    const loc = resolveLocation(m[1]);
+    const name = m[2].trim();
+    const resolved = path.join(loc, name);
+    try { fs.mkdirSync(resolved, { recursive: true }); return `Created folder: ${resolved}`; }
+    catch (e) { return null; }
+  }
+
+  // Pattern: "create a folder called NAME" (no location — use cwd, or desktop if mentioned earlier)
+  m = msg.match(/(?:create|make|new)\s+(?:a\s+)?(?:new\s+)?(?:folder|directory|dir)\s+(?:called|named)\s+[""']?([^""']+?)[""']?\s*$/i);
+  if (m) {
+    const name = m[1].trim();
+    const loc = msg.toLowerCase().includes('desktop') ? desktop : process.cwd();
+    const resolved = path.join(loc, name);
+    try { fs.mkdirSync(resolved, { recursive: true }); return `Created folder: ${resolved}`; }
+    catch (e) { return null; }
+  }
+
+  // Pattern: "create a new folder NAME on my desktop" (no "called/named")
+  m = msg.match(/(?:create|make|new)\s+(?:a\s+)?(?:new\s+)?(?:folder|directory|dir)\s+([A-Za-z0-9_\-. ]+?)\s+(?:on|at|in)\s+(.+?)$/i);
+  if (m) {
+    const name = m[1].trim();
+    const loc = resolveLocation(m[2]);
+    const resolved = path.join(loc, name);
+    try { fs.mkdirSync(resolved, { recursive: true }); return `Created folder: ${resolved}`; }
+    catch (e) { return null; }
+  }
 
-  if (touchMatch) {
-    let fileName = touchMatch[1].trim().replace(/[""']/g, '');
-    let location = touchMatch[2] ? touchMatch[2].trim().replace(/[""']/g, '') : process.cwd();
-    const resolved = path.resolve(resolvePath(location), fileName);
+  // ── Create file ──
+  m = msg.match(/(?:create|make|new|touch)\s+(?:a\s+)?(?:new\s+)?(?:file)\s+(?:called|named)\s+[""']?([^""']+?)[""']?\s+(?:on|at|in)\s+(.+?)$/i);
+  if (m) {
+    const resolved = path.join(resolveLocation(m[2]), m[1].trim());
     return localTools.writeFile.execute(resolved, '');
   }
+  m = msg.match(/(?:create|make|new|touch)\s+(?:a\s+)?(?:new\s+)?(?:file)\s+(?:called|named)\s+[""']?([^""']+?)[""']?\s*$/i);
+  if (m) {
+    const loc = msg.toLowerCase().includes('desktop') ? desktop : process.cwd();
+    return localTools.writeFile.execute(path.join(loc, m[1].trim()), '');
+  }
 
   // ── Read file ──
-  const readMatch = lower.match(/(?:read|show|display|cat|open)\s+(?:the\s+)?(?:file\s+)?[""']?(.+\.\w+)[""']?/i);
-  if (readMatch) {
-    const filePath = resolvePath(readMatch[1].trim().replace(/[""']/g, ''));
+  m = msg.match(/(?:read|show|display|cat|open)\s+(?:the\s+)?(?:file\s+)?[""']?([^""']+\.\w{1,5})[""']?/i);
+  if (m) {
+    const p = m[1].trim();
+    const filePath = path.isAbsolute(p) ? p : path.join(process.cwd(), p);
     return localTools.readFile.execute(filePath);
   }
 
   // ── Delete file/folder ──
-  const deleteMatch = lower.match(/(?:delete|remove|rm)\s+(?:the\s+)?(?:file|folder|directory)?\s*[""']?(.+?)[""']?\s*$/i);
-  if (deleteMatch && (lower.includes('file') || lower.includes('folder') || lower.includes('directory'))) {
-    const filePath = path.resolve(resolvePath(deleteMatch[1].trim().replace(/[""']/g, '')));
+  m = msg.match(/(?:delete|remove|rm)\s+(?:the\s+)?(?:file|folder|directory)\s+[""']?([^""']+?)[""']?\s*$/i);
+  if (m) {
+    const p = m[1].trim();
+    const filePath = path.isAbsolute(p) ? p : path.join(process.cwd(), p);
     return localTools.deleteFile.execute(filePath);
   }
 
   // ── List files ──
-  const lsMatch = lower.match(/(?:list|show|ls|dir)\s+(?:the\s+)?(?:files|contents|items)\s+(?:in|on|at|of)\s+(.+)/i);
-  if (lsMatch) {
-    const dir = resolvePath(lsMatch[1].trim().replace(/[""']/g, ''));
-    return localTools.listFiles.execute(dir);
+  m = msg.match(/(?:list|show|ls|dir)\s+(?:the\s+)?(?:files|contents|items)\s+(?:in|on|at|of)\s+(.+)/i);
+  if (m) {
+    return localTools.listFiles.execute(resolveLocation(m[1]));
   }
 
-  return null; // No match — let LLM handle
+  return null;
 }
 
 async function grokChat(userMessage, conversationHistory = []) {
   // Try local action first — enables file ops on free tier
   const localResult = tryLocalAction(userMessage);
   if (localResult) {
-    console.log(`  ${localResult}`);
-    // Send result to LLM for a natural confirmation
-    const confirmMsg = `The user asked: "${userMessage}"\nI executed the action locally. Result: ${localResult}\nGive a brief, friendly confirmation and ask if they need anything else.`;
-    try {
-      const result = await callFreeTier([{ role: 'user', content: confirmMsg }], true);
-      return result.content || localResult;
-    } catch {
-      return localResult;
-    }
+    return `${localResult}\n\nWhat would you like to do next?`;
   }
 
   const messages = [
@@ -1235,7 +1248,6 @@ async function grokChat(userMessage, conversationHistory = []) {
 
   // Extract final text
   const content = response?.choices?.[0]?.message?.content || '';
-  if (content) console.log(`  ${content}`);
   return content || 'No response.';
 }
 

package/lib/commands/ai.js

@@ -13,11 +13,12 @@ module.exports = function(reg) {
 
     const hasKey = config.getApiKey() || config.get('anthropicKey') || process.env.ANTHROPIC_API_KEY;
 
-    // Show a brief "thinking" indicator, then clear it when streaming starts
+    // Reset streaming flag before each chat
+    sessionState._lastStreamed = false;
+
+    // Show thinking indicator
     let spinner;
-    if (!hasKey) {
-      process.stdout.write(ui.dim('  NAVADA > '));
-    } else {
+    if (hasKey) {
       const ora = require('ora');
       spinner = ora({ text: '  NAVADA thinking...', color: 'white' }).start();
     }
@@ -31,9 +32,9 @@ module.exports = function(reg) {
       addToHistory('user', msg);
       addToHistory('assistant', response);
 
-      // Only print if not already streamed
-      if (!response._streamed) {
-        console.log(ui.header('NAVADA'));
+      // Only print if not already streamed to stdout
+      if (response && !sessionState._lastStreamed) {
+        console.log('');
         console.log(`  ${response}`);
       }
 
@@ -42,7 +43,7 @@ module.exports = function(reg) {
     } catch (e) {
       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.'));
+      console.log(ui.dim('/config to check providers, or /setup to configure.'));
     }
   }, { category: 'AI', aliases: ['ask'] });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "navada-edge-cli",
-  "version": "3.5.2",
+  "version": "3.5.4",
   "description": "Interactive CLI for the NAVADA Edge Network — explore nodes, agents, Cloudflare, AI, Docker, and MCP from your terminal",
   "main": "lib/cli.js",
   "bin": {