@nomad-e/bluma-cli 0.0.108 → 0.0.109

package/dist/main.js

@@ -1,8 +1,330 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/app/agent/tools/natives/async_command.ts
+var async_command_exports = {};
+__export(async_command_exports, {
+  commandStatus: () => commandStatus,
+  killCommand: () => killCommand,
+  runCommandAsync: () => runCommandAsync,
+  sendCommandInput: () => sendCommandInput
+});
+import os2 from "os";
+import { spawn } from "child_process";
+import { v4 as uuidv42 } from "uuid";
+function cleanupOldCommands() {
+  if (runningCommands.size <= MAX_STORED_COMMANDS) return;
+  const commands = Array.from(runningCommands.entries()).filter(([_, cmd]) => cmd.status !== "running").sort((a, b) => (a[1].endTime || 0) - (b[1].endTime || 0));
+  const toRemove = commands.slice(0, commands.length - MAX_STORED_COMMANDS + 10);
+  for (const [id] of toRemove) {
+    runningCommands.delete(id);
+  }
+}
+function isDangerousCommand(command) {
+  const trimmed = command.trim();
+  for (const pattern of DANGEROUS_PATTERNS) {
+    if (pattern.test(trimmed)) {
+      return "Command requires elevated privileges (sudo/doas) which cannot be handled in async mode";
+    }
+  }
+  for (const pattern of INTERACTIVE_PATTERNS) {
+    if (pattern.test(trimmed)) {
+      return "Interactive commands are not supported in async mode";
+    }
+  }
+  return null;
+}
+async function runCommandAsync(args) {
+  try {
+    const {
+      command,
+      cwd = process.cwd(),
+      timeout = 0
+    } = args;
+    if (!command || typeof command !== "string") {
+      return {
+        success: false,
+        error: "command is required and must be a string"
+      };
+    }
+    const dangerReason = isDangerousCommand(command);
+    if (dangerReason) {
+      return {
+        success: false,
+        error: dangerReason
+      };
+    }
+    const commandId = uuidv42().substring(0, 8);
+    const platform = os2.platform();
+    let shellCmd;
+    let shellArgs;
+    if (platform === "win32") {
+      shellCmd = process.env.COMSPEC || "cmd.exe";
+      shellArgs = ["/c", command];
+    } else {
+      shellCmd = process.env.SHELL || "/bin/bash";
+      shellArgs = ["-c", command];
+    }
+    const entry = {
+      id: commandId,
+      command,
+      status: "running",
+      stdout: "",
+      stderr: "",
+      exitCode: null,
+      startTime: Date.now(),
+      process: null
+    };
+    const child = spawn(shellCmd, shellArgs, {
+      cwd,
+      env: process.env,
+      windowsHide: true
+    });
+    entry.process = child;
+    let stdoutTruncated = false;
+    child.stdout?.on("data", (data) => {
+      if (!stdoutTruncated) {
+        entry.stdout += data.toString();
+        if (entry.stdout.length > MAX_OUTPUT_SIZE) {
+          entry.stdout = entry.stdout.substring(0, MAX_OUTPUT_SIZE) + OUTPUT_TRUNCATION_MSG;
+          stdoutTruncated = true;
+        }
+      }
+    });
+    let stderrTruncated = false;
+    child.stderr?.on("data", (data) => {
+      if (!stderrTruncated) {
+        entry.stderr += data.toString();
+        if (entry.stderr.length > MAX_OUTPUT_SIZE) {
+          entry.stderr = entry.stderr.substring(0, MAX_OUTPUT_SIZE) + OUTPUT_TRUNCATION_MSG;
+          stderrTruncated = true;
+        }
+      }
+    });
+    child.on("close", (code) => {
+      entry.exitCode = code;
+      entry.status = code === 0 ? "completed" : "error";
+      entry.endTime = Date.now();
+      entry.process = null;
+    });
+    child.on("error", (error) => {
+      entry.stderr += `
+Process error: ${error.message}`;
+      entry.status = "error";
+      entry.endTime = Date.now();
+      entry.process = null;
+    });
+    if (timeout > 0) {
+      setTimeout(() => {
+        if (entry.status === "running") {
+          child.kill("SIGTERM");
+          setTimeout(() => {
+            if (entry.status === "running") {
+              child.kill("SIGKILL");
+            }
+          }, 2e3);
+          entry.status = "timeout";
+          entry.stderr += `
+Command timed out after ${timeout} seconds`;
+        }
+      }, timeout * 1e3);
+    }
+    runningCommands.set(commandId, entry);
+    cleanupOldCommands();
+    return {
+      success: true,
+      command_id: commandId,
+      command,
+      message: `Command started in background. Use command_status with id "${commandId}" to check progress.`
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Unexpected error: ${error.message}`
+    };
+  }
+}
+async function commandStatus(args) {
+  try {
+    const {
+      command_id,
+      wait_seconds = 0,
+      output_limit = 1e4
+    } = args;
+    if (!command_id) {
+      return {
+        success: false,
+        command_id: "",
+        status: "error",
+        error: "command_id is required"
+      };
+    }
+    const entry = runningCommands.get(command_id);
+    if (!entry) {
+      return {
+        success: false,
+        command_id,
+        status: "not_found",
+        error: `Command with id "${command_id}" not found. It may have expired or never existed.`
+      };
+    }
+    if (wait_seconds > 0 && entry.status === "running") {
+      await new Promise((resolve) => {
+        const checkInterval = setInterval(() => {
+          if (entry.status !== "running") {
+            clearInterval(checkInterval);
+            resolve();
+          }
+        }, 100);
+        setTimeout(() => {
+          clearInterval(checkInterval);
+          resolve();
+        }, wait_seconds * 1e3);
+      });
+    }
+    let stdout = entry.stdout;
+    let stderr = entry.stderr;
+    let truncated = false;
+    if (stdout.length > output_limit) {
+      stdout = "..." + stdout.substring(stdout.length - output_limit);
+      truncated = true;
+    }
+    if (stderr.length > output_limit) {
+      stderr = "..." + stderr.substring(stderr.length - output_limit);
+      truncated = true;
+    }
+    const duration = entry.endTime ? (entry.endTime - entry.startTime) / 1e3 : (Date.now() - entry.startTime) / 1e3;
+    return {
+      success: true,
+      command_id,
+      status: entry.status,
+      stdout: stdout || void 0,
+      stderr: stderr || void 0,
+      exit_code: entry.exitCode,
+      duration_seconds: Math.round(duration * 10) / 10,
+      truncated
+    };
+  } catch (error) {
+    return {
+      success: false,
+      command_id: args.command_id || "",
+      status: "error",
+      error: `Unexpected error: ${error.message}`
+    };
+  }
+}
+async function sendCommandInput(args) {
+  try {
+    const { command_id, input } = args;
+    if (!command_id || input === void 0) {
+      return {
+        success: false,
+        error: "command_id and input are required"
+      };
+    }
+    const entry = runningCommands.get(command_id);
+    if (!entry) {
+      return {
+        success: false,
+        error: `Command with id "${command_id}" not found`
+      };
+    }
+    if (entry.status !== "running" || !entry.process) {
+      return {
+        success: false,
+        error: `Command is not running (status: ${entry.status})`
+      };
+    }
+    entry.process.stdin?.write(input);
+    return {
+      success: true,
+      message: `Sent ${input.length} characters to command ${command_id}`
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Failed to send input: ${error.message}`
+    };
+  }
+}
+async function killCommand(args) {
+  try {
+    const { command_id } = args;
+    const entry = runningCommands.get(command_id);
+    if (!entry) {
+      return {
+        success: false,
+        error: `Command with id "${command_id}" not found`
+      };
+    }
+    if (entry.status !== "running" || !entry.process) {
+      return {
+        success: false,
+        error: `Command is not running (status: ${entry.status})`
+      };
+    }
+    entry.process.kill("SIGTERM");
+    entry.status = "killed";
+    entry.endTime = Date.now();
+    return {
+      success: true,
+      message: `Command ${command_id} killed`
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Failed to kill command: ${error.message}`
+    };
+  }
+}
+var runningCommands, MAX_OUTPUT_SIZE, MAX_STORED_COMMANDS, OUTPUT_TRUNCATION_MSG, DANGEROUS_PATTERNS, INTERACTIVE_PATTERNS;
+var init_async_command = __esm({
+  "src/app/agent/tools/natives/async_command.ts"() {
+    "use strict";
+    runningCommands = /* @__PURE__ */ new Map();
+    MAX_OUTPUT_SIZE = 3e4;
+    MAX_STORED_COMMANDS = 50;
+    OUTPUT_TRUNCATION_MSG = "\n[OUTPUT TRUNCATED - 30KB/200 lines max]";
+    DANGEROUS_PATTERNS = [
+      // Elevação de privilégios
+      /^sudo\s+/i,
+      /^doas\s+/i,
+      /^su\s+/i,
+      /^pkexec\s+/i,
+      /\|\s*sudo\s+/i,
+      /;\s*sudo\s+/i,
+      /&&\s*sudo\s+/i,
+      // Comandos destrutivos
+      /\brm\s+(-[rf]+\s+)*[\/~]/i,
+      /\brm\s+-[rf]*\s+\*/i,
+      /\bchmod\s+(777|666)\s+\//i,
+      /\bdd\s+.*of=\/dev\/(sd|hd|nvme)/i,
+      /\bmkfs\./i,
+      // Fork bombs
+      /:\(\)\s*\{\s*:\|:&\s*\}\s*;:/,
+      // Remote code exec
+      /\bcurl\s+.*\|\s*(ba)?sh/i,
+      /\bwget\s+.*\|\s*(ba)?sh/i
+    ];
+    INTERACTIVE_PATTERNS = [
+      /^(vim|vi|nano|emacs|pico)\s*/i,
+      /^(less|more|most)\s*/i,
+      /^(top|htop|btop|atop|nmon)\s*/i,
+      /^(ssh|telnet|ftp|sftp)\s+/i,
+      /^(mysql|psql|redis-cli|mongo|mongosh)\s*$/i,
+      /^(python|python3|node|ruby|irb|lua)\s*$/i,
+      /^(gdb|lldb)\s*/i
+    ];
+  }
+});
 
 // src/app/agent/core/llm/tool_call_normalizer.ts
 import { randomUUID } from "crypto";
@@ -2476,587 +2798,286 @@ async function grepSearch(args) {
       searchStats.filesSearched = 1;
       const found = await searchFile(resolvedPath, path7.dirname(resolvedPath), pattern, context_lines, matches, max_results);
       if (found > 0) searchStats.filesWithMatches = 1;
-    }
-    return {
-      success: true,
-      query,
-      search_path: resolvedPath,
-      matches,
-      files_searched: searchStats.filesSearched,
-      files_with_matches: searchStats.filesWithMatches,
-      total_matches: matches.length,
-      truncated: matches.length >= max_results
-    };
-  } catch (error) {
-    return {
-      success: false,
-      query: args.query || "",
-      search_path: args.path || "",
-      matches: [],
-      files_searched: 0,
-      files_with_matches: 0,
-      total_matches: 0,
-      truncated: false,
-      error: `Unexpected error: ${error.message}`
-    };
-  }
-}
-
-// src/app/agent/tools/natives/view_file_outline.ts
-import path8 from "path";
-import { promises as fsPromises3 } from "fs";
-var LANGUAGE_MAP = {
-  ".ts": "typescript",
-  ".tsx": "typescript",
-  ".js": "javascript",
-  ".jsx": "javascript",
-  ".mjs": "javascript",
-  ".cjs": "javascript",
-  ".py": "python",
-  ".java": "java",
-  ".go": "go",
-  ".rs": "rust",
-  ".rb": "ruby",
-  ".php": "php",
-  ".cs": "csharp",
-  ".cpp": "cpp",
-  ".c": "c",
-  ".h": "c",
-  ".hpp": "cpp",
-  ".swift": "swift",
-  ".kt": "kotlin",
-  ".scala": "scala"
-};
-var PATTERNS = {
-  typescript: [
-    // Classes
-    /^(?:export\s+)?(?:abstract\s+)?class\s+(\w+)(?:\s+extends\s+\w+)?(?:\s+implements\s+[\w,\s]+)?/,
-    // Interfaces
-    /^(?:export\s+)?interface\s+(\w+)/,
-    // Types
-    /^(?:export\s+)?type\s+(\w+)/,
-    // Functions (standalone)
-    /^(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(/,
-    // Arrow functions assigned to const/let
-    /^(?:export\s+)?(?:const|let)\s+(\w+)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[^=])\s*=>/,
-    // Methods inside classes (indented)
-    /^\s+(?:public|private|protected|static|async|readonly|\s)*(\w+)\s*\([^)]*\)\s*(?::\s*[\w<>\[\]|&\s]+)?\s*\{/,
-    // Const exports
-    /^(?:export\s+)?const\s+(\w+)\s*[:=]/
-  ],
-  javascript: [
-    /^(?:export\s+)?(?:default\s+)?class\s+(\w+)/,
-    /^(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(/,
-    /^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[^=])\s*=>/,
-    /^\s+(?:async\s+)?(\w+)\s*\([^)]*\)\s*\{/,
-    /^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=/
-  ],
-  python: [
-    /^class\s+(\w+)(?:\([^)]*\))?:/,
-    /^(?:async\s+)?def\s+(\w+)\s*\(/,
-    /^(\w+)\s*=\s*(?:lambda|def)/
-  ],
-  java: [
-    /^(?:public|private|protected)?\s*(?:static)?\s*(?:final)?\s*(?:abstract)?\s*class\s+(\w+)/,
-    /^(?:public|private|protected)?\s*(?:static)?\s*(?:final)?\s*interface\s+(\w+)/,
-    /^\s*(?:public|private|protected)?\s*(?:static)?\s*(?:final)?\s*(?:synchronized)?\s*(?:\w+(?:<[^>]+>)?)\s+(\w+)\s*\(/
-  ],
-  go: [
-    /^type\s+(\w+)\s+struct\s*\{/,
-    /^type\s+(\w+)\s+interface\s*\{/,
-    /^func\s+(?:\([^)]+\)\s+)?(\w+)\s*\(/
-  ],
-  rust: [
-    /^(?:pub\s+)?struct\s+(\w+)/,
-    /^(?:pub\s+)?enum\s+(\w+)/,
-    /^(?:pub\s+)?trait\s+(\w+)/,
-    /^(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/,
-    /^impl(?:<[^>]+>)?\s+(?:(\w+)|for\s+(\w+))/
-  ],
-  ruby: [
-    /^class\s+(\w+)/,
-    /^module\s+(\w+)/,
-    /^def\s+(\w+)/
-  ],
-  php: [
-    /^(?:abstract\s+)?class\s+(\w+)/,
-    /^interface\s+(\w+)/,
-    /^(?:public|private|protected)?\s*(?:static)?\s*function\s+(\w+)/
-  ],
-  csharp: [
-    /^(?:public|private|protected|internal)?\s*(?:static)?\s*(?:partial)?\s*class\s+(\w+)/,
-    /^(?:public|private|protected|internal)?\s*interface\s+(\w+)/,
-    /^\s*(?:public|private|protected|internal)?\s*(?:static)?\s*(?:async)?\s*(?:\w+(?:<[^>]+>)?)\s+(\w+)\s*\(/
-  ],
-  swift: [
-    /^(?:public|private|internal|open)?\s*class\s+(\w+)/,
-    /^(?:public|private|internal)?\s*struct\s+(\w+)/,
-    /^(?:public|private|internal)?\s*protocol\s+(\w+)/,
-    /^(?:public|private|internal)?\s*(?:static)?\s*func\s+(\w+)/
-  ],
-  kotlin: [
-    /^(?:open|abstract|sealed)?\s*class\s+(\w+)/,
-    /^interface\s+(\w+)/,
-    /^(?:private|public|internal)?\s*fun\s+(\w+)/
-  ],
-  scala: [
-    /^(?:sealed\s+)?(?:abstract\s+)?class\s+(\w+)/,
-    /^object\s+(\w+)/,
-    /^trait\s+(\w+)/,
-    /^def\s+(\w+)/
-  ],
-  c: [
-    /^(?:static\s+)?(?:inline\s+)?(?:const\s+)?(?:\w+(?:\s*\*)*)\s+(\w+)\s*\([^)]*\)\s*\{/,
-    /^typedef\s+struct\s*\w*\s*\{[^}]*\}\s*(\w+)/,
-    /^struct\s+(\w+)\s*\{/
-  ],
-  cpp: [
-    /^class\s+(\w+)/,
-    /^(?:virtual\s+)?(?:\w+(?:\s*[*&])*)\s+(\w+)\s*\([^)]*\)\s*(?:const)?\s*(?:override)?\s*\{/,
-    /^namespace\s+(\w+)\s*\{/
-  ]
-};
-function detectLanguage(filepath) {
-  const ext = path8.extname(filepath).toLowerCase();
-  return LANGUAGE_MAP[ext] || "unknown";
-}
-function determineItemType(line, language) {
-  const normalizedLine = line.trim().toLowerCase();
-  if (normalizedLine.includes("class ")) return "class";
-  if (normalizedLine.includes("interface ")) return "interface";
-  if (normalizedLine.includes("type ")) return "type";
-  if (normalizedLine.startsWith("import ")) return "import";
-  if (normalizedLine.includes("export ") && !normalizedLine.includes("function") && !normalizedLine.includes("class")) return "export";
-  if (line.startsWith("  ") || line.startsWith("	")) {
-    if (normalizedLine.includes("function") || normalizedLine.includes("def ") || normalizedLine.includes("fn ") || normalizedLine.includes("func ")) {
-      return "method";
-    }
-    if (/^\s+\w+\s*\(/.test(line)) return "method";
-  }
-  if (normalizedLine.includes("function ") || normalizedLine.includes("def ") || normalizedLine.includes("fn ") || normalizedLine.includes("func ")) {
-    return "function";
-  }
-  if (normalizedLine.includes("const ") || normalizedLine.includes("let ") || normalizedLine.includes("var ")) {
-    return normalizedLine.includes("=>") ? "function" : "const";
-  }
-  return "function";
-}
-async function extractOutline(filepath, content, language) {
-  const items = [];
-  const lines = content.split("\n");
-  const patterns = PATTERNS[language] || PATTERNS.javascript;
-  let currentClass = null;
-  let braceCount = 0;
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    const lineNumber = i + 1;
-    const openBraces = (line.match(/\{/g) || []).length;
-    const closeBraces = (line.match(/\}/g) || []).length;
-    braceCount += openBraces - closeBraces;
-    if (braceCount <= 0 && currentClass) {
-      currentClass = null;
-    }
-    for (const pattern of patterns) {
-      const match = line.match(pattern);
-      if (match) {
-        const name = match[1] || match[2];
-        if (!name) continue;
-        const itemType = determineItemType(line, language);
-        if (!itemType) continue;
-        const exported = line.includes("export ");
-        const isInsideClass = currentClass && (line.startsWith("  ") || line.startsWith("	"));
-        const item = {
-          type: itemType,
-          name,
-          line_start: lineNumber,
-          signature: line.trim().substring(0, 120),
-          exported
-        };
-        if (isInsideClass && itemType === "method" && currentClass) {
-          item.parent = currentClass;
-        }
-        if (itemType === "class") {
-          currentClass = name;
-        }
-        items.push(item);
-        break;
-      }
-    }
-  }
-  return items;
-}
-function generateSummary(items, totalLines) {
-  const counts = {};
-  for (const item of items) {
-    counts[item.type] = (counts[item.type] || 0) + 1;
-  }
-  const parts = [`${totalLines} lines`];
-  if (counts.class) parts.push(`${counts.class} class${counts.class > 1 ? "es" : ""}`);
-  if (counts.interface) parts.push(`${counts.interface} interface${counts.interface > 1 ? "s" : ""}`);
-  if (counts.function) parts.push(`${counts.function} function${counts.function > 1 ? "s" : ""}`);
-  if (counts.method) parts.push(`${counts.method} method${counts.method > 1 ? "s" : ""}`);
-  if (counts.type) parts.push(`${counts.type} type${counts.type > 1 ? "s" : ""}`);
-  if (counts.const) parts.push(`${counts.const} const${counts.const > 1 ? "s" : ""}`);
-  return parts.join(", ");
-}
-async function viewFileOutline(args) {
-  try {
-    const { file_path } = args;
-    if (!file_path || typeof file_path !== "string") {
-      return {
-        success: false,
-        file_path: file_path || "",
-        language: "unknown",
-        total_lines: 0,
-        items: [],
-        summary: "",
-        error: "file_path is required and must be a string"
-      };
-    }
-    const resolvedPath = path8.resolve(file_path);
-    let content;
-    try {
-      content = await fsPromises3.readFile(resolvedPath, "utf-8");
-    } catch (error) {
-      return {
-        success: false,
-        file_path: resolvedPath,
-        language: "unknown",
-        total_lines: 0,
-        items: [],
-        summary: "",
-        error: error.code === "ENOENT" ? `File not found: ${resolvedPath}` : `Error reading file: ${error.message}`
-      };
-    }
-    const language = detectLanguage(resolvedPath);
-    const lines = content.split("\n");
-    const totalLines = lines.length;
-    const items = await extractOutline(resolvedPath, content, language);
+    }
     return {
       success: true,
-      file_path: resolvedPath,
-      language,
-      total_lines: totalLines,
-      items,
-      summary: generateSummary(items, totalLines)
+      query,
+      search_path: resolvedPath,
+      matches,
+      files_searched: searchStats.filesSearched,
+      files_with_matches: searchStats.filesWithMatches,
+      total_matches: matches.length,
+      truncated: matches.length >= max_results
     };
   } catch (error) {
     return {
       success: false,
-      file_path: args.file_path || "",
-      language: "unknown",
-      total_lines: 0,
-      items: [],
-      summary: "",
+      query: args.query || "",
+      search_path: args.path || "",
+      matches: [],
+      files_searched: 0,
+      files_with_matches: 0,
+      total_matches: 0,
+      truncated: false,
       error: `Unexpected error: ${error.message}`
     };
   }
 }
 
-// src/app/agent/tools/natives/async_command.ts
-import os2 from "os";
-import { spawn } from "child_process";
-import { v4 as uuidv42 } from "uuid";
-var runningCommands = /* @__PURE__ */ new Map();
-var MAX_OUTPUT_SIZE = 3e4;
-var MAX_STORED_COMMANDS = 50;
-var OUTPUT_TRUNCATION_MSG = "\n[OUTPUT TRUNCATED - 30KB/200 lines max]";
-var DANGEROUS_PATTERNS = [
-  // Elevação de privilégios
-  /^sudo\s+/i,
-  /^doas\s+/i,
-  /^su\s+/i,
-  /^pkexec\s+/i,
-  /\|\s*sudo\s+/i,
-  /;\s*sudo\s+/i,
-  /&&\s*sudo\s+/i,
-  // Comandos destrutivos
-  /\brm\s+(-[rf]+\s+)*[\/~]/i,
-  /\brm\s+-[rf]*\s+\*/i,
-  /\bchmod\s+(777|666)\s+\//i,
-  /\bdd\s+.*of=\/dev\/(sd|hd|nvme)/i,
-  /\bmkfs\./i,
-  // Fork bombs
-  /:\(\)\s*\{\s*:\|:&\s*\}\s*;:/,
-  // Remote code exec
-  /\bcurl\s+.*\|\s*(ba)?sh/i,
-  /\bwget\s+.*\|\s*(ba)?sh/i
-];
-var INTERACTIVE_PATTERNS = [
-  /^(vim|vi|nano|emacs|pico)\s*/i,
-  /^(less|more|most)\s*/i,
-  /^(top|htop|btop|atop|nmon)\s*/i,
-  /^(ssh|telnet|ftp|sftp)\s+/i,
-  /^(mysql|psql|redis-cli|mongo|mongosh)\s*$/i,
-  /^(python|python3|node|ruby|irb|lua)\s*$/i,
-  /^(gdb|lldb)\s*/i
-];
-function cleanupOldCommands() {
-  if (runningCommands.size <= MAX_STORED_COMMANDS) return;
-  const commands = Array.from(runningCommands.entries()).filter(([_, cmd]) => cmd.status !== "running").sort((a, b) => (a[1].endTime || 0) - (b[1].endTime || 0));
-  const toRemove = commands.slice(0, commands.length - MAX_STORED_COMMANDS + 10);
-  for (const [id] of toRemove) {
-    runningCommands.delete(id);
-  }
-}
-function isDangerousCommand(command) {
-  const trimmed = command.trim();
-  for (const pattern of DANGEROUS_PATTERNS) {
-    if (pattern.test(trimmed)) {
-      return "Command requires elevated privileges (sudo/doas) which cannot be handled in async mode";
-    }
-  }
-  for (const pattern of INTERACTIVE_PATTERNS) {
-    if (pattern.test(trimmed)) {
-      return "Interactive commands are not supported in async mode";
-    }
-  }
-  return null;
-}
-async function runCommandAsync(args) {
-  try {
-    const {
-      command,
-      cwd = process.cwd(),
-      timeout = 0
-    } = args;
-    if (!command || typeof command !== "string") {
-      return {
-        success: false,
-        error: "command is required and must be a string"
-      };
-    }
-    const dangerReason = isDangerousCommand(command);
-    if (dangerReason) {
-      return {
-        success: false,
-        error: dangerReason
-      };
-    }
-    const commandId = uuidv42().substring(0, 8);
-    const platform = os2.platform();
-    let shellCmd;
-    let shellArgs;
-    if (platform === "win32") {
-      shellCmd = process.env.COMSPEC || "cmd.exe";
-      shellArgs = ["/c", command];
-    } else {
-      shellCmd = process.env.SHELL || "/bin/bash";
-      shellArgs = ["-c", command];
-    }
-    const entry = {
-      id: commandId,
-      command,
-      status: "running",
-      stdout: "",
-      stderr: "",
-      exitCode: null,
-      startTime: Date.now(),
-      process: null
-    };
-    const child = spawn(shellCmd, shellArgs, {
-      cwd,
-      env: process.env,
-      windowsHide: true
-    });
-    entry.process = child;
-    let stdoutTruncated = false;
-    child.stdout?.on("data", (data) => {
-      if (!stdoutTruncated) {
-        entry.stdout += data.toString();
-        if (entry.stdout.length > MAX_OUTPUT_SIZE) {
-          entry.stdout = entry.stdout.substring(0, MAX_OUTPUT_SIZE) + OUTPUT_TRUNCATION_MSG;
-          stdoutTruncated = true;
-        }
-      }
-    });
-    let stderrTruncated = false;
-    child.stderr?.on("data", (data) => {
-      if (!stderrTruncated) {
-        entry.stderr += data.toString();
-        if (entry.stderr.length > MAX_OUTPUT_SIZE) {
-          entry.stderr = entry.stderr.substring(0, MAX_OUTPUT_SIZE) + OUTPUT_TRUNCATION_MSG;
-          stderrTruncated = true;
-        }
-      }
-    });
-    child.on("close", (code) => {
-      entry.exitCode = code;
-      entry.status = code === 0 ? "completed" : "error";
-      entry.endTime = Date.now();
-      entry.process = null;
-    });
-    child.on("error", (error) => {
-      entry.stderr += `
-Process error: ${error.message}`;
-      entry.status = "error";
-      entry.endTime = Date.now();
-      entry.process = null;
-    });
-    if (timeout > 0) {
-      setTimeout(() => {
-        if (entry.status === "running") {
-          child.kill("SIGTERM");
-          setTimeout(() => {
-            if (entry.status === "running") {
-              child.kill("SIGKILL");
-            }
-          }, 2e3);
-          entry.status = "timeout";
-          entry.stderr += `
-Command timed out after ${timeout} seconds`;
-        }
-      }, timeout * 1e3);
+// src/app/agent/tools/natives/view_file_outline.ts
+import path8 from "path";
+import { promises as fsPromises3 } from "fs";
+var LANGUAGE_MAP = {
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".py": "python",
+  ".java": "java",
+  ".go": "go",
+  ".rs": "rust",
+  ".rb": "ruby",
+  ".php": "php",
+  ".cs": "csharp",
+  ".cpp": "cpp",
+  ".c": "c",
+  ".h": "c",
+  ".hpp": "cpp",
+  ".swift": "swift",
+  ".kt": "kotlin",
+  ".scala": "scala"
+};
+var PATTERNS = {
+  typescript: [
+    // Classes
+    /^(?:export\s+)?(?:abstract\s+)?class\s+(\w+)(?:\s+extends\s+\w+)?(?:\s+implements\s+[\w,\s]+)?/,
+    // Interfaces
+    /^(?:export\s+)?interface\s+(\w+)/,
+    // Types
+    /^(?:export\s+)?type\s+(\w+)/,
+    // Functions (standalone)
+    /^(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(/,
+    // Arrow functions assigned to const/let
+    /^(?:export\s+)?(?:const|let)\s+(\w+)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[^=])\s*=>/,
+    // Methods inside classes (indented)
+    /^\s+(?:public|private|protected|static|async|readonly|\s)*(\w+)\s*\([^)]*\)\s*(?::\s*[\w<>\[\]|&\s]+)?\s*\{/,
+    // Const exports
+    /^(?:export\s+)?const\s+(\w+)\s*[:=]/
+  ],
+  javascript: [
+    /^(?:export\s+)?(?:default\s+)?class\s+(\w+)/,
+    /^(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(/,
+    /^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[^=])\s*=>/,
+    /^\s+(?:async\s+)?(\w+)\s*\([^)]*\)\s*\{/,
+    /^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=/
+  ],
+  python: [
+    /^class\s+(\w+)(?:\([^)]*\))?:/,
+    /^(?:async\s+)?def\s+(\w+)\s*\(/,
+    /^(\w+)\s*=\s*(?:lambda|def)/
+  ],
+  java: [
+    /^(?:public|private|protected)?\s*(?:static)?\s*(?:final)?\s*(?:abstract)?\s*class\s+(\w+)/,
+    /^(?:public|private|protected)?\s*(?:static)?\s*(?:final)?\s*interface\s+(\w+)/,
+    /^\s*(?:public|private|protected)?\s*(?:static)?\s*(?:final)?\s*(?:synchronized)?\s*(?:\w+(?:<[^>]+>)?)\s+(\w+)\s*\(/
+  ],
+  go: [
+    /^type\s+(\w+)\s+struct\s*\{/,
+    /^type\s+(\w+)\s+interface\s*\{/,
+    /^func\s+(?:\([^)]+\)\s+)?(\w+)\s*\(/
+  ],
+  rust: [
+    /^(?:pub\s+)?struct\s+(\w+)/,
+    /^(?:pub\s+)?enum\s+(\w+)/,
+    /^(?:pub\s+)?trait\s+(\w+)/,
+    /^(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/,
+    /^impl(?:<[^>]+>)?\s+(?:(\w+)|for\s+(\w+))/
+  ],
+  ruby: [
+    /^class\s+(\w+)/,
+    /^module\s+(\w+)/,
+    /^def\s+(\w+)/
+  ],
+  php: [
+    /^(?:abstract\s+)?class\s+(\w+)/,
+    /^interface\s+(\w+)/,
+    /^(?:public|private|protected)?\s*(?:static)?\s*function\s+(\w+)/
+  ],
+  csharp: [
+    /^(?:public|private|protected|internal)?\s*(?:static)?\s*(?:partial)?\s*class\s+(\w+)/,
+    /^(?:public|private|protected|internal)?\s*interface\s+(\w+)/,
+    /^\s*(?:public|private|protected|internal)?\s*(?:static)?\s*(?:async)?\s*(?:\w+(?:<[^>]+>)?)\s+(\w+)\s*\(/
+  ],
+  swift: [
+    /^(?:public|private|internal|open)?\s*class\s+(\w+)/,
+    /^(?:public|private|internal)?\s*struct\s+(\w+)/,
+    /^(?:public|private|internal)?\s*protocol\s+(\w+)/,
+    /^(?:public|private|internal)?\s*(?:static)?\s*func\s+(\w+)/
+  ],
+  kotlin: [
+    /^(?:open|abstract|sealed)?\s*class\s+(\w+)/,
+    /^interface\s+(\w+)/,
+    /^(?:private|public|internal)?\s*fun\s+(\w+)/
+  ],
+  scala: [
+    /^(?:sealed\s+)?(?:abstract\s+)?class\s+(\w+)/,
+    /^object\s+(\w+)/,
+    /^trait\s+(\w+)/,
+    /^def\s+(\w+)/
+  ],
+  c: [
+    /^(?:static\s+)?(?:inline\s+)?(?:const\s+)?(?:\w+(?:\s*\*)*)\s+(\w+)\s*\([^)]*\)\s*\{/,
+    /^typedef\s+struct\s*\w*\s*\{[^}]*\}\s*(\w+)/,
+    /^struct\s+(\w+)\s*\{/
+  ],
+  cpp: [
+    /^class\s+(\w+)/,
+    /^(?:virtual\s+)?(?:\w+(?:\s*[*&])*)\s+(\w+)\s*\([^)]*\)\s*(?:const)?\s*(?:override)?\s*\{/,
+    /^namespace\s+(\w+)\s*\{/
+  ]
+};
+function detectLanguage(filepath) {
+  const ext = path8.extname(filepath).toLowerCase();
+  return LANGUAGE_MAP[ext] || "unknown";
+}
+function determineItemType(line, language) {
+  const normalizedLine = line.trim().toLowerCase();
+  if (normalizedLine.includes("class ")) return "class";
+  if (normalizedLine.includes("interface ")) return "interface";
+  if (normalizedLine.includes("type ")) return "type";
+  if (normalizedLine.startsWith("import ")) return "import";
+  if (normalizedLine.includes("export ") && !normalizedLine.includes("function") && !normalizedLine.includes("class")) return "export";
+  if (line.startsWith("  ") || line.startsWith("	")) {
+    if (normalizedLine.includes("function") || normalizedLine.includes("def ") || normalizedLine.includes("fn ") || normalizedLine.includes("func ")) {
+      return "method";
     }
-    runningCommands.set(commandId, entry);
-    cleanupOldCommands();
-    return {
-      success: true,
-      command_id: commandId,
-      command,
-      message: `Command started in background. Use command_status with id "${commandId}" to check progress.`
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: `Unexpected error: ${error.message}`
-    };
+    if (/^\s+\w+\s*\(/.test(line)) return "method";
+  }
+  if (normalizedLine.includes("function ") || normalizedLine.includes("def ") || normalizedLine.includes("fn ") || normalizedLine.includes("func ")) {
+    return "function";
   }
+  if (normalizedLine.includes("const ") || normalizedLine.includes("let ") || normalizedLine.includes("var ")) {
+    return normalizedLine.includes("=>") ? "function" : "const";
+  }
+  return "function";
 }
-async function commandStatus(args) {
-  try {
-    const {
-      command_id,
-      wait_seconds = 0,
-      output_limit = 1e4
-    } = args;
-    if (!command_id) {
-      return {
-        success: false,
-        command_id: "",
-        status: "error",
-        error: "command_id is required"
-      };
-    }
-    const entry = runningCommands.get(command_id);
-    if (!entry) {
-      return {
-        success: false,
-        command_id,
-        status: "not_found",
-        error: `Command with id "${command_id}" not found. It may have expired or never existed.`
-      };
-    }
-    if (wait_seconds > 0 && entry.status === "running") {
-      await new Promise((resolve) => {
-        const checkInterval = setInterval(() => {
-          if (entry.status !== "running") {
-            clearInterval(checkInterval);
-            resolve();
-          }
-        }, 100);
-        setTimeout(() => {
-          clearInterval(checkInterval);
-          resolve();
-        }, wait_seconds * 1e3);
-      });
-    }
-    let stdout = entry.stdout;
-    let stderr = entry.stderr;
-    let truncated = false;
-    if (stdout.length > output_limit) {
-      stdout = "..." + stdout.substring(stdout.length - output_limit);
-      truncated = true;
+async function extractOutline(filepath, content, language) {
+  const items = [];
+  const lines = content.split("\n");
+  const patterns = PATTERNS[language] || PATTERNS.javascript;
+  let currentClass = null;
+  let braceCount = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNumber = i + 1;
+    const openBraces = (line.match(/\{/g) || []).length;
+    const closeBraces = (line.match(/\}/g) || []).length;
+    braceCount += openBraces - closeBraces;
+    if (braceCount <= 0 && currentClass) {
+      currentClass = null;
     }
-    if (stderr.length > output_limit) {
-      stderr = "..." + stderr.substring(stderr.length - output_limit);
-      truncated = true;
+    for (const pattern of patterns) {
+      const match = line.match(pattern);
+      if (match) {
+        const name = match[1] || match[2];
+        if (!name) continue;
+        const itemType = determineItemType(line, language);
+        if (!itemType) continue;
+        const exported = line.includes("export ");
+        const isInsideClass = currentClass && (line.startsWith("  ") || line.startsWith("	"));
+        const item = {
+          type: itemType,
+          name,
+          line_start: lineNumber,
+          signature: line.trim().substring(0, 120),
+          exported
+        };
+        if (isInsideClass && itemType === "method" && currentClass) {
+          item.parent = currentClass;
+        }
+        if (itemType === "class") {
+          currentClass = name;
+        }
+        items.push(item);
+        break;
+      }
     }
-    const duration = entry.endTime ? (entry.endTime - entry.startTime) / 1e3 : (Date.now() - entry.startTime) / 1e3;
-    return {
-      success: true,
-      command_id,
-      status: entry.status,
-      stdout: stdout || void 0,
-      stderr: stderr || void 0,
-      exit_code: entry.exitCode,
-      duration_seconds: Math.round(duration * 10) / 10,
-      truncated
-    };
-  } catch (error) {
-    return {
-      success: false,
-      command_id: args.command_id || "",
-      status: "error",
-      error: `Unexpected error: ${error.message}`
-    };
   }
+  return items;
 }
-async function sendCommandInput(args) {
-  try {
-    const { command_id, input } = args;
-    if (!command_id || input === void 0) {
-      return {
-        success: false,
-        error: "command_id and input are required"
-      };
-    }
-    const entry = runningCommands.get(command_id);
-    if (!entry) {
-      return {
-        success: false,
-        error: `Command with id "${command_id}" not found`
-      };
-    }
-    if (entry.status !== "running" || !entry.process) {
-      return {
-        success: false,
-        error: `Command is not running (status: ${entry.status})`
-      };
-    }
-    entry.process.stdin?.write(input);
-    return {
-      success: true,
-      message: `Sent ${input.length} characters to command ${command_id}`
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: `Failed to send input: ${error.message}`
-    };
+function generateSummary(items, totalLines) {
+  const counts = {};
+  for (const item of items) {
+    counts[item.type] = (counts[item.type] || 0) + 1;
   }
+  const parts = [`${totalLines} lines`];
+  if (counts.class) parts.push(`${counts.class} class${counts.class > 1 ? "es" : ""}`);
+  if (counts.interface) parts.push(`${counts.interface} interface${counts.interface > 1 ? "s" : ""}`);
+  if (counts.function) parts.push(`${counts.function} function${counts.function > 1 ? "s" : ""}`);
+  if (counts.method) parts.push(`${counts.method} method${counts.method > 1 ? "s" : ""}`);
+  if (counts.type) parts.push(`${counts.type} type${counts.type > 1 ? "s" : ""}`);
+  if (counts.const) parts.push(`${counts.const} const${counts.const > 1 ? "s" : ""}`);
+  return parts.join(", ");
 }
-async function killCommand(args) {
+async function viewFileOutline(args) {
   try {
-    const { command_id } = args;
-    const entry = runningCommands.get(command_id);
-    if (!entry) {
+    const { file_path } = args;
+    if (!file_path || typeof file_path !== "string") {
       return {
         success: false,
-        error: `Command with id "${command_id}" not found`
+        file_path: file_path || "",
+        language: "unknown",
+        total_lines: 0,
+        items: [],
+        summary: "",
+        error: "file_path is required and must be a string"
       };
     }
-    if (entry.status !== "running" || !entry.process) {
+    const resolvedPath = path8.resolve(file_path);
+    let content;
+    try {
+      content = await fsPromises3.readFile(resolvedPath, "utf-8");
+    } catch (error) {
       return {
         success: false,
-        error: `Command is not running (status: ${entry.status})`
+        file_path: resolvedPath,
+        language: "unknown",
+        total_lines: 0,
+        items: [],
+        summary: "",
+        error: error.code === "ENOENT" ? `File not found: ${resolvedPath}` : `Error reading file: ${error.message}`
       };
     }
-    entry.process.kill("SIGTERM");
-    entry.status = "killed";
-    entry.endTime = Date.now();
+    const language = detectLanguage(resolvedPath);
+    const lines = content.split("\n");
+    const totalLines = lines.length;
+    const items = await extractOutline(resolvedPath, content, language);
     return {
       success: true,
-      message: `Command ${command_id} killed`
+      file_path: resolvedPath,
+      language,
+      total_lines: totalLines,
+      items,
+      summary: generateSummary(items, totalLines)
     };
   } catch (error) {
     return {
       success: false,
-      error: `Failed to kill command: ${error.message}`
+      file_path: args.file_path || "",
+      language: "unknown",
+      total_lines: 0,
+      items: [],
+      summary: "",
+      error: `Unexpected error: ${error.message}`
     };
   }
 }
 
+// src/app/agent/tool_invoker.ts
+init_async_command();
+
 // src/app/agent/tools/natives/task_boundary.ts
 import path9 from "path";
 import { promises as fs7 } from "fs";
@@ -6219,6 +6240,61 @@ var AppComponent = ({ eventBus: eventBus2, sessionId: sessionId2 }) => {
         ]);
         return;
       }
+      if (text.startsWith("!")) {
+        const command = text.slice(1).trim();
+        if (!command) {
+          setIsProcessing(false);
+          return;
+        }
+        setHistory((prev) => [
+          ...prev,
+          {
+            id: prev.length,
+            component: /* @__PURE__ */ jsxs15(Box16, { marginBottom: 1, children: [
+              /* @__PURE__ */ jsx16(Text15, { color: "white", bold: true, children: "$ " }),
+              /* @__PURE__ */ jsx16(Text15, { color: "white", children: command })
+            ] })
+          }
+        ]);
+        Promise.resolve().then(() => (init_async_command(), async_command_exports)).then(async ({ runCommandAsync: runCommandAsync2 }) => {
+          try {
+            const result = await runCommandAsync2({ command, cwd: workdir });
+            if (result.success && result.command_id) {
+              const contextMessage = `[User executed shell command directly]
+Command: ${command}
+Command ID: ${result.command_id}
+
+Please use command_status to check the result and report back to the user.`;
+              agentInstance.current?.processTurn({ content: contextMessage });
+            } else {
+              setHistory((prev) => [
+                ...prev,
+                {
+                  id: prev.length,
+                  component: /* @__PURE__ */ jsxs15(Text15, { color: "red", children: [
+                    "Failed to execute: ",
+                    result.error || result.message
+                  ] })
+                }
+              ]);
+              setIsProcessing(false);
+            }
+          } catch (err) {
+            setHistory((prev) => [
+              ...prev,
+              {
+                id: prev.length,
+                component: /* @__PURE__ */ jsxs15(Text15, { color: "red", children: [
+                  "Error: ",
+                  err.message
+                ] })
+              }
+            ]);
+            setIsProcessing(false);
+          }
+        });
+        return;
+      }
       setIsProcessing(true);
       const displayText = text.length > 1e4 ? text.substring(0, 1e4) + "..." : text;
       setHistory((prev) => [

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nomad-e/bluma-cli",
-	"version": "0.0.108",
+	"version": "0.0.109",
 	"description": "BluMa independent agent for automation and advanced software engineering.",
 	"author": "Alex Fonseca",
 	"license": "Apache-2.0",