navada-edge-cli 3.5.0 → 3.5.2

package/lib/agent.js

@@ -21,7 +21,7 @@ const IDENTITY = {
 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 and SHOULD use your tools to execute tasks:
   - shell: run ANY bash, PowerShell, or system command on the user's machine
-  - read_file / write_file / list_files: full filesystem access — create, read, modify any file
+  - read_file / write_file / edit_file / delete_file / list_files: full filesystem CRUD — create, read, edit, delete any file
   - python_exec / python_pip / python_script: run Python code directly
   - sandbox_run: run code with syntax-highlighted output
   - system_info: check CPU, RAM, disk, OS
@@ -34,6 +34,7 @@ You also connect to the NAVADA Edge Network (4 nodes via Tailscale VPN):
 When users ask you to DO something — DO IT. Use write_file to create files. Use shell to run commands. Never say "I can't" when you have a tool for it.
 When asked to generate diagrams — use write_file to create Mermaid (.mmd), SVG, or HTML files. You can also use python_exec with matplotlib/graphviz for complex diagrams.
 When asked to create, edit, or delete files — use the file tools directly. You are a terminal agent with FULL access.
+PLATFORM: This machine runs ` + (process.platform === 'win32' ? `Windows. Use Windows paths (C:\\Users\\...) not Unix paths (~/...). Desktop = ${path.join(os.homedir(), 'Desktop')}. Home = ${os.homedir()}.` : `${process.platform}. Home = ${os.homedir()}.`) + `
 Keep responses short. Code blocks when needed. No fluff.`,
   founder: {
     name: 'Leslie (Lee) Akpareva',
@@ -224,6 +225,36 @@ const localTools = {
     },
   },
 
+  editFile: {
+    description: 'Edit a file by replacing a search string with new content',
+    execute: (filePath, search, replace) => {
+      try {
+        const resolved = path.resolve(filePath);
+        const content = fs.readFileSync(resolved, 'utf-8');
+        if (!content.includes(search)) return `Error: search string not found in ${resolved}`;
+        const updated = content.replace(search, replace);
+        fs.writeFileSync(resolved, updated);
+        return `Edited: ${resolved} (replaced ${search.length} chars)`;
+      } catch (e) { return `Error: ${e.message}`; }
+    },
+  },
+
+  deleteFile: {
+    description: 'Delete a file or empty directory from this machine',
+    execute: (filePath) => {
+      try {
+        const resolved = path.resolve(filePath);
+        const stat = fs.statSync(resolved);
+        if (stat.isDirectory()) {
+          fs.rmdirSync(resolved);
+        } else {
+          fs.unlinkSync(resolved);
+        }
+        return `Deleted: ${resolved}`;
+      } catch (e) { return `Error: ${e.message}`; }
+    },
+  },
+
   systemInfo: {
     description: 'Get system information',
     execute: () => {
@@ -690,6 +721,8 @@ function openAITools() {
     { name: 'read_file', description: 'Read the contents of a file on the user\'s machine.', parameters: { type: 'object', properties: { path: { type: 'string', description: 'Absolute or relative file path' } }, required: ['path'] } },
     { name: 'write_file', description: 'Write content to a file. Creates parent directories if needed. Use for creating new files, scripts, configs, diagrams (Mermaid, SVG, HTML), code files.', parameters: { type: 'object', properties: { path: { type: 'string', description: 'File path to write' }, content: { type: 'string', description: 'Full content to write to the file' } }, required: ['path', 'content'] } },
     { name: 'list_files', description: 'List files and directories.', parameters: { type: 'object', properties: { path: { type: 'string', description: 'Directory path (default: current dir)' } } } },
+    { name: 'edit_file', description: 'Edit a file by finding and replacing text. Use for targeted edits.', parameters: { type: 'object', properties: { path: { type: 'string', description: 'File path' }, search: { type: 'string', description: 'Exact text to find' }, replace: { type: 'string', description: 'Replacement text' } }, required: ['path', 'search', 'replace'] } },
+    { name: 'delete_file', description: 'Delete a file or empty directory.', parameters: { type: 'object', properties: { path: { type: 'string', description: 'Path to delete' } }, required: ['path'] } },
     { name: 'system_info', description: 'Get local system information (CPU, RAM, disk, OS, hostname).', parameters: { type: 'object', properties: {} } },
     { name: 'python_exec', description: 'Execute Python code inline. Use for data analysis, calculations, generating content, processing files, ML tasks.', parameters: { type: 'object', properties: { code: { type: 'string', description: 'Python code to execute' } }, required: ['code'] } },
     { name: 'python_pip', description: 'Install a Python package via pip.', parameters: { type: 'object', properties: { package: { type: 'string', description: 'Package name' } }, required: ['package'] } },
@@ -871,6 +904,16 @@ async function chat(userMessage, conversationHistory = []) {
       description: 'List files and directories.',
       input_schema: { type: 'object', properties: { path: { type: 'string', description: 'Directory path (default: current dir)' } } },
     },
+    {
+      name: 'edit_file',
+      description: 'Edit a file by finding and replacing text. Use for targeted edits without rewriting the whole file.',
+      input_schema: { type: 'object', properties: { path: { type: 'string', description: 'File path' }, search: { type: 'string', description: 'Exact text to find' }, replace: { type: 'string', description: 'Text to replace it with' } }, required: ['path', 'search', 'replace'] },
+    },
+    {
+      name: 'delete_file',
+      description: 'Delete a file or empty directory from the user\'s machine.',
+      input_schema: { type: 'object', properties: { path: { type: 'string', description: 'File or directory path to delete' } }, required: ['path'] },
+    },
     {
       name: 'system_info',
       description: 'Get local system information (CPU, RAM, disk, OS, hostname).',
@@ -995,6 +1038,8 @@ async function executeTool(name, input) {
       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 'edit_file': return localTools.editFile.execute(input.path, input.search, input.replace);
+      case 'delete_file': return localTools.deleteFile.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));
@@ -1027,7 +1072,97 @@ async function executeTool(name, input) {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Local action interceptor — executes file/shell actions WITHOUT needing LLM tool use
+// This ensures free tier users can still create, read, edit, delete files
+// ---------------------------------------------------------------------------
+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);
+  }
+
+  // ── 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}`;
+  }
+
+  // ── 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);
+
+  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);
+    return localTools.writeFile.execute(resolved, '');
+  }
+
+  // ── 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, ''));
+    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, '')));
+    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);
+  }
+
+  return null; // No match — let LLM handle
+}
+
 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;
