aemeathcli 1.0.0

package/dist/chunk-Y5XVD2CD.js

@@ -0,0 +1,1610 @@
+import { validatePath, isCommandBlocked, redactSecrets } from './chunk-CS5X3BWX.js';
+import { FileNotFoundError, ExecutionTimeoutError } from './chunk-ZGOHARPV.js';
+import { logger } from './chunk-JAXXTYID.js';
+import { stat, readFile, mkdir, writeFile } from 'fs/promises';
+import { dirname, resolve, extname } from 'path';
+import fg from 'fast-glob';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import { execaCommand } from 'execa';
+
+// src/tools/registry.ts
+function redactToolArgs(args) {
+  const redacted = {};
+  for (const [key, value] of Object.entries(args)) {
+    if (typeof value === "string" && (key === "content" || key === "command" || key === "new_source")) {
+      redacted[key] = redactSecrets(value.length > 200 ? value.slice(0, 200) + "..." : value);
+    } else if (typeof value === "string") {
+      redacted[key] = redactSecrets(value);
+    } else {
+      redacted[key] = value;
+    }
+  }
+  return redacted;
+}
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  categoryIndex = /* @__PURE__ */ new Map();
+  register(tool) {
+    const name = tool.definition.name;
+    if (this.tools.has(name)) {
+      logger.warn({ toolName: name }, "Overwriting existing tool registration");
+    }
+    this.tools.set(name, tool);
+    let categorySet = this.categoryIndex.get(tool.category);
+    if (!categorySet) {
+      categorySet = /* @__PURE__ */ new Set();
+      this.categoryIndex.set(tool.category, categorySet);
+    }
+    categorySet.add(name);
+    logger.debug({ toolName: name, category: tool.category }, "Tool registered");
+  }
+  get(name) {
+    return this.tools.get(name);
+  }
+  getAll() {
+    return [...this.tools.values()];
+  }
+  getDefinitions() {
+    return [...this.tools.values()].map((t) => t.definition);
+  }
+  getByCategory(category) {
+    const names = this.categoryIndex.get(category);
+    if (!names) {
+      return [];
+    }
+    const results = [];
+    for (const name of names) {
+      const tool = this.tools.get(name);
+      if (tool) {
+        results.push(tool);
+      }
+    }
+    return results;
+  }
+  async execute(call, context) {
+    const tool = this.tools.get(call.name);
+    if (!tool) {
+      return {
+        toolCallId: call.id,
+        name: call.name,
+        content: `Unknown tool: ${call.name}`,
+        isError: true
+      };
+    }
+    if (tool.requiresApproval(context.permissionMode, call.arguments)) {
+      return {
+        toolCallId: call.id,
+        name: call.name,
+        content: `Tool "${call.name}" requires user approval in ${context.permissionMode} mode.`,
+        isError: true
+      };
+    }
+    try {
+      logger.debug({ toolName: call.name, args: redactToolArgs(call.arguments) }, "Executing tool");
+      const result = await tool.execute(call.arguments);
+      return {
+        ...result,
+        toolCallId: call.id,
+        name: call.name
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown execution error";
+      logger.error({ toolName: call.name, error: message }, "Tool execution failed");
+      return {
+        toolCallId: call.id,
+        name: call.name,
+        content: message,
+        isError: true
+      };
+    }
+  }
+};
+var MAX_FILE_SIZE = 10 * 1024 * 1024;
+var DEFAULT_LINE_LIMIT = 2e3;
+var MAX_LINE_LENGTH = 2e3;
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".bmp",
+  ".ico",
+  ".webp",
+  ".svg",
+  ".mp3",
+  ".mp4",
+  ".avi",
+  ".mov",
+  ".wav",
+  ".flac",
+  ".zip",
+  ".gz",
+  ".tar",
+  ".bz2",
+  ".7z",
+  ".rar",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".o",
+  ".a",
+  ".pdf",
+  ".doc",
+  ".docx",
+  ".xls",
+  ".xlsx",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".eot",
+  ".otf",
+  ".sqlite",
+  ".db"
+]);
+function isBinaryFile(filePath, buffer) {
+  if (BINARY_EXTENSIONS.has(extname(filePath).toLowerCase())) {
+    return true;
+  }
+  const sample = buffer.subarray(0, 8192);
+  for (let i = 0; i < sample.length; i++) {
+    if (sample[i] === 0) {
+      return true;
+    }
+  }
+  return false;
+}
+function formatWithLineNumbers(content, offset, limit) {
+  const allLines = content.split("\n");
+  const startLine = Math.max(0, offset);
+  const endLine = Math.min(allLines.length, startLine + limit);
+  const sliced = allLines.slice(startLine, endLine);
+  const maxLineNum = endLine;
+  const padWidth = String(maxLineNum).length;
+  return sliced.map((line, idx) => {
+    const lineNum = String(startLine + idx + 1).padStart(padWidth, " ");
+    const truncated = line.length > MAX_LINE_LENGTH ? line.substring(0, MAX_LINE_LENGTH) + "..." : line;
+    return `${lineNum}	${truncated}`;
+  }).join("\n");
+}
+var projectRoot = process.cwd();
+function setReadProjectRoot(root) {
+  projectRoot = root;
+}
+function createReadTool() {
+  return {
+    definition: {
+      name: "read",
+      description: "Read a file from the filesystem with line numbers. Supports offset and limit for large files.",
+      parameters: [
+        {
+          name: "file_path",
+          type: "string",
+          description: "Absolute path to the file to read",
+          required: true
+        },
+        {
+          name: "offset",
+          type: "number",
+          description: "Line number to start reading from (0-indexed)",
+          required: false,
+          default: 0
+        },
+        {
+          name: "limit",
+          type: "number",
+          description: "Maximum number of lines to read",
+          required: false,
+          default: DEFAULT_LINE_LIMIT
+        }
+      ]
+    },
+    category: "file",
+    requiresApproval: (_mode, _args) => {
+      return false;
+    },
+    execute: async (args) => {
+      const filePath = args["file_path"];
+      if (typeof filePath !== "string" || filePath.length === 0) {
+        return {
+          toolCallId: "",
+          name: "read",
+          content: "file_path parameter is required and must be a non-empty string.",
+          isError: true
+        };
+      }
+      let resolvedPath;
+      try {
+        resolvedPath = validatePath(filePath, projectRoot);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : "Path validation failed";
+        return { toolCallId: "", name: "read", content: msg, isError: true };
+      }
+      let fileStat;
+      try {
+        fileStat = await stat(resolvedPath);
+      } catch {
+        throw new FileNotFoundError(resolvedPath);
+      }
+      if (!fileStat.isFile()) {
+        return {
+          toolCallId: "",
+          name: "read",
+          content: `"${resolvedPath}" is not a regular file. Use Bash ls to list directories.`,
+          isError: true
+        };
+      }
+      if (fileStat.size > MAX_FILE_SIZE) {
+        return {
+          toolCallId: "",
+          name: "read",
+          content: `File is too large (${(fileStat.size / 1024 / 1024).toFixed(1)} MB). Maximum is ${MAX_FILE_SIZE / 1024 / 1024} MB.`,
+          isError: true
+        };
+      }
+      const rawBuffer = await readFile(resolvedPath);
+      if (isBinaryFile(resolvedPath, rawBuffer)) {
+        return {
+          toolCallId: "",
+          name: "read",
+          content: `Binary file detected: ${resolvedPath} (${fileStat.size} bytes). Cannot display binary content.`,
+          isError: false
+        };
+      }
+      const content = rawBuffer.toString("utf-8");
+      if (content.length === 0) {
+        return {
+          toolCallId: "",
+          name: "read",
+          content: `File "${resolvedPath}" exists but is empty.`,
+          isError: false
+        };
+      }
+      const offset = typeof args["offset"] === "number" ? args["offset"] : 0;
+      const limit = typeof args["limit"] === "number" ? args["limit"] : DEFAULT_LINE_LIMIT;
+      const formatted = formatWithLineNumbers(content, offset, limit);
+      logger.debug({ file: resolvedPath, offset, limit }, "File read");
+      return {
+        toolCallId: "",
+        name: "read",
+        content: formatted,
+        isError: false
+      };
+    }
+  };
+}
+var CONFIG_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".env",
+  ".pem",
+  ".key",
+  ".crt",
+  ".p12",
+  ".pfx",
+  ".jks"
+]);
+var SENSITIVE_FILENAMES = /* @__PURE__ */ new Set([
+  ".env",
+  ".env.local",
+  ".env.production",
+  ".env.development",
+  "credentials.json",
+  "credentials.enc",
+  "secrets.json",
+  "id_rsa",
+  "id_ed25519",
+  "config.json"
+]);
+function isConfigFile(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  const base = filePath.split("/").pop() ?? "";
+  return CONFIG_EXTENSIONS.has(ext) || SENSITIVE_FILENAMES.has(base);
+}
+var projectRoot2 = process.cwd();
+function setWriteProjectRoot(root) {
+  projectRoot2 = root;
+}
+function createWriteTool() {
+  return {
+    definition: {
+      name: "write",
+      description: "Write content to a file. Creates parent directories if needed. Overwrites existing files.",
+      parameters: [
+        {
+          name: "file_path",
+          type: "string",
+          description: "Absolute path to the file to write",
+          required: true
+        },
+        {
+          name: "content",
+          type: "string",
+          description: "The content to write to the file",
+          required: true
+        }
+      ]
+    },
+    category: "file",
+    requiresApproval: (mode, _args) => {
+      return mode === "strict" || mode === "standard";
+    },
+    execute: async (args) => {
+      const filePath = args["file_path"];
+      const content = args["content"];
+      if (typeof filePath !== "string" || filePath.length === 0) {
+        return {
+          toolCallId: "",
+          name: "write",
+          content: "file_path parameter is required and must be a non-empty string.",
+          isError: true
+        };
+      }
+      if (typeof content !== "string") {
+        return {
+          toolCallId: "",
+          name: "write",
+          content: "content parameter is required and must be a string.",
+          isError: true
+        };
+      }
+      let resolvedPath;
+      try {
+        resolvedPath = validatePath(filePath, projectRoot2);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : "Path validation failed";
+        return { toolCallId: "", name: "write", content: msg, isError: true };
+      }
+      const parentDir = dirname(resolvedPath);
+      try {
+        await mkdir(parentDir, { recursive: true });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : "Failed to create directory";
+        return {
+          toolCallId: "",
+          name: "write",
+          content: `Failed to create parent directory: ${msg}`,
+          isError: true
+        };
+      }
+      const fileMode = isConfigFile(resolvedPath) ? 384 : 420;
+      let existed = false;
+      try {
+        const fileStat = await stat(resolvedPath);
+        existed = fileStat.isFile();
+      } catch {
+      }
+      try {
+        await writeFile(resolvedPath, content, { encoding: "utf-8", mode: fileMode });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : "Write failed";
+        return {
+          toolCallId: "",
+          name: "write",
+          content: `Failed to write file: ${msg}`,
+          isError: true
+        };
+      }
+      const lineCount = content.split("\n").length;
+      const action = existed ? "Updated" : "Created";
+      logger.debug(
+        { file: resolvedPath, lines: lineCount, mode: fileMode.toString(8) },
+        `File ${action.toLowerCase()}`
+      );
+      return {
+        toolCallId: "",
+        name: "write",
+        content: `${action} ${resolvedPath} (${lineCount} lines)`,
+        isError: false
+      };
+    }
+  };
+}
+var projectRoot3 = process.cwd();
+function setEditProjectRoot(root) {
+  projectRoot3 = root;
+}
+function createEditTool() {
+  return {
+    definition: {
+      name: "edit",
+      description: "Perform exact string replacement in a file. The old_string must be unique unless replace_all is true.",
+      parameters: [
+        {
+          name: "file_path",
+          type: "string",
+          description: "Absolute path to the file to edit",
+          required: true
+        },
+        {
+          name: "old_string",
+          type: "string",
+          description: "The exact text to find and replace",
+          required: true
+        },
+        {
+          name: "new_string",
+          type: "string",
+          description: "The replacement text",
+          required: true
+        },
+        {
+          name: "replace_all",
+          type: "boolean",
+          description: "Replace all occurrences instead of requiring uniqueness",
+          required: false,
+          default: false
+        }
+      ]
+    },
+    category: "file",
+    requiresApproval: (mode, _args) => {
+      return mode === "strict" || mode === "standard";
+    },
+    execute: async (args) => {
+      const filePath = args["file_path"];
+      const oldString = args["old_string"];
+      const newString = args["new_string"];
+      const replaceAll = args["replace_all"] === true;
+      if (typeof filePath !== "string" || filePath.length === 0) {
+        return {
+          toolCallId: "",
+          name: "edit",
+          content: "file_path parameter is required and must be a non-empty string.",
+          isError: true
+        };
+      }
+      if (typeof oldString !== "string") {
+        return {
+          toolCallId: "",
+          name: "edit",
+          content: "old_string parameter is required and must be a string.",
+          isError: true
+        };
+      }
+      if (typeof newString !== "string") {
+        return {
+          toolCallId: "",
+          name: "edit",
+          content: "new_string parameter is required and must be a string.",
+          isError: true
+        };
+      }
+      if (oldString === newString) {
+        return {
+          toolCallId: "",
+          name: "edit",
+          content: "old_string and new_string are identical \u2014 no edit needed.",
+          isError: true
+        };
+      }
+      let resolvedPath;
+      try {
+        resolvedPath = validatePath(filePath, projectRoot3);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : "Path validation failed";
+        return { toolCallId: "", name: "edit", content: msg, isError: true };
+      }
+      try {
+        const fileStat = await stat(resolvedPath);
+        if (!fileStat.isFile()) {
+          return {
+            toolCallId: "",
+            name: "edit",
+            content: `"${resolvedPath}" is not a regular file.`,
+            isError: true
+          };
+        }
+      } catch {
+        throw new FileNotFoundError(resolvedPath);
+      }
+      const rawBuffer = await readFile(resolvedPath);
+      const originalContent = rawBuffer.toString("utf-8");
+      if (!originalContent.includes(oldString)) {
+        return {
+          toolCallId: "",
+          name: "edit",
+          content: `old_string not found in ${resolvedPath}. Ensure it matches the file content exactly, including whitespace and indentation.`,
+          isError: true
+        };
+      }
+      if (!replaceAll) {
+        const firstIdx = originalContent.indexOf(oldString);
+        const secondIdx = originalContent.indexOf(oldString, firstIdx + 1);
+        if (secondIdx !== -1) {
+          const occurrences = originalContent.split(oldString).length - 1;
+          return {
+            toolCallId: "",
+            name: "edit",
+            content: `old_string is not unique \u2014 found ${occurrences} occurrences in ${resolvedPath}. Provide more surrounding context to make it unique, or set replace_all to true.`,
+            isError: true
+          };
+        }
+      }
+      let newContent;
+      let replacementCount;
+      if (replaceAll) {
+        replacementCount = originalContent.split(oldString).length - 1;
+        newContent = originalContent.split(oldString).join(newString);
+      } else {
+        replacementCount = 1;
+        const idx = originalContent.indexOf(oldString);
+        newContent = originalContent.substring(0, idx) + newString + originalContent.substring(idx + oldString.length);
+      }
+      await writeFile(resolvedPath, newContent, "utf-8");
+      logger.debug(
+        { file: resolvedPath, replacements: replacementCount },
+        "File edited"
+      );
+      return {
+        toolCallId: "",
+        name: "edit",
+        content: `Edited ${resolvedPath}: ${replacementCount} replacement(s) made.`,
+        isError: false
+      };
+    }
+  };
+}
+var MAX_RESULTS = 1e3;
+var projectRoot4 = process.cwd();
+function setGlobProjectRoot(root) {
+  projectRoot4 = root;
+}
+function createGlobTool() {
+  return {
+    definition: {
+      name: "glob",
+      description: "Find files matching a glob pattern. Results are sorted by modification time (newest first).",
+      parameters: [
+        {
+          name: "pattern",
+          type: "string",
+          description: 'Glob pattern to match (e.g. "**/*.ts", "src/**/*.tsx")',
+          required: true
+        },
+        {
+          name: "path",
+          type: "string",
+          description: "Directory to search in. Defaults to project root.",
+          required: false
+        }
+      ]
+    },
+    category: "search",
+    requiresApproval: (_mode, _args) => {
+      return false;
+    },
+    execute: async (args) => {
+      const pattern = args["pattern"];
+      if (typeof pattern !== "string" || pattern.length === 0) {
+        return {
+          toolCallId: "",
+          name: "glob",
+          content: "pattern parameter is required and must be a non-empty string.",
+          isError: true
+        };
+      }
+      let searchPath;
+      if (typeof args["path"] === "string" && args["path"].length > 0) {
+        const resolved = resolve(projectRoot4, args["path"]);
+        searchPath = validatePath(resolved, projectRoot4);
+      } else {
+        searchPath = projectRoot4;
+      }
+      let matchedPaths;
+      try {
+        matchedPaths = await fg(pattern, {
+          cwd: searchPath,
+          absolute: true,
+          dot: false,
+          onlyFiles: true,
+          ignore: [
+            "**/node_modules/**",
+            "**/.git/**",
+            "**/dist/**",
+            "**/build/**",
+            "**/.next/**",
+            "**/coverage/**"
+          ]
+        });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : "Glob search failed";
+        return { toolCallId: "", name: "glob", content: msg, isError: true };
+      }
+      if (matchedPaths.length === 0) {
+        return {
+          toolCallId: "",
+          name: "glob",
+          content: "No files found",
+          isError: false
+        };
+      }
+      const entries = [];
+      for (const filePath of matchedPaths) {
+        try {
+          const fileStat = await stat(filePath);
+          entries.push({ path: filePath, mtimeMs: fileStat.mtimeMs });
+        } catch {
+        }
+      }
+      entries.sort((a, b) => b.mtimeMs - a.mtimeMs);
+      const truncated = entries.length > MAX_RESULTS;
+      const resultEntries = truncated ? entries.slice(0, MAX_RESULTS) : entries;
+      const output = resultEntries.map((e) => e.path).join("\n");
+      logger.debug(
+        { pattern, searchPath, total: entries.length, returned: resultEntries.length },
+        "Glob search complete"
+      );
+      const suffix = truncated ? `
+
+(Showing ${MAX_RESULTS} of ${entries.length} matches)` : "";
+      return {
+        toolCallId: "",
+        name: "glob",
+        content: output + suffix,
+        isError: false
+      };
+    }
+  };
+}
+var execFileAsync = promisify(execFile);
+var MAX_OUTPUT_LENGTH = 3e4;
+var DEFAULT_HEAD_LIMIT = 0;
+async function findSearchBinary() {
+  try {
+    await execFileAsync("which", ["rg"]);
+    return "rg";
+  } catch {
+    return "grep";
+  }
+}
+function buildRipgrepArgs(pattern, searchPath, outputMode, opts) {
+  const args = [];
+  if (outputMode === "files_with_matches") {
+    args.push("--files-with-matches");
+  } else if (outputMode === "count") {
+    args.push("--count");
+  }
+  if (opts.caseInsensitive === true) {
+    args.push("-i");
+  }
+  if (opts.multiline === true) {
+    args.push("-U", "--multiline-dotall");
+  }
+  if (outputMode === "content") {
+    {
+      args.push("-n");
+    }
+    if (typeof opts.contextLines === "number" && opts.contextLines > 0) {
+      args.push("-C", String(opts.contextLines));
+    } else {
+      if (typeof opts.beforeContext === "number" && opts.beforeContext > 0) {
+        args.push("-B", String(opts.beforeContext));
+      }
+      if (typeof opts.afterContext === "number" && opts.afterContext > 0) {
+        args.push("-A", String(opts.afterContext));
+      }
+    }
+  }
+  if (typeof opts.glob === "string" && opts.glob.length > 0) {
+    args.push("--glob", opts.glob);
+  }
+  if (typeof opts.fileType === "string" && opts.fileType.length > 0) {
+    args.push("--type", opts.fileType);
+  }
+  args.push(
+    "--glob",
+    "!node_modules",
+    "--glob",
+    "!.git",
+    "--glob",
+    "!dist",
+    "--glob",
+    "!build",
+    "--glob",
+    "!coverage"
+  );
+  args.push("--", pattern, searchPath);
+  return args;
+}
+function buildGrepArgs(pattern, searchPath, outputMode, opts) {
+  const args = ["-r", "--extended-regexp"];
+  if (outputMode === "files_with_matches") {
+    args.push("-l");
+  } else if (outputMode === "count") {
+    args.push("-c");
+  }
+  if (opts.caseInsensitive === true) {
+    args.push("-i");
+  }
+  if (outputMode === "content" && typeof opts.contextLines === "number" && opts.contextLines > 0) {
+    args.push("-C", String(opts.contextLines));
+  }
+  args.push(
+    "--exclude-dir=node_modules",
+    "--exclude-dir=.git",
+    "--exclude-dir=dist",
+    "--exclude-dir=build"
+  );
+  args.push("--", pattern, searchPath);
+  return args;
+}
+function applyLimits(output, headLimit, offset) {
+  let lines = output.split("\n");
+  if (offset > 0) {
+    lines = lines.slice(offset);
+  }
+  if (headLimit > 0) {
+    lines = lines.slice(0, headLimit);
+  }
+  let result = lines.join("\n");
+  if (result.length > MAX_OUTPUT_LENGTH) {
+    result = result.substring(0, MAX_OUTPUT_LENGTH) + "\n...(truncated)";
+  }
+  return result;
+}
+var projectRoot5 = process.cwd();
+function setGrepProjectRoot(root) {
+  projectRoot5 = root;
+}
+function createGrepTool() {
+  return {
+    definition: {
+      name: "grep",
+      description: "Search file contents using regex patterns. Uses ripgrep (rg) with grep fallback.",
+      parameters: [
+        {
+          name: "pattern",
+          type: "string",
+          description: "Regular expression pattern to search for",
+          required: true
+        },
+        {
+          name: "path",
+          type: "string",
+          description: "File or directory to search in. Defaults to project root.",
+          required: false
+        },
+        {
+          name: "output_mode",
+          type: "string",
+          description: "Output mode: content, files_with_matches, or count",
+          required: false,
+          default: "files_with_matches",
+          enum: ["content", "files_with_matches", "count"]
+        },
+        {
+          name: "glob",
+          type: "string",
+          description: 'Glob filter for files (e.g. "*.ts")',
+          required: false
+        },
+        {
+          name: "type",
+          type: "string",
+          description: 'File type filter (e.g. "ts", "py")',
+          required: false
+        },
+        {
+          name: "context",
+          type: "number",
+          description: "Lines of context around matches",
+          required: false
+        },
+        {
+          name: "-B",
+          type: "number",
+          description: "Lines of context before matches",
+          required: false
+        },
+        {
+          name: "-A",
+          type: "number",
+          description: "Lines of context after matches",
+          required: false
+        },
+        {
+          name: "-i",
+          type: "boolean",
+          description: "Case insensitive search",
+          required: false,
+          default: false
+        },
+        {
+          name: "multiline",
+          type: "boolean",
+          description: "Enable multiline matching",
+          required: false,
+          default: false
+        },
+        {
+          name: "head_limit",
+          type: "number",
+          description: "Limit output to first N entries",
+          required: false,
+          default: 0
+        },
+        {
+          name: "offset",
+          type: "number",
+          description: "Skip first N entries",
+          required: false,
+          default: 0
+        }
+      ]
+    },
+    category: "search",
+    requiresApproval: (_mode, _args) => {
+      return false;
+    },
+    execute: async (args) => {
+      const pattern = args["pattern"];
+      if (typeof pattern !== "string" || pattern.length === 0) {
+        return {
+          toolCallId: "",
+          name: "grep",
+          content: "pattern parameter is required and must be a non-empty string.",
+          isError: true
+        };
+      }
+      let searchPath;
+      if (typeof args["path"] === "string" && args["path"].length > 0) {
+        const resolved = resolve(projectRoot5, args["path"]);
+        searchPath = validatePath(resolved, projectRoot5);
+      } else {
+        searchPath = projectRoot5;
+      }
+      const outputMode = args["output_mode"] === "content" || args["output_mode"] === "count" ? args["output_mode"] : "files_with_matches";
+      const headLimit = typeof args["head_limit"] === "number" ? args["head_limit"] : DEFAULT_HEAD_LIMIT;
+      const offset = typeof args["offset"] === "number" ? args["offset"] : 0;
+      const binary = await findSearchBinary();
+      const searchArgs = binary === "rg" ? buildRipgrepArgs(pattern, searchPath, outputMode, {
+        glob: typeof args["glob"] === "string" ? args["glob"] : void 0,
+        fileType: typeof args["type"] === "string" ? args["type"] : void 0,
+        contextLines: typeof args["context"] === "number" ? args["context"] : void 0,
+        beforeContext: typeof args["-B"] === "number" ? args["-B"] : void 0,
+        afterContext: typeof args["-A"] === "number" ? args["-A"] : void 0,
+        caseInsensitive: args["-i"] === true,
+        multiline: args["multiline"] === true}) : buildGrepArgs(pattern, searchPath, outputMode, {
+        caseInsensitive: args["-i"] === true,
+        contextLines: typeof args["context"] === "number" ? args["context"] : void 0
+      });
+      try {
+        const { stdout } = await execFileAsync(binary, searchArgs, {
+          maxBuffer: 10 * 1024 * 1024,
+          timeout: 3e4
+        });
+        const result = applyLimits(stdout.trim(), headLimit, offset);
+        if (result.length === 0) {
+          return {
+            toolCallId: "",
+            name: "grep",
+            content: "No matches found.",
+            isError: false
+          };
+        }
+        logger.debug({ binary, pattern, outputMode, matches: result.split("\n").length }, "Grep complete");
+        return {
+          toolCallId: "",
+          name: "grep",
+          content: result,
+          isError: false
+        };
+      } catch (err) {
+        if (err instanceof Error && "code" in err && err.code === "1") {
+          return {
+            toolCallId: "",
+            name: "grep",
+            content: "No matches found.",
+            isError: false
+          };
+        }
+        const execError = err;
+        if (execError.status === 1) {
+          return {
+            toolCallId: "",
+            name: "grep",
+            content: "No matches found.",
+            isError: false
+          };
+        }
+        const msg = err instanceof Error ? err.message : "Search failed";
+        logger.error({ binary, pattern, error: msg }, "Grep failed");
+        return {
+          toolCallId: "",
+          name: "grep",
+          content: `Search failed: ${msg}`,
+          isError: true
+        };
+      }
+    }
+  };
+}
+var DEFAULT_TIMEOUT_MS = 12e4;
+var MAX_TIMEOUT_MS = 6e5;
+var MAX_OUTPUT_LENGTH2 = 3e4;
+var DANGEROUS_PATTERNS = [
+  "rm -rf /",
+  "rm -rf ~",
+  "mkfs",
+  "dd if=",
+  "> /dev/sd",
+  "chmod -R 777 /",
+  ":(){ :|:& };:",
+  "fork bomb",
+  "shutdown",
+  "reboot",
+  "init 0",
+  "init 6"
+];
+var ALWAYS_DANGEROUS_COMMANDS = [
+  "push --force",
+  "push -f",
+  "reset --hard",
+  "clean -fd",
+  "branch -D",
+  "rm -rf",
+  "drop table",
+  "drop database",
+  "truncate table"
+];
+var SENSITIVE_ENV_PATTERNS = [
+  "API_KEY",
+  "SECRET",
+  "TOKEN",
+  "PASSWORD",
+  "CREDENTIAL",
+  "ANTHROPIC_API",
+  "OPENAI_API",
+  "GOOGLE_API",
+  "MOONSHOT_API",
+  "KIMI_API",
+  "SESSION_TOKEN",
+  "REFRESH_TOKEN",
+  "ACCESS_TOKEN",
+  "PRIVATE_KEY"
+];
+function filterSensitiveEnv(env) {
+  const filtered = {};
+  for (const [key, value] of Object.entries(env)) {
+    const upperKey = key.toUpperCase();
+    const isSensitive = SENSITIVE_ENV_PATTERNS.some((pattern) => upperKey.includes(pattern));
+    if (!isSensitive) {
+      filtered[key] = value;
+    }
+  }
+  return filtered;
+}
+function isDangerousCommand(command) {
+  const lowerCommand = command.toLowerCase().trim();
+  return DANGEROUS_PATTERNS.some((p) => lowerCommand.includes(p)) || ALWAYS_DANGEROUS_COMMANDS.some((p) => lowerCommand.includes(p.toLowerCase()));
+}
+function truncateOutput(output) {
+  if (output.length <= MAX_OUTPUT_LENGTH2) {
+    return output;
+  }
+  return output.substring(0, MAX_OUTPUT_LENGTH2) + "\n...(truncated)";
+}
+var workingDirectory = process.cwd();
+var blockedCommands = [];
+function setBashWorkingDirectory(dir) {
+  workingDirectory = dir;
+}
+function setBashBlockedCommands(commands) {
+  blockedCommands = commands;
+}
+function createBashTool() {
+  return {
+    definition: {
+      name: "bash",
+      description: "Execute a shell command. Supports timeout. Dangerous commands require approval.",
+      parameters: [
+        {
+          name: "command",
+          type: "string",
+          description: "The shell command to execute",
+          required: true
+        },
+        {
+          name: "description",
+          type: "string",
+          description: "Short description of what this command does",
+          required: false
+        },
+        {
+          name: "timeout",
+          type: "number",
+          description: "Timeout in milliseconds (max 600000)",
+          required: false,
+          default: DEFAULT_TIMEOUT_MS
+        }
+      ]
+    },
+    category: "shell",
+    requiresApproval: (mode, args) => {
+      const command = typeof args["command"] === "string" ? args["command"] : "";
+      if (isDangerousCommand(command) || isCommandBlocked(command, blockedCommands)) {
+        return true;
+      }
+      if (mode === "strict") {
+        return true;
+      }
+      return false;
+    },
+    execute: async (args) => {
+      const command = args["command"];
+      if (typeof command !== "string" || command.length === 0) {
+        return {
+          toolCallId: "",
+          name: "bash",
+          content: "command parameter is required and must be a non-empty string.",
+          isError: true
+        };
+      }
+      const lowerCommand = command.toLowerCase().trim();
+      for (const pattern of DANGEROUS_PATTERNS) {
+        if (lowerCommand.includes(pattern)) {
+          return {
+            toolCallId: "",
+            name: "bash",
+            content: `Blocked: command matches dangerous pattern "${pattern}".`,
+            isError: true
+          };
+        }
+      }
+      if (isCommandBlocked(command, blockedCommands)) {
+        return {
+          toolCallId: "",
+          name: "bash",
+          content: "Command is on the blocked list and cannot be executed.",
+          isError: true
+        };
+      }
+      let timeoutMs = DEFAULT_TIMEOUT_MS;
+      if (typeof args["timeout"] === "number") {
+        timeoutMs = Math.max(1e3, Math.min(args["timeout"], MAX_TIMEOUT_MS));
+      }
+      logger.debug({ command: redactSecrets(command), timeout: timeoutMs, cwd: workingDirectory }, "Executing bash command");
+      try {
+        const result = await execaCommand(command, {
+          cwd: workingDirectory,
+          timeout: timeoutMs,
+          reject: false,
+          shell: true,
+          env: {
+            ...filterSensitiveEnv(process.env),
+            TERM: "dumb",
+            NO_COLOR: "1"
+          },
+          stripFinalNewline: true
+        });
+        const stdout = result.stdout ? truncateOutput(result.stdout) : "";
+        const stderr = result.stderr ? truncateOutput(result.stderr) : "";
+        let content = "";
+        if (stdout.length > 0) {
+          content += stdout;
+        }
+        if (stderr.length > 0) {
+          content += (content.length > 0 ? "\n\nSTDERR:\n" : "STDERR:\n") + stderr;
+        }
+        if (content.length === 0) {
+          content = `Command completed with exit code ${result.exitCode ?? 0}.`;
+        }
+        const isError = (result.exitCode ?? 0) !== 0;
+        if (isError) {
+          content = `Exit code: ${result.exitCode ?? "unknown"}
+${content}`;
+        }
+        return {
+          toolCallId: "",
+          name: "bash",
+          content,
+          isError
+        };
+      } catch (err) {
+        if (err instanceof Error && err.message.includes("timed out")) {
+          throw new ExecutionTimeoutError(command, timeoutMs);
+        }
+        const msg = err instanceof Error ? err.message : "Command execution failed";
+        logger.error({ command: redactSecrets(command), error: msg }, "Bash execution failed");
+        return {
+          toolCallId: "",
+          name: "bash",
+          content: `Execution failed: ${msg}`,
+          isError: true
+        };
+      }
+    }
+  };
+}
+
+// src/tools/web-search.ts
+var searchProvider;
+function setWebSearchProvider(provider) {
+  searchProvider = provider;
+}
+function createWebSearchTool() {
+  return {
+    definition: {
+      name: "web_search",
+      description: "Search the web for up-to-date information. Requires a configured search provider.",
+      parameters: [
+        {
+          name: "query",
+          type: "string",
+          description: "The search query",
+          required: true
+        },
+        {
+          name: "allowed_domains",
+          type: "array",
+          description: "Only include results from these domains",
+          required: false
+        },
+        {
+          name: "blocked_domains",
+          type: "array",
+          description: "Exclude results from these domains",
+          required: false
+        }
+      ]
+    },
+    category: "web",
+    requiresApproval: (_mode, _args) => {
+      return false;
+    },
+    execute: async (args) => {
+      const query = args["query"];
+      if (typeof query !== "string" || query.length === 0) {
+        return {
+          toolCallId: "",
+          name: "web_search",
+          content: "query parameter is required and must be a non-empty string.",
+          isError: true
+        };
+      }
+      if (!searchProvider) {
+        return {
+          toolCallId: "",
+          name: "web_search",
+          content: "Web search is not configured. Set up a search provider in your configuration.",
+          isError: true
+        };
+      }
+      const allowedDomains = Array.isArray(args["allowed_domains"]) ? args["allowed_domains"].filter(
+        (d) => typeof d === "string"
+      ) : void 0;
+      const blockedDomains = Array.isArray(args["blocked_domains"]) ? args["blocked_domains"].filter(
+        (d) => typeof d === "string"
+      ) : void 0;
+      try {
+        logger.debug({ query }, "Web search executing");
+        const results = await searchProvider(query, {
+          allowedDomains,
+          blockedDomains
+        });
+        if (results.length === 0) {
+          return {
+            toolCallId: "",
+            name: "web_search",
+            content: `No results found for: ${query}`,
+            isError: false
+          };
+        }
+        return {
+          toolCallId: "",
+          name: "web_search",
+          content: results,
+          isError: false
+        };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : "Search failed";
+        logger.error({ query, error: msg }, "Web search failed");
+        return {
+          toolCallId: "",
+          name: "web_search",
+          content: `Web search failed: ${msg}`,
+          isError: true
+        };
+      }
+    }
+  };
+}
+
+// src/tools/web-fetch.ts
+var DEFAULT_TIMEOUT_MS2 = 3e4;
+var MAX_CONTENT_LENGTH = 1e5;
+var MAX_URL_LENGTH = 2048;
+function stripHtmlTags(html) {
+  let text = html.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "");
+  text = text.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "");
+  text = text.replace(/<\/(p|div|h[1-6]|li|tr|br|hr)[^>]*>/gi, "\n");
+  text = text.replace(/<br\s*\/?>/gi, "\n");
+  text = text.replace(/<[^>]+>/g, "");
+  text = text.replace(/&amp;/g, "&");
+  text = text.replace(/&lt;/g, "<");
+  text = text.replace(/&gt;/g, ">");
+  text = text.replace(/&quot;/g, '"');
+  text = text.replace(/&#39;/g, "'");
+  text = text.replace(/&nbsp;/g, " ");
+  text = text.replace(/[ \t]+/g, " ");
+  text = text.replace(/\n{3,}/g, "\n\n");
+  return text.trim();
+}
+function isPrivateHostname(hostname) {
+  if (hostname === "localhost" || hostname === "[::1]") {
+    return true;
+  }
+  const ipMatch = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(hostname);
+  if (ipMatch) {
+    const [, a, b] = ipMatch;
+    const first = parseInt(a, 10);
+    const second = parseInt(b, 10);
+    if (first === 127) return true;
+    if (first === 10) return true;
+    if (first === 172 && second >= 16 && second <= 31) return true;
+    if (first === 192 && second === 168) return true;
+    if (first === 169 && second === 254) return true;
+    if (first === 0) return true;
+  }
+  return false;
+}
+function isValidUrl(urlString) {
+  if (urlString.length > MAX_URL_LENGTH) {
+    return false;
+  }
+  try {
+    const url = new URL(urlString);
+    if (url.protocol !== "https:" && url.protocol !== "http:") {
+      return false;
+    }
+    if (isPrivateHostname(url.hostname)) {
+      return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function enforceHttps(urlString) {
+  try {
+    const url = new URL(urlString);
+    if (url.protocol === "http:") {
+      url.protocol = "https:";
+    }
+    return url.toString();
+  } catch {
+    return urlString;
+  }
+}
+function createWebFetchTool() {
+  return {
+    definition: {
+      name: "web_fetch",
+      description: "Fetch content from a URL and convert HTML to readable text. HTTP URLs are upgraded to HTTPS.",
+      parameters: [
+        {
+          name: "url",
+          type: "string",
+          description: "The URL to fetch content from",
+          required: true
+        },
+        {
+          name: "prompt",
+          type: "string",
+          description: "What information to extract from the page",
+          required: false
+        },
+        {
+          name: "timeout",
+          type: "number",
+          description: "Timeout in milliseconds (default 30000)",
+          required: false,
+          default: DEFAULT_TIMEOUT_MS2
+        }
+      ]
+    },
+    category: "web",
+    requiresApproval: (_mode, _args) => {
+      return false;
+    },
+    execute: async (args) => {
+      const rawUrl = args["url"];
+      if (typeof rawUrl !== "string" || rawUrl.length === 0) {
+        return {
+          toolCallId: "",
+          name: "web_fetch",
+          content: "url parameter is required and must be a non-empty string.",
+          isError: true
+        };
+      }
+      if (!isValidUrl(rawUrl)) {
+        return {
+          toolCallId: "",
+          name: "web_fetch",
+          content: `Invalid URL: "${rawUrl}". Must be a valid HTTP(S) URL.`,
+          isError: true
+        };
+      }
+      const url = enforceHttps(rawUrl);
+      let timeoutMs = DEFAULT_TIMEOUT_MS2;
+      if (typeof args["timeout"] === "number") {
+        timeoutMs = Math.max(5e3, Math.min(args["timeout"], 6e4));
+      }
+      logger.debug({ url, timeout: timeoutMs }, "Fetching URL");
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+      try {
+        const response = await fetch(url, {
+          signal: controller.signal,
+          headers: {
+            "User-Agent": "AemeathCLI/1.0",
+            "Accept": "text/html, application/json, text/plain, */*"
+          },
+          redirect: "follow"
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+          return {
+            toolCallId: "",
+            name: "web_fetch",
+            content: `HTTP ${response.status} ${response.statusText} for ${url}`,
+            isError: true
+          };
+        }
+        const contentType = response.headers.get("content-type") ?? "";
+        const rawBody = await response.text();
+        let content;
+        if (contentType.includes("text/html")) {
+          content = stripHtmlTags(rawBody);
+        } else {
+          content = rawBody;
+        }
+        if (content.length > MAX_CONTENT_LENGTH) {
+          content = content.substring(0, MAX_CONTENT_LENGTH) + "\n...(content truncated)";
+        }
+        if (content.length === 0) {
+          return {
+            toolCallId: "",
+            name: "web_fetch",
+            content: `Fetched ${url} but the response body was empty.`,
+            isError: false
+          };
+        }
+        return {
+          toolCallId: "",
+          name: "web_fetch",
+          content,
+          isError: false
+        };
+      } catch (err) {
+        clearTimeout(timeoutId);
+        if (err instanceof Error && err.name === "AbortError") {
+          return {
+            toolCallId: "",
+            name: "web_fetch",
+            content: `Request timed out after ${timeoutMs}ms for ${url}`,
+            isError: true
+          };
+        }
+        const msg = err instanceof Error ? err.message : "Fetch failed";
+        logger.error({ url, error: msg }, "Web fetch failed");
+        return {
+          toolCallId: "",
+          name: "web_fetch",
+          content: `Fetch failed for ${url}: ${msg}`,
+          isError: true
+        };
+      }
+    }
+  };
+}
+var GIT_TIMEOUT_MS = 6e4;
+var MAX_OUTPUT_LENGTH3 = 3e4;
+var ALLOWED_SUBCOMMANDS = /* @__PURE__ */ new Set([
+  "status",
+  "diff",
+  "log",
+  "show",
+  "branch",
+  "tag",
+  "add",
+  "commit",
+  "checkout",
+  "switch",
+  "merge",
+  "rebase",
+  "cherry-pick",
+  "stash",
+  "fetch",
+  "pull",
+  "push",
+  "remote",
+  "rev-parse",
+  "describe",
+  "blame"
+]);
+var DANGEROUS_FLAGS = [
+  "--force",
+  "-f",
+  "--force-with-lease",
+  "--hard",
+  "--no-verify",
+  "-D"
+];
+var READ_ONLY_SUBCOMMANDS = /* @__PURE__ */ new Set([
+  "status",
+  "diff",
+  "log",
+  "show",
+  "branch",
+  "tag",
+  "remote",
+  "rev-parse",
+  "describe",
+  "blame"
+]);
+function parseGitSubcommand(command) {
+  const parts = command.trim().split(/\s+/);
+  if (parts[0] !== "git" || parts.length < 2) {
+    return void 0;
+  }
+  return parts[1];
+}
+function hasDangerousFlags(command) {
+  const lowerCommand = command.toLowerCase();
+  return DANGEROUS_FLAGS.some((flag) => {
+    const pattern = new RegExp(`(^|\\s)${flag.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(\\s|$)`);
+    return pattern.test(lowerCommand);
+  });
+}
+function truncateOutput2(output) {
+  if (output.length <= MAX_OUTPUT_LENGTH3) {
+    return output;
+  }
+  return output.substring(0, MAX_OUTPUT_LENGTH3) + "\n...(truncated)";
+}
+var workingDirectory2 = process.cwd();
+function setGitWorkingDirectory(dir) {
+  workingDirectory2 = dir;
+}
+function createGitTool() {
+  return {
+    definition: {
+      name: "git",
+      description: "Execute git commands safely. Supports status, diff, log, add, commit, branch operations. Never force pushes by default.",
+      parameters: [
+        {
+          name: "command",
+          type: "string",
+          description: 'Full git command to execute (e.g. "git status", "git diff HEAD")',
+          required: true
+        }
+      ]
+    },
+    category: "git",
+    requiresApproval: (mode, args) => {
+      const command = typeof args["command"] === "string" ? args["command"] : "";
+      const subcommand = parseGitSubcommand(command);
+      if (hasDangerousFlags(command)) {
+        return true;
+      }
+      if (subcommand && READ_ONLY_SUBCOMMANDS.has(subcommand)) {
+        return false;
+      }
+      if (mode === "strict") {
+        return true;
+      }
+      if (subcommand === "push" && mode === "standard") {
+        return true;
+      }
+      return false;
+    },
+    execute: async (args) => {
+      const command = args["command"];
+      if (typeof command !== "string" || command.length === 0) {
+        return {
+          toolCallId: "",
+          name: "git",
+          content: "command parameter is required and must be a non-empty string.",
+          isError: true
+        };
+      }
+      const trimmedCommand = command.trim();
+      if (!trimmedCommand.startsWith("git ")) {
+        return {
+          toolCallId: "",
+          name: "git",
+          content: 'Command must start with "git".',
+          isError: true
+        };
+      }
+      const subcommand = parseGitSubcommand(trimmedCommand);
+      if (!subcommand || !ALLOWED_SUBCOMMANDS.has(subcommand)) {
+        return {
+          toolCallId: "",
+          name: "git",
+          content: `Git subcommand "${subcommand ?? "unknown"}" is not allowed. Allowed: ${[...ALLOWED_SUBCOMMANDS].join(", ")}`,
+          isError: true
+        };
+      }
+      const lowerCommand = trimmedCommand.toLowerCase();
+      if (subcommand === "push" && (lowerCommand.includes("--force") || lowerCommand.includes(" -f"))) {
+        return {
+          toolCallId: "",
+          name: "git",
+          content: "Force push is blocked by default. Use --force-with-lease if needed (requires approval).",
+          isError: true
+        };
+      }
+      logger.debug({ command: trimmedCommand, subcommand, cwd: workingDirectory2 }, "Executing git command");
+      try {
+        const result = await execaCommand(trimmedCommand, {
+          cwd: workingDirectory2,
+          timeout: GIT_TIMEOUT_MS,
+          reject: false,
+          env: {
+            ...process.env,
+            GIT_TERMINAL_PROMPT: "0",
+            GIT_PAGER: "cat"
+          },
+          stripFinalNewline: true
+        });
+        const stdout = result.stdout ? truncateOutput2(result.stdout) : "";
+        const stderr = result.stderr ? truncateOutput2(result.stderr) : "";
+        let content = "";
+        if (stdout.length > 0) {
+          content += stdout;
+        }
+        if (stderr.length > 0) {
+          content += (content.length > 0 ? "\n\nSTDERR:\n" : "") + stderr;
+        }
+        if (content.length === 0) {
+          content = `Git command completed with exit code ${result.exitCode ?? 0}.`;
+        }
+        const isError = (result.exitCode ?? 0) !== 0;
+        return {
+          toolCallId: "",
+          name: "git",
+          content,
+          isError
+        };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : "Git command failed";
+        logger.error({ command: trimmedCommand, error: msg }, "Git execution failed");
+        return {
+          toolCallId: "",
+          name: "git",
+          content: `Git command failed: ${msg}`,
+          isError: true
+        };
+      }
+    }
+  };
+}
+
+// src/tools/index.ts
+function createDefaultRegistry(context) {
+  setReadProjectRoot(context.projectRoot);
+  setWriteProjectRoot(context.projectRoot);
+  setEditProjectRoot(context.projectRoot);
+  setGlobProjectRoot(context.projectRoot);
+  setGrepProjectRoot(context.projectRoot);
+  setBashWorkingDirectory(context.workingDirectory);
+  setBashBlockedCommands(context.blockedCommands);
+  setGitWorkingDirectory(context.workingDirectory);
+  const registry = new ToolRegistry();
+  registry.register(createReadTool());
+  registry.register(createWriteTool());
+  registry.register(createEditTool());
+  registry.register(createGlobTool());
+  registry.register(createGrepTool());
+  registry.register(createBashTool());
+  registry.register(createWebSearchTool());
+  registry.register(createWebFetchTool());
+  registry.register(createGitTool());
+  return registry;
+}
+
+export { ToolRegistry, createBashTool, createDefaultRegistry, createEditTool, createGitTool, createGlobTool, createGrepTool, createReadTool, createWebFetchTool, createWebSearchTool, createWriteTool, setBashBlockedCommands, setBashWorkingDirectory, setEditProjectRoot, setGitWorkingDirectory, setGlobProjectRoot, setGrepProjectRoot, setReadProjectRoot, setWebSearchProvider, setWriteProjectRoot };
+//# sourceMappingURL=chunk-Y5XVD2CD.js.map
+//# sourceMappingURL=chunk-Y5XVD2CD.js.map