noumen 0.1.0 → 0.2.0

package/dist/chunk-QTJ7VTJY.js

@@ -0,0 +1,1994 @@
+import {
+  IMAGE_EXTENSIONS,
+  compressImageBufferWithTokenLimit,
+  createImageMetadataText,
+  maybeResizeAndDownsampleImageBuffer
+} from "./chunk-5GEX6ZSB.js";
+
+// src/tools/tool-search.ts
+var TOOL_SEARCH_NAME = "ToolSearch";
+function isDeferredTool(tool) {
+  if (tool.alwaysLoad === true) return false;
+  if (tool.mcpInfo !== void 0) return true;
+  if (tool.name === TOOL_SEARCH_NAME) return false;
+  return tool.shouldDefer === true;
+}
+function formatDeferredToolLine(tool) {
+  const desc = tool.description.split(".")[0];
+  return `- ${tool.name}: ${desc}`;
+}
+function parseToolName(name) {
+  if (name.startsWith("mcp__") || name.includes("__")) {
+    const withoutPrefix = name.replace(/^mcp__/, "").toLowerCase();
+    const parts2 = withoutPrefix.split("__").flatMap((p) => p.split("_"));
+    return { parts: parts2.filter(Boolean), full: withoutPrefix.replace(/__/g, " ").replace(/_/g, " "), isMcp: true };
+  }
+  const parts = name.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/_/g, " ").toLowerCase().split(/\s+/).filter(Boolean);
+  return { parts, full: parts.join(" "), isMcp: false };
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function searchToolsWithKeywords(query, deferredTools, allTools, maxResults) {
+  const queryLower = query.toLowerCase().trim();
+  const exactMatch = deferredTools.find((t) => t.name.toLowerCase() === queryLower) ?? allTools.find((t) => t.name.toLowerCase() === queryLower);
+  if (exactMatch) return [exactMatch.name];
+  if (queryLower.startsWith("mcp__") && queryLower.length > 5) {
+    const prefixMatches = deferredTools.filter((t) => t.name.toLowerCase().startsWith(queryLower)).slice(0, maxResults).map((t) => t.name);
+    if (prefixMatches.length > 0) return prefixMatches;
+  }
+  const queryTerms = queryLower.split(/\s+/).filter((t) => t.length > 0);
+  const requiredTerms = [];
+  const optionalTerms = [];
+  for (const term of queryTerms) {
+    if (term.startsWith("+") && term.length > 1) {
+      requiredTerms.push(term.slice(1));
+    } else {
+      optionalTerms.push(term);
+    }
+  }
+  const allScoringTerms = requiredTerms.length > 0 ? [...requiredTerms, ...optionalTerms] : queryTerms;
+  const termPatterns = /* @__PURE__ */ new Map();
+  for (const term of allScoringTerms) {
+    if (!termPatterns.has(term)) {
+      termPatterns.set(term, new RegExp(`\\b${escapeRegExp(term)}\\b`));
+    }
+  }
+  let candidates = deferredTools;
+  if (requiredTerms.length > 0) {
+    candidates = deferredTools.filter((tool) => {
+      const parsed = parseToolName(tool.name);
+      const descLower = tool.description.toLowerCase();
+      return requiredTerms.every((term) => {
+        const pattern = termPatterns.get(term);
+        return parsed.parts.includes(term) || parsed.parts.some((part) => part.includes(term)) || pattern.test(descLower);
+      });
+    });
+  }
+  const scored = candidates.map((tool) => {
+    const parsed = parseToolName(tool.name);
+    const descLower = tool.description.toLowerCase();
+    let score = 0;
+    for (const term of allScoringTerms) {
+      const pattern = termPatterns.get(term);
+      if (parsed.parts.includes(term)) {
+        score += parsed.isMcp ? 12 : 10;
+      } else if (parsed.parts.some((part) => part.includes(term))) {
+        score += parsed.isMcp ? 6 : 5;
+      }
+      if (parsed.full.includes(term) && score === 0) {
+        score += 3;
+      }
+      if (pattern.test(descLower)) {
+        score += 2;
+      }
+    }
+    return { name: tool.name, score };
+  });
+  return scored.filter((item) => item.score > 0).sort((a, b) => b.score - a.score).slice(0, maxResults).map((item) => item.name);
+}
+function formatToolSchemas(tools) {
+  if (tools.length === 0) return "No matching deferred tools found.";
+  const lines = tools.map((t) => {
+    const schema = {
+      description: t.description,
+      name: t.name,
+      parameters: t.parameters
+    };
+    return `<function>${JSON.stringify(schema)}</function>`;
+  });
+  return `<functions>
+${lines.join("\n")}
+</functions>`;
+}
+function createToolSearchTool(getDeferredTools, getAllTools, getToolsByNames, onDiscovered) {
+  return {
+    name: TOOL_SEARCH_NAME,
+    description: 'Fetches full schema definitions for deferred tools so they can be called. Deferred tools appear by name in <available-deferred-tools> sections. Until fetched, only the name is known \u2014 there is no parameter schema, so the tool cannot be invoked. Use this tool to load tool schemas.\n\nQuery forms:\n- "select:Read,Edit,Grep" \u2014 fetch these exact tools by name\n- "notebook jupyter" \u2014 keyword search, up to max_results best matches\n- "+slack send" \u2014 require "slack" in the name, rank by remaining terms',
+    isReadOnly: true,
+    isConcurrencySafe: true,
+    parameters: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: 'Query to find deferred tools. Use "select:<tool_name>" for direct selection, or keywords to search.'
+        },
+        max_results: {
+          type: "number",
+          description: "Maximum number of results to return (default: 5)"
+        }
+      },
+      required: ["query"]
+    },
+    async call(args) {
+      const query = args.query;
+      const maxResults = args.max_results ?? 5;
+      const deferredTools = getDeferredTools();
+      const allTools = getAllTools();
+      const selectMatch = query.match(/^select:(.+)$/i);
+      if (selectMatch) {
+        const requested = selectMatch[1].split(",").map((s) => s.trim()).filter(Boolean);
+        const found = [];
+        for (const toolName of requested) {
+          const match = deferredTools.find((t) => t.name.toLowerCase() === toolName.toLowerCase()) ?? allTools.find((t) => t.name.toLowerCase() === toolName.toLowerCase());
+          if (match && !found.includes(match.name)) {
+            found.push(match.name);
+          }
+        }
+        if (found.length === 0) {
+          return {
+            content: JSON.stringify({
+              matches: [],
+              query,
+              total_deferred_tools: deferredTools.length
+            })
+          };
+        }
+        onDiscovered(found);
+        const matchedTools2 = getToolsByNames(found);
+        return { content: formatToolSchemas(matchedTools2) };
+      }
+      const matches = searchToolsWithKeywords(query, deferredTools, allTools, maxResults);
+      if (matches.length === 0) {
+        return {
+          content: JSON.stringify({
+            matches: [],
+            query,
+            total_deferred_tools: deferredTools.length
+          })
+        };
+      }
+      onDiscovered(matches);
+      const matchedTools = getToolsByNames(matches);
+      return { content: formatToolSchemas(matchedTools) };
+    }
+  };
+}
+
+// src/utils/zod.ts
+var cache = /* @__PURE__ */ new WeakMap();
+function zodToJsonSchema(schema) {
+  const hit = cache.get(schema);
+  if (hit) return hit;
+  const zod = schema._zod ? schema : void 0;
+  if (!zod) {
+    throw new Error(
+      "zodToJsonSchema requires a Zod v4 schema. Install zod and pass a z.object(\u2026) schema."
+    );
+  }
+  let toJSONSchema;
+  try {
+    const sAny = schema;
+    if (typeof sAny._toJSONSchema === "function") {
+      const result = sAny._toJSONSchema();
+      cache.set(schema, result);
+      return result;
+    }
+    toJSONSchema = globalThis.__noumen_toJSONSchema;
+  } catch {
+  }
+  if (toJSONSchema) {
+    const result = toJSONSchema(schema);
+    cache.set(schema, result);
+    return result;
+  }
+  throw new Error(
+    "Could not convert Zod schema to JSON Schema. Call `registerZodToJsonSchema(toJSONSchema)` from zod/v4 or upgrade to Zod v4."
+  );
+}
+function registerZodToJsonSchema(fn) {
+  globalThis.__noumen_toJSONSchema = fn;
+}
+function formatZodValidationError(toolName, issues) {
+  if (!issues || !issues.issues.length) {
+    return `${toolName}: validation failed with unknown error`;
+  }
+  const parts = [];
+  const missing = issues.issues.filter(
+    (i) => i.code === "invalid_type" && i.message.includes("required")
+  );
+  const unrecognized = issues.issues.filter(
+    (i) => i.code === "unrecognized_keys"
+  );
+  const other = issues.issues.filter(
+    (i) => !missing.includes(i) && !unrecognized.includes(i)
+  );
+  if (missing.length) {
+    parts.push(
+      `Missing required parameter${missing.length > 1 ? "s" : ""}: ${missing.map((m) => formatPath(m.path)).join(", ")}`
+    );
+  }
+  if (unrecognized.length) {
+    parts.push(
+      `Unrecognized parameter${unrecognized.length > 1 ? "s" : ""}: ${unrecognized.map((u) => u.message).join(", ")}`
+    );
+  }
+  for (const issue of other) {
+    const path2 = formatPath(issue.path);
+    parts.push(`${path2 ? path2 + ": " : ""}${issue.message}`);
+  }
+  return `${toolName} failed due to the following ${parts.length > 1 ? "issues" : "issue"}:
+${parts.join("\n")}`;
+}
+function formatPath(path2) {
+  return path2.map((p, i) => typeof p === "number" ? `[${p}]` : i > 0 ? `.${p}` : p).join("");
+}
+
+// src/tools/prompts/read.ts
+var READ_PROMPT = `Reads a file from the local filesystem. You can access any file directly by using this tool.
+Assume this tool is able to read all files on the machine. If the User provides a path to a file assume that path is valid. It is okay to read a file that does not exist; an error will be returned.
+
+Usage:
+- The file_path parameter must be an absolute path, not a relative path.
+- By default, it reads the entire file. Use offset and limit to read specific portions of large files.
+- Lines in the output are numbered with the format: LINE_NUMBER|LINE_CONTENT
+- If you read a file that exists but has empty contents you will receive a notice in place of file contents.
+- This tool can read image files (e.g. PNG, JPG) when the provider supports multimodal input.
+- This tool can read Jupyter notebooks (.ipynb files) and returns all cells with their outputs.
+- This tool can only read files, not directories. To list a directory, use an ls command via the Bash tool.
+- If the file has not changed since the last read, a "file_unchanged" result is returned to save context tokens.
+`;
+
+// src/tools/read.ts
+import * as path from "path";
+var DEFAULT_MAX_IMAGE_TOKENS = 1600;
+var MAX_FILE_SIZE = 10 * 1024 * 1024;
+var BLOCKED_DEVICE_PATHS = /* @__PURE__ */ new Set([
+  "/dev/zero",
+  "/dev/random",
+  "/dev/urandom",
+  "/dev/full",
+  "/dev/stdin",
+  "/dev/tty",
+  "/dev/console",
+  "/dev/stdout",
+  "/dev/stderr",
+  "/dev/fd/0",
+  "/dev/fd/1",
+  "/dev/fd/2"
+]);
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".bin",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".bz2",
+  ".xz",
+  ".7z",
+  ".rar",
+  ".wasm",
+  ".o",
+  ".a",
+  ".obj",
+  ".lib",
+  ".class",
+  ".pyc",
+  ".pyo",
+  ".jar",
+  ".war",
+  ".ear",
+  ".iso",
+  ".img",
+  ".dmg",
+  ".msi",
+  ".deb",
+  ".rpm",
+  ".apk",
+  ".ipa"
+]);
+var readFileTool = {
+  name: "ReadFile",
+  description: "Read a file from the filesystem. Returns the file content with line numbers. For image files (.png, .jpg, .jpeg, .gif, .webp), returns the image data directly. Use offset and limit to read specific portions of large text files.",
+  prompt: READ_PROMPT,
+  isReadOnly: true,
+  isConcurrencySafe: true,
+  parameters: {
+    type: "object",
+    properties: {
+      file_path: {
+        type: "string",
+        description: "The path of the file to read (absolute or relative to cwd)"
+      },
+      offset: {
+        type: "number",
+        description: "Line number to start reading from (1-indexed). Defaults to 1.",
+        minimum: 1
+      },
+      limit: {
+        type: "number",
+        description: "Maximum number of lines to read. If omitted, reads entire file.",
+        minimum: 1
+      }
+    },
+    required: ["file_path"]
+  },
+  async call(args, ctx) {
+    const filePath = args.file_path;
+    const offset = args.offset ?? 1;
+    const limit = args.limit;
+    try {
+      const resolved = path.resolve(ctx.cwd, filePath);
+      if (BLOCKED_DEVICE_PATHS.has(resolved)) {
+        return {
+          content: `Error: Cannot read device file ${filePath}.`,
+          isError: true
+        };
+      }
+      const ext = path.extname(filePath).toLowerCase();
+      if (BINARY_EXTENSIONS.has(ext)) {
+        return {
+          content: `Error: Cannot read binary ${ext} file. This tool only reads text files.`,
+          isError: true
+        };
+      }
+      if (IMAGE_EXTENSIONS.has(ext) && ctx.fs.readFileBytes) {
+        return readImageFile(filePath, ext, ctx);
+      }
+      try {
+        const stat = await ctx.fs.stat(filePath);
+        if (stat.size !== void 0 && stat.size > MAX_FILE_SIZE) {
+          return {
+            content: `Error: File is too large (${Math.round(stat.size / 1024 / 1024)}MB). Use offset/limit to read specific portions.`,
+            isError: true
+          };
+        }
+      } catch {
+      }
+      if (ctx.fileStateCache) {
+        const cached = ctx.fileStateCache.get(filePath);
+        if (cached && !cached.isPartialView && cached.offset !== void 0 && cached.offset === offset && cached.limit === limit) {
+          try {
+            const stat = await ctx.fs.stat(filePath);
+            const mtime = stat.modifiedAt ? Math.floor(stat.modifiedAt.getTime()) : 0;
+            if (mtime === cached.timestamp) {
+              return { content: "file_unchanged" };
+            }
+          } catch {
+          }
+        }
+      }
+      const content = await ctx.fs.readFile(filePath);
+      const lines = content.split("\n");
+      const startIdx = Math.max(0, offset - 1);
+      const endIdx = limit ? Math.min(lines.length, startIdx + limit) : lines.length;
+      const selectedLines = lines.slice(startIdx, endIdx);
+      const numbered = selectedLines.map(
+        (line, i) => `${String(startIdx + i + 1).padStart(6)}|${line}`
+      );
+      let result = numbered.join("\n");
+      if (endIdx < lines.length) {
+        result += `
+... ${lines.length - endIdx} lines not shown ...`;
+      }
+      if (ctx.fileStateCache) {
+        let mtime = 0;
+        try {
+          const stat = await ctx.fs.stat(filePath);
+          mtime = stat.modifiedAt ? Math.floor(stat.modifiedAt.getTime()) : 0;
+        } catch {
+        }
+        ctx.fileStateCache.set(filePath, {
+          content: selectedLines.join("\n"),
+          timestamp: mtime,
+          offset,
+          limit
+        });
+      }
+      return { content: result || "File is empty." };
+    } catch (err) {
+      return {
+        content: `Error reading file: ${err instanceof Error ? err.message : String(err)}`,
+        isError: true
+      };
+    }
+  }
+};
+async function readImageFile(filePath, ext, ctx) {
+  const imageBuffer = await ctx.fs.readFileBytes(filePath);
+  const originalSize = imageBuffer.length;
+  const formatExt = ext.replace(/^\./, "");
+  const resized = await maybeResizeAndDownsampleImageBuffer(
+    imageBuffer,
+    originalSize,
+    formatExt
+  );
+  let base64 = resized.buffer.toString("base64");
+  let mediaType = resized.mediaType;
+  const estimatedTokens = Math.ceil(base64.length * 0.125);
+  if (estimatedTokens > DEFAULT_MAX_IMAGE_TOKENS) {
+    try {
+      const compressed = await compressImageBufferWithTokenLimit(
+        imageBuffer,
+        DEFAULT_MAX_IMAGE_TOKENS,
+        `image/${formatExt}`
+      );
+      base64 = compressed.base64;
+      mediaType = compressed.mediaType;
+    } catch {
+    }
+  }
+  const parts = [
+    {
+      type: "image",
+      data: base64,
+      media_type: `image/${mediaType}`
+    }
+  ];
+  if (resized.dimensions) {
+    parts.push({
+      type: "text",
+      text: createImageMetadataText(resized.dimensions)
+    });
+  }
+  return { content: parts };
+}
+
+// src/tools/prompts/write.ts
+var WRITE_PROMPT = `Writes a file to the local filesystem. Parent directories are created automatically if they don't exist.
+
+Usage:
+- This tool will overwrite the existing file if there is one at the provided path.
+- If this is an existing file, you MUST use the ReadFile tool first to read the file's contents. This tool will fail if you did not read the file first.
+- Prefer the EditFile tool for modifying existing files \u2014 it only sends the diff. Only use this tool to create new files or for complete rewrites.
+- NEVER create documentation files (*.md) or README files unless explicitly requested by the User.
+- Only use emojis if the user explicitly requests it. Avoid writing emojis to files unless asked.
+`;
+
+// src/tools/write.ts
+var writeFileTool = {
+  name: "WriteFile",
+  description: "Create or overwrite a file with the given content. Parent directories are created automatically if they don't exist.",
+  prompt: WRITE_PROMPT,
+  isReadOnly: false,
+  checkPermissions(args) {
+    const filePath = args.file_path;
+    return {
+      behavior: "passthrough",
+      message: `Write to ${filePath}`
+    };
+  },
+  parameters: {
+    type: "object",
+    properties: {
+      file_path: {
+        type: "string",
+        description: "The path of the file to write (absolute or relative to cwd)"
+      },
+      content: {
+        type: "string",
+        description: "The content to write to the file"
+      }
+    },
+    required: ["file_path", "content"]
+  },
+  async call(args, ctx) {
+    const filePath = args.file_path;
+    const content = args.content;
+    try {
+      if (ctx.checkpointManager && ctx.currentMessageId) {
+        await ctx.checkpointManager.trackEdit(filePath, ctx.currentMessageId, ctx.sessionId ?? "");
+      }
+      const existed = await ctx.fs.exists(filePath);
+      if (existed && ctx.fileStateCache) {
+        const cached = ctx.fileStateCache.get(filePath);
+        if (!cached) {
+          return {
+            content: `Error: File ${filePath} exists but has not been read yet. Read it first before overwriting.`,
+            isError: true
+          };
+        }
+      }
+      await ctx.fs.writeFile(filePath, content);
+      ctx.notifyHook?.("FileWrite", {
+        event: "FileWrite",
+        sessionId: ctx.sessionId ?? "",
+        toolName: "WriteFile",
+        filePath,
+        isNew: !existed
+      }).catch(() => {
+      });
+      if (ctx.fileStateCache) {
+        let mtime = 0;
+        try {
+          const stat = await ctx.fs.stat(filePath);
+          mtime = stat.modifiedAt ? Math.floor(stat.modifiedAt.getTime()) : 0;
+        } catch {
+        }
+        ctx.fileStateCache.set(filePath, {
+          content,
+          timestamp: mtime
+        });
+      }
+      return {
+        content: existed ? `File updated successfully at: ${filePath}` : `File created successfully at: ${filePath}`
+      };
+    } catch (err) {
+      return {
+        content: `Error writing file: ${err instanceof Error ? err.message : String(err)}`,
+        isError: true
+      };
+    }
+  }
+};
+
+// src/tools/edit-utils.ts
+var LEFT_SINGLE_CURLY = "\u2018";
+var RIGHT_SINGLE_CURLY = "\u2019";
+var LEFT_DOUBLE_CURLY = "\u201C";
+var RIGHT_DOUBLE_CURLY = "\u201D";
+function normalizeQuotes(str) {
+  return str.replaceAll(LEFT_SINGLE_CURLY, "'").replaceAll(RIGHT_SINGLE_CURLY, "'").replaceAll(LEFT_DOUBLE_CURLY, '"').replaceAll(RIGHT_DOUBLE_CURLY, '"');
+}
+function findActualString(fileContent, searchString) {
+  if (fileContent.includes(searchString)) {
+    return searchString;
+  }
+  const normalizedSearch = normalizeQuotes(searchString);
+  const normalizedFile = normalizeQuotes(fileContent);
+  const searchIndex = normalizedFile.indexOf(normalizedSearch);
+  if (searchIndex !== -1) {
+    return fileContent.substring(searchIndex, searchIndex + searchString.length);
+  }
+  return null;
+}
+function countOccurrences(haystack, needle) {
+  const normalizedNeedle = normalizeQuotes(needle);
+  const normalizedHaystack = normalizeQuotes(haystack);
+  let count = 0;
+  let pos = 0;
+  while (true) {
+    const idx = normalizedHaystack.indexOf(normalizedNeedle, pos);
+    if (idx === -1) break;
+    count++;
+    pos = idx + 1;
+  }
+  return count;
+}
+function usesCurlyQuotes(str) {
+  return {
+    singleCurly: str.includes(LEFT_SINGLE_CURLY) || str.includes(RIGHT_SINGLE_CURLY),
+    doubleCurly: str.includes(LEFT_DOUBLE_CURLY) || str.includes(RIGHT_DOUBLE_CURLY)
+  };
+}
+function preserveQuoteStyle(oldString, actualOldString, newString) {
+  if (oldString === actualOldString) {
+    return newString;
+  }
+  const fileStyle = usesCurlyQuotes(actualOldString);
+  let result = newString;
+  if (fileStyle.singleCurly) {
+    result = convertStraightToCurlySingle(result);
+  }
+  if (fileStyle.doubleCurly) {
+    result = convertStraightToCurlyDouble(result);
+  }
+  return result;
+}
+function convertStraightToCurlySingle(str) {
+  let result = "";
+  let inWord = false;
+  for (let i = 0; i < str.length; i++) {
+    const ch = str[i];
+    if (ch === "'") {
+      const prev = i > 0 ? str[i - 1] : " ";
+      if (/\s/.test(prev) || prev === "(" || prev === "[" || prev === "{") {
+        result += LEFT_SINGLE_CURLY;
+        inWord = true;
+      } else {
+        result += RIGHT_SINGLE_CURLY;
+        inWord = false;
+      }
+    } else {
+      result += ch;
+      inWord = /\w/.test(ch);
+    }
+  }
+  return result;
+}
+function convertStraightToCurlyDouble(str) {
+  let result = "";
+  let open = true;
+  for (let i = 0; i < str.length; i++) {
+    const ch = str[i];
+    if (ch === '"') {
+      result += open ? LEFT_DOUBLE_CURLY : RIGHT_DOUBLE_CURLY;
+      open = !open;
+    } else {
+      result += ch;
+    }
+  }
+  return result;
+}
+function stripTrailingWhitespace(str) {
+  const parts = str.split(/(\r\n|\n|\r)/);
+  const result = [];
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (i % 2 === 0) {
+      result.push(part.replace(/[\t ]+$/, ""));
+    } else {
+      result.push(part);
+    }
+  }
+  return result.join("");
+}
+
+// src/tools/prompts/edit.ts
+var EDIT_PROMPT = `Performs exact string replacements in files.
+
+Usage:
+- You must use the ReadFile tool at least once before editing a file. This tool will error if you attempt an edit without reading the file first.
+- When editing text from ReadFile output, ensure you preserve the exact indentation (tabs/spaces) as it appears AFTER the line number prefix. The line number prefix format is: spaces + line number + pipe. Everything after that is the actual file content to match. Never include any part of the line number prefix in the old_string or new_string.
+- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.
+- Only use emojis if the user explicitly requests it. Avoid adding emojis to files unless asked.
+- The edit will FAIL if \`old_string\` is not unique in the file. Either provide a larger string with more surrounding context to make it unique or use \`replace_all\` to change every instance of \`old_string\`.
+- Use \`replace_all\` for replacing and renaming strings across the file. This parameter is useful if you want to rename a variable for instance.
+`;
+
+// src/tools/edit.ts
+var editFileTool = {
+  name: "EditFile",
+  description: "Edit a file by replacing an exact string match with new content. The old_string must match exactly (including whitespace and indentation). Set replace_all to true to replace all occurrences.",
+  prompt: EDIT_PROMPT,
+  isReadOnly: false,
+  checkPermissions(args) {
+    const filePath = args.file_path;
+    return {
+      behavior: "passthrough",
+      message: `Edit ${filePath}`
+    };
+  },
+  parameters: {
+    type: "object",
+    properties: {
+      file_path: {
+        type: "string",
+        description: "The path of the file to edit"
+      },
+      old_string: {
+        type: "string",
+        description: "The exact string to find and replace"
+      },
+      new_string: {
+        type: "string",
+        description: "The replacement string"
+      },
+      replace_all: {
+        type: "boolean",
+        description: "If true, replace all occurrences of old_string. Defaults to false."
+      }
+    },
+    required: ["file_path", "old_string", "new_string"]
+  },
+  async call(args, ctx) {
+    const filePath = args.file_path;
+    const oldString = args.old_string;
+    const newString = args.new_string;
+    const replaceAll = args.replace_all ?? false;
+    if (filePath.endsWith(".ipynb")) {
+      return {
+        content: `Error: ${filePath} is a Jupyter Notebook. Use the NotebookEdit tool to edit notebook files.`,
+        isError: true
+      };
+    }
+    if (oldString === newString) {
+      return {
+        content: "No changes to make: old_string and new_string are exactly the same.",
+        isError: true
+      };
+    }
+    try {
+      if (ctx.fileStateCache) {
+        const cached = ctx.fileStateCache.get(filePath);
+        if (!cached || cached.isPartialView) {
+          return {
+            content: `Error: File has not been read yet. Use ReadFile on ${filePath} before editing.`,
+            isError: true
+          };
+        }
+        try {
+          const stat = await ctx.fs.stat(filePath);
+          const mtime = stat.modifiedAt ? Math.floor(stat.modifiedAt.getTime()) : 0;
+          if (mtime > cached.timestamp) {
+            const currentContent = await ctx.fs.readFile(filePath);
+            if (currentContent !== cached.content) {
+              return {
+                content: `Error: ${filePath} has been modified since last read. Re-read the file before editing.`,
+                isError: true
+              };
+            }
+          }
+        } catch {
+        }
+      }
+      if (ctx.checkpointManager && ctx.currentMessageId) {
+        await ctx.checkpointManager.trackEdit(filePath, ctx.currentMessageId, ctx.sessionId ?? "");
+      }
+      const content = await ctx.fs.readFile(filePath);
+      const actualOldString = findActualString(content, oldString);
+      if (!actualOldString) {
+        return {
+          content: `Error: old_string not found in ${filePath}. Make sure the string matches exactly, including whitespace and indentation.`,
+          isError: true
+        };
+      }
+      if (!replaceAll) {
+        const count = content.split(actualOldString).length - 1;
+        if (count > 1) {
+          return {
+            content: `Error: old_string appears ${count} times in ${filePath}. Provide more context to make it unique, or set replace_all to true.`,
+            isError: true
+          };
+        }
+      }
+      const actualNewString = preserveQuoteStyle(oldString, actualOldString, newString);
+      let updated;
+      if (replaceAll) {
+        updated = content.split(actualOldString).join(actualNewString);
+      } else if (actualNewString === "") {
+        const hasTrailingNewline = !actualOldString.endsWith("\n") && content.includes(actualOldString + "\n");
+        const deleteTarget = hasTrailingNewline ? actualOldString + "\n" : actualOldString;
+        updated = content.replace(deleteTarget, () => actualNewString);
+      } else {
+        updated = content.replace(actualOldString, () => actualNewString);
+      }
+      await ctx.fs.writeFile(filePath, updated);
+      ctx.notifyHook?.("FileWrite", {
+        event: "FileWrite",
+        sessionId: ctx.sessionId ?? "",
+        toolName: "EditFile",
+        filePath,
+        isNew: false
+      }).catch(() => {
+      });
+      if (ctx.fileStateCache) {
+        let mtime = 0;
+        try {
+          const stat = await ctx.fs.stat(filePath);
+          mtime = stat.modifiedAt ? Math.floor(stat.modifiedAt.getTime()) : 0;
+        } catch {
+        }
+        ctx.fileStateCache.set(filePath, {
+          content: updated,
+          timestamp: mtime
+        });
+      }
+      return {
+        content: `File ${filePath} has been updated successfully.`
+      };
+    } catch (err) {
+      return {
+        content: `Error editing file: ${err instanceof Error ? err.message : String(err)}`,
+        isError: true
+      };
+    }
+  }
+};
+
+// src/tools/shell-safety/git-safety.ts
+var GIT_INTERNAL_PATTERNS = [
+  /\.git\/hooks\//,
+  /\.git\/config$/,
+  /\.git\/info\//,
+  /\.git\/objects\//,
+  /\.git\/refs\//,
+  /\.git\/HEAD$/,
+  /\.git\/index$/,
+  /\.git\/packed-refs$/,
+  /\.git\/shallow$/,
+  /\.git\/modules\//
+];
+function isGitInternalPath(path2) {
+  const normalized = path2.replace(/\\/g, "/");
+  return GIT_INTERNAL_PATTERNS.some((p) => p.test(normalized));
+}
+var BARE_REPO_MARKERS = ["HEAD", "objects", "refs"];
+function looksLikeBareRepo(dirEntries) {
+  const entrySet = new Set(dirEntries.map((e) => e.replace(/\/$/, "")));
+  if (entrySet.has(".git")) return false;
+  return BARE_REPO_MARKERS.every((m) => entrySet.has(m));
+}
+function commandWritesGitInternals(command) {
+  const redirectPattern = /(?:>{1,2}|tee\s+)\s*(\S+)/g;
+  let match;
+  while ((match = redirectPattern.exec(command)) !== null) {
+    if (isGitInternalPath(match[1])) return true;
+  }
+  const copyPattern = /\b(?:cp|mv|ln)\b.*\s(\S*\.git\/\S+)/;
+  const copyMatch = command.match(copyPattern);
+  if (copyMatch && isGitInternalPath(copyMatch[1])) return true;
+  return false;
+}
+
+// src/tools/shell-safety/command-classification.ts
+var READ_ONLY_COMMANDS = /* @__PURE__ */ new Set([
+  "cat",
+  "head",
+  "tail",
+  "less",
+  "more",
+  "wc",
+  "file",
+  "which",
+  "whence",
+  "where",
+  "whereis",
+  "type",
+  "pwd",
+  "date",
+  "uname",
+  "hostname",
+  "whoami",
+  "id",
+  "groups",
+  "ls",
+  "ll",
+  "la",
+  "dir",
+  "tree",
+  "stat",
+  "du",
+  "df",
+  "free",
+  "uptime",
+  "ps",
+  "top",
+  "htop",
+  "lsof",
+  "ss",
+  "netstat",
+  "ifconfig",
+  "ip",
+  "ping",
+  "dig",
+  "nslookup",
+  "host",
+  "traceroute",
+  "grep",
+  "egrep",
+  "fgrep",
+  "rg",
+  "ag",
+  "ack",
+  "find",
+  "fd",
+  "fdfind",
+  "locate",
+  "readlink",
+  "realpath",
+  "basename",
+  "dirname",
+  "diff",
+  "comm",
+  "sort",
+  "uniq",
+  "cut",
+  "tr",
+  "awk",
+  "sed",
+  // sed -i is destructive but caught by destructive patterns
+  "jq",
+  "yq",
+  "xxd",
+  "hexdump",
+  "od",
+  "md5sum",
+  "sha256sum",
+  "shasum",
+  "base64",
+  "true",
+  "false",
+  "test",
+  "[",
+  "[[",
+  "man",
+  "help",
+  "info",
+  "nproc",
+  "arch",
+  "lscpu",
+  "lsb_release",
+  "sw_vers",
+  "sysctl",
+  "getconf",
+  "dotnet"
+  // dotnet --info, dotnet --list-sdks
+]);
+var GIT_READ_ONLY_SUBCOMMANDS = /* @__PURE__ */ new Set([
+  "status",
+  "log",
+  "diff",
+  "show",
+  "blame",
+  "shortlog",
+  "describe",
+  "rev-parse",
+  "rev-list",
+  "cat-file",
+  "ls-files",
+  "ls-tree",
+  "ls-remote",
+  "name-rev",
+  "for-each-ref",
+  "count-objects",
+  "fsck",
+  "verify-pack",
+  "reflog",
+  "stash",
+  // "stash list" / "stash show" — stash apply/pop are not here
+  "tag",
+  // "tag -l" is safe; "tag <name>" creates — caught below
+  "branch",
+  // "branch --list" is safe; "branch <name>" creates — caught below
+  "remote",
+  // "remote -v" safe; "remote add/remove" — caught below
+  "config",
+  // "config --list/--get" safe
+  "help",
+  "version",
+  "--version",
+  "--help"
+]);
+var GIT_MUTATING_SUBCOMMANDS = /* @__PURE__ */ new Set([
+  "push",
+  "pull",
+  "fetch",
+  "merge",
+  "rebase",
+  "cherry-pick",
+  "revert",
+  "commit",
+  "add",
+  "rm",
+  "mv",
+  "init",
+  "clone",
+  "checkout",
+  "switch",
+  "restore",
+  "reset",
+  "clean",
+  "bisect",
+  "am",
+  "apply",
+  "format-patch",
+  "submodule",
+  "worktree"
+]);
+var DESTRUCTIVE_PATTERNS = [
+  // rm -rf / rm -r / rm --recursive (but not plain rm single-file)
+  /\brm\s+(-[a-zA-Z]*[rR][a-zA-Z]*|--recursive)\b/,
+  // rm on root-like paths
+  /\brm\s+.*\s+\/($|\s)/,
+  // git force operations
+  /\bgit\s+push\s+.*--force\b/,
+  /\bgit\s+push\s+-f\b/,
+  /\bgit\s+reset\s+--hard\b/,
+  /\bgit\s+clean\s+.*-[a-zA-Z]*f/,
+  /\bgit\s+checkout\s+--\s+\./,
+  // Filesystem destruction
+  /\bchmod\s+(-[a-zA-Z]*R[a-zA-Z]*|--recursive)\s+777\b/,
+  /\bchown\s+(-[a-zA-Z]*R[a-zA-Z]*|--recursive)\b/,
+  /\bdd\s+/,
+  /\bmkfs\b/,
+  /\bformat\b/,
+  /\bfdisk\b/,
+  // Dangerous redirects
+  />\s*\/dev\/sd[a-z]/,
+  // Database destructive operations
+  /\bDROP\s+(TABLE|DATABASE|SCHEMA)\b/i,
+  /\bTRUNCATE\s+TABLE\b/i,
+  /\bDELETE\s+FROM\b/i,
+  // sed in-place
+  /\bsed\s+(-[a-zA-Z]*i[a-zA-Z]*|--in-place)\b/,
+  // Container/system destruction
+  /\bdocker\s+(rm|rmi|system\s+prune|volume\s+rm)\b/,
+  /\bkubectl\s+delete\b/,
+  // Kill processes
+  /\bkill\s+-9\b/,
+  /\bkillall\b/,
+  /\bpkill\b/,
+  // Recursive operations on root
+  /\bfind\s+\/\s+.*-delete\b/,
+  /\bfind\s+\/\s+.*-exec\s+rm\b/
+];
+var SAFE_ECHO_RE = /^(?:echo|printf)(?:\s+(?:'[^']*'|[^|;&`$(){}><#\\!"'\s]+))*(?:\s+2>&1)?\s*$/;
+function hasTokenFlag(tokens, ...flags) {
+  return tokens.some((t) => flags.includes(t));
+}
+function splitCompoundCommand(command) {
+  return command.split(/\s*(?:;|&&|\|\||(?<!\|)\|(?!\|))\s*/).map((s) => s.trim()).filter(Boolean);
+}
+function stripPrefixes(command) {
+  let cmd = command.trim();
+  while (/^[A-Za-z_][A-Za-z0-9_]*=\S*\s/.test(cmd)) {
+    cmd = cmd.replace(/^[A-Za-z_][A-Za-z0-9_]*=\S*\s+/, "");
+  }
+  for (const prefix of ["sudo", "env", "nohup", "time", "nice", "ionice", "strace", "ltrace"]) {
+    if (cmd.startsWith(prefix + " ")) {
+      cmd = cmd.slice(prefix.length).trim();
+      while (cmd.startsWith("-")) {
+        const spaceIdx = cmd.indexOf(" ");
+        if (spaceIdx === -1) break;
+        cmd = cmd.slice(spaceIdx).trim();
+      }
+      while (/^[A-Za-z_][A-Za-z0-9_]*=\S*\s/.test(cmd)) {
+        cmd = cmd.replace(/^[A-Za-z_][A-Za-z0-9_]*=\S*\s+/, "");
+      }
+    }
+  }
+  return cmd;
+}
+function extractCommandName(command) {
+  const cmd = stripPrefixes(command);
+  const firstToken = cmd.split(/\s/)[0] ?? "";
+  const base = firstToken.includes("/") ? firstToken.split("/").pop() : firstToken;
+  return base;
+}
+function classifyGitCommand(command) {
+  if (/\bgit\s+--version\b/.test(command)) {
+    return { isReadOnly: true, isDestructive: false, reason: "git --version is read-only" };
+  }
+  if (/\bgit\s+--help\b/.test(command)) {
+    return { isReadOnly: true, isDestructive: false, reason: "git --help is read-only" };
+  }
+  if (/\bgit\s+(-c\s|--exec-path=|--config-env=)/.test(command)) {
+    return { isReadOnly: false, isDestructive: true, reason: "git config injection vector (-c/--exec-path/--config-env)" };
+  }
+  const match = command.match(/\bgit\s+(?:--[a-z-]+=?\S*\s+)*([a-z][a-z-]*)/);
+  if (!match) {
+    return { isReadOnly: false, isDestructive: false, reason: "Cannot parse git subcommand" };
+  }
+  const subcommand = match[1];
+  if (GIT_READ_ONLY_SUBCOMMANDS.has(subcommand)) {
+    const afterSubcmd = command.slice(command.indexOf(subcommand) + subcommand.length).trim();
+    const tokens = afterSubcmd.split(/\s+/).filter(Boolean);
+    const positional = tokens.filter((t) => !t.startsWith("-"));
+    const flags = tokens.filter((t) => t.startsWith("-"));
+    if (subcommand === "branch") {
+      if (hasTokenFlag(flags, "--list", "-l")) {
+        return { isReadOnly: true, isDestructive: false, reason: "git branch --list is read-only" };
+      }
+      if (hasTokenFlag(flags, "-d", "-D", "--delete")) {
+        return { isReadOnly: false, isDestructive: true, reason: "git branch delete" };
+      }
+      if (positional.length > 0) {
+        return { isReadOnly: false, isDestructive: false, reason: "git branch create" };
+      }
+    }
+    if (subcommand === "tag") {
+      if (hasTokenFlag(flags, "-l", "--list")) {
+        return { isReadOnly: true, isDestructive: false, reason: "git tag --list is read-only" };
+      }
+      if (hasTokenFlag(flags, "-d", "-D", "--delete")) {
+        return { isReadOnly: false, isDestructive: true, reason: "git tag delete" };
+      }
+      if (positional.length > 0) {
+        return { isReadOnly: false, isDestructive: false, reason: "git tag create" };
+      }
+    }
+    if (subcommand === "stash") {
+      const stashSubcmd = positional[0];
+      if (stashSubcmd === "list" || stashSubcmd === "show") {
+        return { isReadOnly: true, isDestructive: false, reason: `git stash ${stashSubcmd} is read-only` };
+      }
+      if (stashSubcmd === "drop" || stashSubcmd === "clear") {
+        return { isReadOnly: false, isDestructive: true, reason: "git stash destructive operation" };
+      }
+      return { isReadOnly: false, isDestructive: false, reason: "git stash mutating operation" };
+    }
+    if (subcommand === "config") {
+      if (hasTokenFlag(flags, "--set", "--add", "--unset", "--unset-all", "--replace-all", "--rename-section", "--remove-section")) {
+        return { isReadOnly: false, isDestructive: false, reason: "git config write operation" };
+      }
+      if (positional.length >= 2) {
+        return { isReadOnly: false, isDestructive: false, reason: "git config set key value" };
+      }
+    }
+    if (subcommand === "remote") {
+      const remoteSubcmd = positional[0];
+      if (remoteSubcmd && ["add", "remove", "rename", "set-url", "set-branches", "prune"].includes(remoteSubcmd)) {
+        return { isReadOnly: false, isDestructive: false, reason: "git remote mutating operation" };
+      }
+    }
+    return { isReadOnly: true, isDestructive: false, reason: `git ${subcommand} is read-only` };
+  }
+  if (GIT_MUTATING_SUBCOMMANDS.has(subcommand)) {
+    for (const pattern of DESTRUCTIVE_PATTERNS) {
+      if (pattern.test(command)) {
+        return { isReadOnly: false, isDestructive: true, reason: `Destructive: ${pattern.source}` };
+      }
+    }
+    return { isReadOnly: false, isDestructive: false, reason: `git ${subcommand} is mutating` };
+  }
+  return { isReadOnly: false, isDestructive: false, reason: `Unknown git subcommand: ${subcommand}` };
+}
+function classifySingleCommand(command, config) {
+  const name = extractCommandName(command);
+  if (!name) {
+    return { isReadOnly: false, isDestructive: false, reason: "Empty command" };
+  }
+  const allDestructive = [
+    ...DESTRUCTIVE_PATTERNS,
+    ...config?.extraDestructivePatterns ?? []
+  ];
+  for (const pattern of allDestructive) {
+    if (pattern.test(command)) {
+      return {
+        isReadOnly: false,
+        isDestructive: true,
+        reason: `Matches destructive pattern: ${pattern.source}`
+      };
+    }
+  }
+  if (name === "git") {
+    return classifyGitCommand(command);
+  }
+  if (name === "xargs" && /\bgit\b/.test(command)) {
+    return classifyGitCommand(command);
+  }
+  if ((name === "echo" || name === "printf") && SAFE_ECHO_RE.test(stripPrefixes(command).trim())) {
+    return { isReadOnly: true, isDestructive: false, reason: `${name} with safe arguments is read-only` };
+  }
+  const extraReadOnly = new Set(config?.extraReadOnlyCommands ?? []);
+  if (READ_ONLY_COMMANDS.has(name) || extraReadOnly.has(name)) {
+    return { isReadOnly: true, isDestructive: false, reason: `${name} is read-only` };
+  }
+  return {
+    isReadOnly: false,
+    isDestructive: false,
+    reason: `${name} is not in the read-only allowlist`
+  };
+}
+function classifyCommand(command, config) {
+  if (!command.trim()) {
+    return { isReadOnly: true, isDestructive: false, reason: "Empty command" };
+  }
+  const subCommands = splitCompoundCommand(command);
+  if (subCommands.length === 0) {
+    return { isReadOnly: true, isDestructive: false, reason: "Empty command" };
+  }
+  if (subCommands.length > 1) {
+    const hasCd = subCommands.some((s) => /^(cd|pushd)\s/.test(s.trim()));
+    const hasGit = subCommands.some((s) => {
+      const n = extractCommandName(s);
+      return n === "git" || n === "xargs" && /\bgit\b/.test(s);
+    });
+    if (hasCd && hasGit) {
+      return {
+        isReadOnly: false,
+        isDestructive: false,
+        reason: "cd + git compound may escape working directory (bare-repo risk)"
+      };
+    }
+    if (hasGit && commandWritesGitInternals(command)) {
+      return {
+        isReadOnly: false,
+        isDestructive: true,
+        reason: "Compound command writes to git internal paths before running git"
+      };
+    }
+  }
+  let allReadOnly = true;
+  let anyDestructive = false;
+  const reasons = [];
+  for (const sub of subCommands) {
+    const result = classifySingleCommand(sub, config);
+    if (!result.isReadOnly) allReadOnly = false;
+    if (result.isDestructive) anyDestructive = true;
+    if (result.reason) reasons.push(result.reason);
+  }
+  return {
+    isReadOnly: allReadOnly,
+    isDestructive: anyDestructive,
+    reason: reasons.join("; ")
+  };
+}
+
+// src/tools/shell-safety/git-tracking.ts
+function detectGitOperations(command, stdout) {
+  const events = [];
+  const cmd = command.trim();
+  if (/\bgit\s+commit\b/.test(cmd)) {
+    const shaMatch = stdout.match(/\[[\w/.-]+\s+([0-9a-f]{7,40})\]/);
+    const sha = shaMatch ? shaMatch[1] : "unknown";
+    events.push({ type: "commit", details: `commit ${sha}` });
+  }
+  if (/\bgit\s+merge\b/.test(cmd)) {
+    const branchMatch = cmd.match(/\bgit\s+merge\s+(?:--\S+\s+)*(\S+)/);
+    const branch = branchMatch ? branchMatch[1] : "unknown";
+    events.push({ type: "merge", details: `merge ${branch}` });
+  }
+  if (/\bgit\s+rebase\b/.test(cmd)) {
+    const branchMatch = cmd.match(/\bgit\s+rebase\s+(?:--\S+\s+)*(\S+)/);
+    const branch = branchMatch ? branchMatch[1] : "unknown";
+    events.push({ type: "rebase", details: `rebase onto ${branch}` });
+  }
+  if (/\bgit\s+push\b/.test(cmd)) {
+    const remoteMatch = cmd.match(/\bgit\s+push\s+(?:--\S+\s+)*(\S+)/);
+    const remote = remoteMatch ? remoteMatch[1] : "origin";
+    const branchMatch = stdout.match(/\S+\s+->\s+(\S+)/);
+    const branch = branchMatch ? branchMatch[1] : "";
+    events.push({
+      type: "push",
+      details: `push to ${remote}${branch ? ` (${branch})` : ""}`
+    });
+  }
+  if (/\b(gh\s+pr\s+create|glab\s+mr\s+create)\b/.test(cmd)) {
+    const urlMatch = stdout.match(/(https?:\/\/\S+(?:pull|merge_requests)\/\d+)/);
+    const url = urlMatch ? urlMatch[1] : "";
+    events.push({
+      type: "pr_create",
+      details: url ? `PR created: ${url}` : "PR created"
+    });
+  }
+  return events;
+}
+function hasGitIndexLockError(output) {
+  return /\.git\/index\.lock/.test(output);
+}
+
+// src/tools/prompts/bash.ts
+var BASH_PROMPT = `Executes a given bash command and returns its output.
+
+The working directory persists between commands, but shell state does not.
+
+IMPORTANT: Avoid using this tool to run \`find\`, \`grep\`, \`cat\`, \`head\`, \`tail\`, \`sed\`, \`awk\`, or \`echo\` commands, unless explicitly instructed or after you have verified that a dedicated tool cannot accomplish your task. Instead, use the appropriate dedicated tool:
+
+- File search: Use Glob (NOT find or ls)
+- Content search: Use Grep (NOT grep or rg)
+- Read files: Use ReadFile (NOT cat/head/tail)
+- Edit files: Use EditFile (NOT sed/awk)
+- Write files: Use WriteFile (NOT echo >/cat <<EOF)
+- Communication: Output text directly (NOT echo/printf)
+
+While the Bash tool can do similar things, the built-in tools are preferred as they provide better structured output and integrate with the permission system.
+
+# Instructions
+
+- If your command will create new directories or files, first use this tool to run \`ls\` to verify the parent directory exists and is the correct location.
+- Always quote file paths that contain spaces with double quotes (e.g., cd "path with spaces/file.txt").
+- Try to maintain your current working directory throughout the session by using absolute paths and avoiding usage of \`cd\`. You may use \`cd\` if the User explicitly requests it.
+- You may specify an optional timeout in milliseconds (up to 600000ms / 10 minutes). By default, your command will timeout after 30000ms (0.5 minutes).
+- When issuing multiple commands:
+  - If the commands are independent and can run in parallel, make multiple Bash tool calls in a single message.
+  - If the commands depend on each other and must run sequentially, use a single Bash call with '&&' to chain them together.
+  - Use ';' only when you need to run commands sequentially but don't care if earlier commands fail.
+  - DO NOT use newlines to separate commands (newlines are ok in quoted strings).
+- For git commands:
+  - Prefer to create a new commit rather than amending an existing commit.
+  - Before running destructive operations (e.g., git reset --hard, git push --force, git checkout --), consider whether there is a safer alternative. Only use destructive operations when they are truly the best approach.
+  - Never skip hooks (--no-verify) or bypass signing (--no-gpg-sign) unless the user has explicitly asked for it. If a hook fails, investigate and fix the underlying issue.
+- Avoid unnecessary \`sleep\` commands:
+  - Do not sleep between commands that can run immediately \u2014 just run them.
+  - Do not retry failing commands in a sleep loop \u2014 diagnose the root cause.
+  - If you must sleep, keep the duration short (1-5 seconds) to avoid blocking the user.
+`;
+
+// src/tools/bash.ts
+var MAX_OUTPUT_CHARS = 1e5;
+var bashTool = {
+  name: "Bash",
+  description: "Execute a bash shell command. Use this for running scripts, installing packages, git operations, and other system commands.",
+  prompt: BASH_PROMPT,
+  isReadOnly(args) {
+    const command = args.command;
+    return classifyCommand(command).isReadOnly;
+  },
+  isDestructive(args) {
+    const command = args.command;
+    return classifyCommand(command).isDestructive;
+  },
+  checkPermissions(args) {
+    const command = args.command;
+    const classification = classifyCommand(command);
+    if (classification.isDestructive) {
+      return {
+        behavior: "ask",
+        message: `Destructive command: ${command}${classification.reason ? ` (${classification.reason})` : ""}`
+      };
+    }
+    if (commandWritesGitInternals(command)) {
+      return {
+        behavior: "ask",
+        message: `Command writes to .git/ internals: ${command}`
+      };
+    }
+    return {
+      behavior: "passthrough",
+      message: `Execute: ${command}`
+    };
+  },
+  parameters: {
+    type: "object",
+    properties: {
+      command: {
+        type: "string",
+        description: "The bash command to execute"
+      },
+      timeout: {
+        type: "number",
+        description: "Timeout in milliseconds (default: 30000)"
+      },
+      description: {
+        type: "string",
+        description: "Short description of what this command does (5-10 words)"
+      }
+    },
+    required: ["command"]
+  },
+  async call(args, ctx) {
+    const command = args.command;
+    const timeout = args.timeout;
+    try {
+      const result = await ctx.computer.executeCommand(command, {
+        timeout,
+        cwd: ctx.cwd
+      });
+      let output = "";
+      if (result.stdout) {
+        output += result.stdout;
+      }
+      if (result.stderr) {
+        if (output) output += "\n";
+        output += `STDERR:
+${result.stderr}`;
+      }
+      if (!output.trim()) {
+        output = "(no output)";
+      }
+      if (output.length > MAX_OUTPUT_CHARS) {
+        const totalChars = output.length;
+        output = output.slice(0, MAX_OUTPUT_CHARS) + `
+... output truncated (${totalChars} total chars)`;
+      }
+      if (result.exitCode !== 0) {
+        output = `Exit code: ${result.exitCode}
+${output}`;
+      }
+      const toolResult = {
+        content: output,
+        isError: result.exitCode !== 0
+      };
+      if (result.exitCode === 0) {
+        const gitOps = detectGitOperations(command, result.stdout ?? "");
+        if (gitOps.length > 0) {
+          toolResult.metadata = { gitOperations: gitOps };
+        }
+      }
+      return toolResult;
+    } catch (err) {
+      return {
+        content: `Error executing command: ${err instanceof Error ? err.message : String(err)}`,
+        isError: true
+      };
+    }
+  }
+};
+
+// src/tools/prompts/glob.ts
+var GLOB_PROMPT = `Fast file pattern matching tool that works with any codebase size.
+
+- Supports glob patterns like "**/*.js" or "src/**/*.ts"
+- Returns matching file paths sorted by modification time
+- Use this tool when you need to find files by name patterns
+- When you are doing an open-ended search that may require multiple rounds of globbing and grepping, use the Agent tool instead
+`;
+
+// src/utils/shell-escape.ts
+function shellEscape(s) {
+  return "'" + s.replace(/'/g, "'\\''") + "'";
+}
+
+// src/tools/glob.ts
+var MAX_RESULTS = 200;
+var globTool = {
+  name: "Glob",
+  description: "Find files matching a glob pattern. Uses ripgrep (rg --files --glob) for fast, gitignore-aware file discovery. Returns matching file paths sorted by modification time.",
+  prompt: GLOB_PROMPT,
+  isReadOnly: true,
+  isConcurrencySafe: true,
+  parameters: {
+    type: "object",
+    properties: {
+      pattern: {
+        type: "string",
+        description: 'Glob pattern to match files (e.g. "*.ts", "src/**/*.tsx")'
+      },
+      path: {
+        type: "string",
+        description: "Directory to search in (defaults to cwd)"
+      }
+    },
+    required: ["pattern"]
+  },
+  async call(args, ctx) {
+    const pattern = args.pattern;
+    const searchPath = args.path ?? ctx.cwd;
+    const fullPattern = pattern.startsWith("**/") ? pattern : `**/${pattern}`;
+    const command = `rg --files --glob ${shellEscape(fullPattern)} --sort=modified | head -n ${String(MAX_RESULTS + 1)}`;
+    try {
+      const result = await ctx.computer.executeCommand(command, {
+        cwd: searchPath
+      });
+      if (result.exitCode > 1) {
+        return {
+          content: `Glob error: ${result.stderr || result.stdout}`,
+          isError: true
+        };
+      }
+      const lines = result.stdout.split("\n").filter((l) => l.trim() !== "");
+      if (lines.length === 0) {
+        return { content: "No files found matching the pattern." };
+      }
+      const truncated = lines.length > MAX_RESULTS;
+      const files = truncated ? lines.slice(0, MAX_RESULTS) : lines;
+      let output = files.join("\n");
+      if (truncated) {
+        output += `
+
+(Results truncated. More than ${MAX_RESULTS} files match.)`;
+      }
+      return { content: output };
+    } catch (err) {
+      return {
+        content: `Error searching files: ${err instanceof Error ? err.message : String(err)}`,
+        isError: true
+      };
+    }
+  }
+};
+
+// src/tools/prompts/grep.ts
+var GREP_PROMPT = `A powerful search tool built on ripgrep.
+
+Usage:
+- ALWAYS use Grep for search tasks. NEVER invoke \`grep\` or \`rg\` as a Bash command. The Grep tool has been optimized for correct permissions and access.
+- Supports full regex syntax (e.g., "log.*Error", "function\\s+\\w+")
+- Filter files with the glob parameter (e.g., "*.js", "**/*.tsx")
+- Returns matching lines with file paths and line numbers
+- Use the Agent tool for open-ended searches requiring multiple rounds
+- Pattern syntax: Uses ripgrep (not grep) \u2014 literal braces need escaping (use \`interface\\{\\}\` to find \`interface{}\` in Go code)
+- Multiline matching: By default patterns match within single lines only. For cross-line patterns like \`struct \\{[\\s\\S]*?field\`, pass a context_lines parameter.
+`;
+
+// src/tools/grep.ts
+var MAX_MATCHES = 250;
+var grepTool = {
+  name: "Grep",
+  description: "Search file contents using ripgrep (rg). Supports regex patterns. Returns matching lines with file paths and line numbers.",
+  prompt: GREP_PROMPT,
+  isReadOnly: true,
+  isConcurrencySafe: true,
+  parameters: {
+    type: "object",
+    properties: {
+      pattern: {
+        type: "string",
+        description: "Regular expression pattern to search for"
+      },
+      path: {
+        type: "string",
+        description: "File or directory to search in (defaults to cwd)"
+      },
+      glob: {
+        type: "string",
+        description: 'Glob pattern to filter files (e.g. "*.ts", "*.{js,jsx}")'
+      },
+      case_insensitive: {
+        type: "boolean",
+        description: "Case insensitive search (default: false)"
+      },
+      context_lines: {
+        type: "number",
+        description: "Number of context lines to show before and after each match"
+      }
+    },
+    required: ["pattern"]
+  },
+  async call(args, ctx) {
+    const pattern = args.pattern;
+    const searchPath = args.path ?? ctx.cwd;
+    const glob = args.glob;
+    const caseInsensitive = args.case_insensitive;
+    const contextLines = args.context_lines;
+    const rgArgs = [
+      "rg",
+      "--line-number",
+      "--no-heading",
+      "--color=never",
+      `--max-count=${MAX_MATCHES}`
+    ];
+    if (caseInsensitive) rgArgs.push("-i");
+    if (contextLines !== void 0) rgArgs.push(`-C${contextLines}`);
+    if (glob) rgArgs.push(`--glob`, shellEscape(glob));
+    rgArgs.push("--", shellEscape(pattern), ".");
+    const command = rgArgs.join(" ");
+    try {
+      const result = await ctx.computer.executeCommand(command, {
+        cwd: searchPath
+      });
+      if (result.exitCode === 1 && !result.stdout.trim()) {
+        return { content: "No matches found." };
+      }
+      if (result.exitCode > 1) {
+        return {
+          content: `Grep error: ${result.stderr || result.stdout}`,
+          isError: true
+        };
+      }
+      const lines = result.stdout.split("\n");
+      let output = result.stdout;
+      if (lines.length > MAX_MATCHES) {
+        output = lines.slice(0, MAX_MATCHES).join("\n") + `
+
+(Results truncated at ${MAX_MATCHES} matches.)`;
+      }
+      return { content: output || "No matches found." };
+    } catch (err) {
+      return {
+        content: `Error searching: ${err instanceof Error ? err.message : String(err)}`,
+        isError: true
+      };
+    }
+  }
+};
+
+// src/tools/prompts/web-fetch.ts
+var WEB_FETCH_PROMPT = `Fetches content from a specified URL and returns it in a readable format.
+
+- Takes a URL and fetches the page content, converting HTML to markdown
+- Returns the processed content for analysis
+- Use this tool when you need to retrieve and analyze web content
+
+Usage notes:
+- The URL must be a fully-formed valid URL
+- HTTP URLs will be automatically upgraded to HTTPS
+- This tool is read-only and does not modify any files
+- Results may be summarized if the content is very large
+- When a URL redirects to a different host, the tool will inform you and provide the redirect URL. You should then make a new WebFetch request with the redirect URL.
+- For GitHub URLs, prefer using the gh CLI via Bash instead (e.g., gh pr view, gh issue view, gh api).
+`;
+
+// src/tools/web-fetch.ts
+var MAX_CONTENT_LENGTH = 5 * 1024 * 1024;
+var FETCH_TIMEOUT_MS = 3e4;
+var MAX_OUTPUT_CHARS2 = 1e5;
+var webFetchTool = {
+  name: "WebFetch",
+  description: "Fetch a URL and return its contents as markdown. Useful for reading web pages, documentation, API responses, and other online content. Provide an optional prompt to extract specific information.",
+  prompt: WEB_FETCH_PROMPT,
+  isReadOnly: true,
+  isConcurrencySafe: true,
+  parameters: {
+    type: "object",
+    properties: {
+      url: {
+        type: "string",
+        description: "The URL to fetch (must be a valid http/https URL)"
+      },
+      prompt: {
+        type: "string",
+        description: "Optional instruction for what to extract from the page content"
+      }
+    },
+    required: ["url"]
+  },
+  async call(args, _ctx) {
+    const url = args.url;
+    const prompt = args.prompt;
+    try {
+      new URL(url);
+    } catch {
+      return { content: `Invalid URL: ${url}`, isError: true };
+    }
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+      const response = await fetch(url, {
+        signal: controller.signal,
+        headers: {
+          "User-Agent": "noumen-agent/1.0",
+          Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,text/plain;q=0.8,*/*;q=0.7"
+        },
+        redirect: "follow"
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        return {
+          content: `HTTP ${response.status}: ${response.statusText}`,
+          isError: true
+        };
+      }
+      const contentType = response.headers.get("content-type") ?? "";
+      const contentLength = parseInt(
+        response.headers.get("content-length") ?? "0",
+        10
+      );
+      if (contentLength > MAX_CONTENT_LENGTH) {
+        return {
+          content: `Response too large (${contentLength} bytes, limit ${MAX_CONTENT_LENGTH})`,
+          isError: true
+        };
+      }
+      let text = "";
+      let bytesRead = 0;
+      const reader = response.body?.getReader();
+      const decoder = new TextDecoder();
+      if (reader) {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          bytesRead += value.byteLength;
+          if (bytesRead > MAX_CONTENT_LENGTH) {
+            reader.cancel();
+            return {
+              content: `Response too large (>${MAX_CONTENT_LENGTH} bytes streamed, limit ${MAX_CONTENT_LENGTH})`,
+              isError: true
+            };
+          }
+          text += decoder.decode(value, { stream: true });
+        }
+        text += decoder.decode();
+      } else {
+        text = await response.text();
+      }
+      let markdown;
+      if (contentType.includes("text/html") || contentType.includes("xhtml")) {
+        const { NodeHtmlMarkdown } = await import("node-html-markdown");
+        markdown = NodeHtmlMarkdown.translate(text);
+      } else {
+        markdown = text;
+      }
+      if (markdown.length > MAX_OUTPUT_CHARS2) {
+        const totalChars = markdown.length;
+        markdown = markdown.slice(0, MAX_OUTPUT_CHARS2) + `
+
+... content truncated (${totalChars} total chars)`;
+      }
+      let result = `# Content from ${url}
+
+${markdown}`;
+      if (prompt) {
+        result = `## Extraction prompt: ${prompt}
+
+${result}`;
+      }
+      return { content: result };
+    } catch (err) {
+      if (err instanceof Error && err.name === "AbortError") {
+        return { content: `Fetch timed out after ${FETCH_TIMEOUT_MS}ms`, isError: true };
+      }
+      return {
+        content: `Fetch error: ${err instanceof Error ? err.message : String(err)}`,
+        isError: true
+      };
+    }
+  }
+};
+
+// src/tools/prompts/notebook.ts
+var NOTEBOOK_PROMPT = `Completely replaces the contents of a specific cell in a Jupyter notebook (.ipynb file) with new source. Jupyter notebooks are interactive documents that combine code, text, and visualizations, commonly used for data analysis and scientific computing. The notebook_path parameter must be an absolute path, not a relative path. The cell_number is 0-indexed. Use edit_mode=insert to add a new cell at the index specified by cell_number. Use edit_mode=delete to delete the cell at the index specified by cell_number.`;
+
+// src/tools/notebook.ts
+var notebookEditTool = {
+  name: "NotebookEdit",
+  description: "Edit a Jupyter notebook (.ipynb) file. Can replace, insert, or delete cells. The notebook is pure JSON \u2014 no kernel execution.",
+  prompt: NOTEBOOK_PROMPT,
+  isReadOnly: false,
+  isConcurrencySafe: false,
+  parameters: {
+    type: "object",
+    properties: {
+      notebook_path: {
+        type: "string",
+        description: "Path to the .ipynb file"
+      },
+      cell_index: {
+        type: "number",
+        description: "0-based index of the cell to edit. For insert, the new cell is placed at this index."
+      },
+      new_source: {
+        type: "string",
+        description: "The new cell source content. Each line becomes an element in the source array."
+      },
+      cell_type: {
+        type: "string",
+        description: 'Cell type: "code" or "markdown" (default: "code")'
+      },
+      edit_mode: {
+        type: "string",
+        description: '"replace" (default) \u2014 replace existing cell source; "insert" \u2014 insert a new cell at cell_index; "delete" \u2014 delete the cell at cell_index (new_source is ignored)'
+      }
+    },
+    required: ["notebook_path", "cell_index"]
+  },
+  async call(args, ctx) {
+    const path2 = args.notebook_path;
+    const cellIndex = args.cell_index;
+    const newSource = args.new_source ?? "";
+    const cellType = args.cell_type ?? "code";
+    const editMode = args.edit_mode ?? "replace";
+    try {
+      const raw = await ctx.fs.readFile(path2);
+      let notebook;
+      try {
+        notebook = JSON.parse(raw);
+      } catch {
+        return { content: `Not a valid JSON notebook: ${path2}`, isError: true };
+      }
+      if (!Array.isArray(notebook.cells)) {
+        return { content: "Notebook has no cells array.", isError: true };
+      }
+      const sourceLines = newSource.split("\n").map(
+        (line, i, arr) => i < arr.length - 1 ? line + "\n" : line
+      );
+      switch (editMode) {
+        case "replace": {
+          if (cellIndex < 0 || cellIndex >= notebook.cells.length) {
+            return {
+              content: `Cell index ${cellIndex} out of range (0-${notebook.cells.length - 1}).`,
+              isError: true
+            };
+          }
+          notebook.cells[cellIndex].source = sourceLines;
+          notebook.cells[cellIndex].cell_type = cellType;
+          break;
+        }
+        case "insert": {
+          if (cellIndex < 0 || cellIndex > notebook.cells.length) {
+            return {
+              content: `Insert index ${cellIndex} out of range (0-${notebook.cells.length}).`,
+              isError: true
+            };
+          }
+          const newCell = {
+            cell_type: cellType,
+            source: sourceLines,
+            metadata: {},
+            ...cellType === "code" ? { outputs: [], execution_count: null } : {}
+          };
+          notebook.cells.splice(cellIndex, 0, newCell);
+          break;
+        }
+        case "delete": {
+          if (cellIndex < 0 || cellIndex >= notebook.cells.length) {
+            return {
+              content: `Cell index ${cellIndex} out of range (0-${notebook.cells.length - 1}).`,
+              isError: true
+            };
+          }
+          notebook.cells.splice(cellIndex, 1);
+          break;
+        }
+        default:
+          return {
+            content: `Unknown edit_mode: ${editMode}. Use "replace", "insert", or "delete".`,
+            isError: true
+          };
+      }
+      await ctx.fs.writeFile(path2, JSON.stringify(notebook, null, 1) + "\n");
+      const action = editMode === "delete" ? `Deleted cell ${cellIndex}` : editMode === "insert" ? `Inserted new ${cellType} cell at index ${cellIndex}` : `Replaced cell ${cellIndex} content`;
+      return { content: `${action} in ${path2}. Notebook now has ${notebook.cells.length} cells.` };
+    } catch (err) {
+      return {
+        content: `Error editing notebook: ${err instanceof Error ? err.message : String(err)}`,
+        isError: true
+      };
+    }
+  }
+};
+
+// src/tools/ask-user.ts
+var askUserTool = {
+  name: "AskUser",
+  description: "Ask the user a question and wait for their response. Use when you need clarification, confirmation, or additional information before proceeding.",
+  isReadOnly: true,
+  isConcurrencySafe: false,
+  requiresUserInteraction: true,
+  parameters: {
+    type: "object",
+    properties: {
+      question: {
+        type: "string",
+        description: "The question to ask the user"
+      }
+    },
+    required: ["question"]
+  },
+  async call(args, ctx) {
+    const question = args.question;
+    if (!ctx.userInputHandler) {
+      return {
+        content: "Cannot ask user: no userInputHandler configured. Set userInputHandler in AgentOptions or ThreadConfig.",
+        isError: true
+      };
+    }
+    try {
+      const answer = await ctx.userInputHandler(question);
+      return { content: answer };
+    } catch (err) {
+      return {
+        content: `Error getting user input: ${err instanceof Error ? err.message : String(err)}`,
+        isError: true
+      };
+    }
+  }
+};
+
+// src/tools/registry.ts
+function resolveToolPrompt(tool) {
+  if (tool.prompt === void 0) return tool.description;
+  return typeof tool.prompt === "function" ? tool.prompt() : tool.prompt;
+}
+function resolveToolFlag(flag, args, defaultValue = false) {
+  if (flag === void 0) return defaultValue;
+  if (typeof flag === "function") {
+    try {
+      return flag(args);
+    } catch {
+      return defaultValue;
+    }
+  }
+  return flag;
+}
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  _discoveredTools = /* @__PURE__ */ new Set();
+  _toolSearchEnabled = false;
+  constructor(additionalTools) {
+    const builtIn = [
+      readFileTool,
+      writeFileTool,
+      editFileTool,
+      bashTool,
+      globTool,
+      grepTool,
+      webFetchTool,
+      notebookEditTool,
+      askUserTool
+    ];
+    for (const tool of builtIn) {
+      this.tools.set(tool.name, tool);
+    }
+    if (additionalTools) {
+      for (const tool of additionalTools) {
+        this.tools.set(tool.name, tool);
+      }
+    }
+  }
+  enableToolSearch() {
+    this._toolSearchEnabled = true;
+  }
+  register(tool) {
+    this.tools.set(tool.name, tool);
+  }
+  get(name) {
+    return this.tools.get(name);
+  }
+  async execute(name, args, ctx) {
+    const tool = this.tools.get(name);
+    if (!tool) {
+      return {
+        content: `Unknown tool: ${name}`,
+        isError: true
+      };
+    }
+    if (tool.inputSchema) {
+      const parsed = tool.inputSchema.safeParse(args);
+      if (!parsed.success) {
+        return {
+          content: formatZodValidationError(name, parsed.error),
+          isError: true
+        };
+      }
+    }
+    return tool.call(args, ctx);
+  }
+  toToolDefinitions() {
+    return Array.from(this.tools.values()).map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: resolveToolPrompt(tool),
+        parameters: tool.parameters
+      }
+    }));
+  }
+  /**
+   * Get tool definitions filtered by tool search. Eager tools (always sent)
+   * plus any deferred tools the model has discovered via ToolSearch.
+   * Falls back to all tools when tool search is not enabled.
+   */
+  getActiveToolDefinitions() {
+    if (!this._toolSearchEnabled) return this.toToolDefinitions();
+    return Array.from(this.tools.values()).filter((tool) => !isDeferredTool(tool) || this._discoveredTools.has(tool.name)).map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: resolveToolPrompt(tool),
+        parameters: tool.parameters
+      }
+    }));
+  }
+  getEagerTools() {
+    return Array.from(this.tools.values()).filter((tool) => !isDeferredTool(tool));
+  }
+  getDeferredTools() {
+    return Array.from(this.tools.values()).filter(isDeferredTool);
+  }
+  getToolsByNames(names) {
+    return names.map((name) => this.tools.get(name)).filter((t) => t !== void 0);
+  }
+  markDiscovered(names) {
+    for (const name of names) {
+      this._discoveredTools.add(name);
+    }
+  }
+  get discoveredTools() {
+    return this._discoveredTools;
+  }
+  listTools() {
+    return Array.from(this.tools.values());
+  }
+};
+
+export {
+  TOOL_SEARCH_NAME,
+  isDeferredTool,
+  formatDeferredToolLine,
+  searchToolsWithKeywords,
+  createToolSearchTool,
+  zodToJsonSchema,
+  registerZodToJsonSchema,
+  formatZodValidationError,
+  readFileTool,
+  writeFileTool,
+  normalizeQuotes,
+  findActualString,
+  countOccurrences,
+  preserveQuoteStyle,
+  stripTrailingWhitespace,
+  editFileTool,
+  isGitInternalPath,
+  looksLikeBareRepo,
+  commandWritesGitInternals,
+  extractCommandName,
+  classifyCommand,
+  detectGitOperations,
+  hasGitIndexLockError,
+  bashTool,
+  globTool,
+  grepTool,
+  webFetchTool,
+  notebookEditTool,
+  askUserTool,
+  resolveToolFlag,
+  ToolRegistry
+};
+//# sourceMappingURL=chunk-QTJ7VTJY.js.map