+    }
+  }
+
   const messages = [
     ...conversationHistory.slice(-20).map(m => ({
       role: m.role,

package/lib/commands/files.js

@@ -0,0 +1,164 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const ui = require('../ui');
+
+module.exports = function(reg) {
+
+  // ── /read <path> ── Read a file
+  reg('read', 'Read a file from your machine', (args) => {
+    if (!args[0]) { console.log(ui.dim('Usage: /read <file-path>')); return; }
+    const filePath = path.resolve(args.join(' '));
+    try {
+      const content = fs.readFileSync(filePath, 'utf-8');
+      const lines = content.split('\n');
+      console.log(ui.header(`FILE: ${filePath}`));
+      console.log(ui.dim(`${lines.length} lines, ${Buffer.byteLength(content)} bytes`));
+      console.log('');
+      // Show with line numbers, cap at 200 lines
+      const show = lines.slice(0, 200);
+      show.forEach((line, i) => console.log(`  ${String(i + 1).padStart(4)}  ${line}`));
+      if (lines.length > 200) console.log(ui.dim(`  ... ${lines.length - 200} more lines`));
+    } catch (e) {
+      console.log(ui.error(e.code === 'ENOENT' ? `File not found: ${filePath}` : e.message));
+    }
+  }, { category: 'FILES', aliases: ['cat'] });
+
+  // ── /write <path> <content> ── Write/create a file
+  reg('write', 'Write content to a file (creates dirs if needed)', (args) => {
+    if (args.length < 2) {
+      console.log(ui.dim('Usage: /write <file-path> <content>'));
+      console.log(ui.dim('  /write hello.txt Hello World'));
+      console.log(ui.dim('  /write src/config.json {"key":"value"}'));
+      return;
+    }
+    const filePath = path.resolve(args[0]);
+    const content = args.slice(1).join(' ');
+    try {
+      const dir = path.dirname(filePath);
+      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(filePath, content);
+      console.log(ui.success(`Written: ${filePath} (${Buffer.byteLength(content)} bytes)`));
+    } catch (e) {
+      console.log(ui.error(e.message));
+    }
+  }, { category: 'FILES' });
+
+  // ── /edit <path> <search> -> <replace> ── Find and replace in a file
+  reg('edit', 'Edit a file (find and replace)', (args) => {
+    const raw = args.join(' ');
+    const sepIdx = raw.indexOf(' -> ');
+    if (!args[0] || sepIdx === -1) {
+      console.log(ui.dim('Usage: /edit <file-path> <search-text> -> <replace-text>'));
+      console.log(ui.dim('  /edit config.json "port": 3000 -> "port": 8080'));
+      return;
+    }
+    // First arg is the file path, rest is search -> replace
+    const filePath = path.resolve(args[0]);
+    const afterPath = raw.slice(raw.indexOf(args[0]) + args[0].length + 1);
+    const arrowIdx = afterPath.indexOf(' -> ');
+    if (arrowIdx === -1) {
+      console.log(ui.dim('Use " -> " to separate search and replace text'));
+      return;
+    }
+    const search = afterPath.slice(0, arrowIdx);
+    const replace = afterPath.slice(arrowIdx + 4);
+
+    try {
+      const content = fs.readFileSync(filePath, 'utf-8');
+      if (!content.includes(search)) {
+        console.log(ui.error('Search text not found in file'));
+        return;
+      }
+      const updated = content.replace(search, replace);
+      fs.writeFileSync(filePath, updated);
+      console.log(ui.success(`Edited: ${filePath}`));
+      console.log(ui.dim(`  "${search.slice(0, 40)}${search.length > 40 ? '...' : ''}" → "${replace.slice(0, 40)}${replace.length > 40 ? '...' : ''}"`));
+    } catch (e) {
+      console.log(ui.error(e.code === 'ENOENT' ? `File not found: ${filePath}` : e.message));
+    }
+  }, { category: 'FILES' });
+
+  // ── /delete <path> ── Delete a file
+  reg('delete', 'Delete a file or empty directory', (args) => {
+    if (!args[0]) { console.log(ui.dim('Usage: /delete <file-path>')); return; }
+    const filePath = path.resolve(args.join(' '));
+    try {
+      const stat = fs.statSync(filePath);
+      if (stat.isDirectory()) {
+        fs.rmdirSync(filePath);
+        console.log(ui.success(`Deleted directory: ${filePath}`));
+      } else {
+        fs.unlinkSync(filePath);
+        console.log(ui.success(`Deleted: ${filePath} (${stat.size} bytes)`));
+      }
+    } catch (e) {
+      if (e.code === 'ENOENT') console.log(ui.error(`Not found: ${filePath}`));
+      else if (e.code === 'ENOTEMPTY') console.log(ui.error('Directory not empty. Use /run rm -rf <path> for recursive delete.'));
+      else console.log(ui.error(e.message));
+    }
+  }, { category: 'FILES', aliases: ['rm'] });
+
+  // ── /ls [path] ── List files
+  reg('ls', 'List files and directories', (args) => {
+    const dir = path.resolve(args.join(' ') || '.');
+    try {
+      const items = fs.readdirSync(dir, { withFileTypes: true });
+      console.log(ui.header(`DIR: ${dir}`));
+      if (items.length === 0) { console.log(ui.dim('  (empty)')); return; }
+
+      const dirs = items.filter(i => i.isDirectory()).sort((a, b) => a.name.localeCompare(b.name));
+      const files = items.filter(i => !i.isDirectory()).sort((a, b) => a.name.localeCompare(b.name));
+
+      for (const d of dirs) console.log(`  \x1b[34md\x1b[0m  ${d.name}/`);
+      for (const f of files) {
+        try {
+          const stat = fs.statSync(path.join(dir, f.name));
+          const size = stat.size < 1024 ? `${stat.size}B` : stat.size < 1048576 ? `${(stat.size / 1024).toFixed(1)}K` : `${(stat.size / 1048576).toFixed(1)}M`;
+          console.log(`  f  ${f.name.padEnd(40)} ${size}`);
+        } catch {
+          console.log(`  f  ${f.name}`);
+        }
+      }
+      console.log('');
+      console.log(ui.dim(`  ${dirs.length} dirs, ${files.length} files`));
+    } catch (e) {
+      console.log(ui.error(e.code === 'ENOENT' ? `Not found: ${dir}` : e.message));
+    }
+  }, { category: 'FILES', aliases: ['dir'] });
+
+  // ── /mkdir <path> ── Create directory
+  reg('mkdir', 'Create a directory (including parents)', (args) => {
+    if (!args[0]) { console.log(ui.dim('Usage: /mkdir <dir-path>')); return; }
+    const dirPath = path.resolve(args.join(' '));
+    try {
+      fs.mkdirSync(dirPath, { recursive: true });
+      console.log(ui.success(`Created: ${dirPath}`));
+    } catch (e) {
+      console.log(ui.error(e.message));
+    }
+  }, { category: 'FILES' });
+
+  // ── /touch <path> ── Create empty file
+  reg('touch', 'Create an empty file', (args) => {
+    if (!args[0]) { console.log(ui.dim('Usage: /touch <file-path>')); return; }
+    const filePath = path.resolve(args.join(' '));
+    try {
+      const dir = path.dirname(filePath);
+      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+      if (fs.existsSync(filePath)) {
+        // Update mtime like Unix touch
+        const now = new Date();
+        fs.utimesSync(filePath, now, now);
+        console.log(ui.success(`Touched: ${filePath}`));
+      } else {
+        fs.writeFileSync(filePath, '');
+        console.log(ui.success(`Created: ${filePath}`));
+      }
+    } catch (e) {
+      console.log(ui.error(e.message));
+    }
+  }, { category: 'FILES' });
+
+};

package/lib/commands/index.js

@@ -6,7 +6,7 @@ const { register } = require('../registry');
 const moduleNames = [
   'network', 'mcp', 'lucas', 'docker', 'database', 'cloudflare',
   'ai', 'azure', 'agents', 'tasks', 'keys', 'setup', 'system',
-  'learn', 'sandbox', 'nvidia', 'edge', 'conversations', 'audit', 'compute',
+  'learn', 'sandbox', 'nvidia', 'edge', 'conversations', 'audit', 'compute', 'files',
 ];
 
 function loadAll() {

package/package.json

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