@avasis-ai/synthcode 1.0.0

package/dist/tools/index.cjs

@@ -0,0 +1,1032 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  globToRegExp: () => globToRegExp,
+  walkDir: () => walkDir
+});
+function globToRegExp(pattern) {
+  const parts = pattern.split("/");
+  let regex = "";
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (part === "**") {
+      regex += "(?:[^/]*(?:\\/|$))*";
+    } else {
+      const escaped = part.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]");
+      regex += escaped + "\\/";
+    }
+  }
+  regex = regex.replace(/\\\//g, "/").replace(/\/$/, "");
+  return new RegExp(`(^|/)${regex}(/|$)`);
+}
+async function walkDir(dir, options) {
+  const maxDepth = options?.maxDepth ?? Infinity;
+  const followSymlinks = options?.followSymlinks ?? false;
+  const results = [];
+  async function walk(current, depth) {
+    if (depth > maxDepth) return;
+    let entries;
+    try {
+      entries = await fs4.promises.readdir(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = path4.join(current, entry.name);
+      if (entry.name === "node_modules" || entry.name === ".git") continue;
+      try {
+        let stat;
+        if (entry.isSymbolicLink() && !followSymlinks) continue;
+        stat = await fs4.promises.stat(fullPath);
+        if (stat.isFile()) {
+          results.push({ path: fullPath, stat });
+        } else if (stat.isDirectory()) {
+          await walk(fullPath, depth + 1);
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+  await walk(dir, 0);
+  return results;
+}
+var fs4, path4;
+var init_utils = __esm({
+  "src/utils.ts"() {
+    "use strict";
+    fs4 = __toESM(require("fs"), 1);
+    path4 = __toESM(require("path"), 1);
+  }
+});
+
+// src/tools/index.ts
+var tools_exports = {};
+__export(tools_exports, {
+  BashTool: () => BashTool,
+  FileEditTool: () => FileEditTool,
+  FileReadTool: () => FileReadTool,
+  FileWriteTool: () => FileWriteTool,
+  FuzzyEditError: () => FuzzyEditError,
+  GlobTool: () => GlobTool,
+  GrepTool: () => GrepTool,
+  ToolRegistry: () => ToolRegistry,
+  WebFetchTool: () => WebFetchTool,
+  defineTool: () => defineTool,
+  defineToolFromClass: () => defineToolFromClass,
+  fuzzyContains: () => fuzzyContains,
+  fuzzyReplace: () => fuzzyReplace,
+  orchestrateTools: () => orchestrateTools
+});
+module.exports = __toCommonJS(tools_exports);
+
+// src/tools/tool.ts
+function zodToJsonSchema(schema) {
+  const s = schema;
+  const def = s._def;
+  const typeName = def.typeName;
+  const description = def.description;
+  const base = {};
+  if (description) base.description = description;
+  switch (typeName) {
+    case "ZodString":
+      return { ...base, type: "string" };
+    case "ZodNumber":
+      return { ...base, type: "number" };
+    case "ZodBoolean":
+      return { ...base, type: "boolean" };
+    case "ZodNull":
+      return { ...base, type: "null" };
+    case "ZodArray": {
+      const items = zodToJsonSchema(def.element);
+      return { ...base, type: "array", items };
+    }
+    case "ZodObject": {
+      const shapeFn = def.shape;
+      const shape = shapeFn();
+      const properties = {};
+      const required = [];
+      for (const [key, value] of Object.entries(shape)) {
+        properties[key] = zodToJsonSchema(value);
+        const propDef = value._def;
+        if (propDef.typeName !== "ZodOptional" && propDef.typeName !== "ZodNullish" && propDef.typeName !== "ZodDefault") {
+          required.push(key);
+        }
+      }
+      const result = { ...base, type: "object", properties };
+      if (required.length > 0) result.required = required;
+      return result;
+    }
+    case "ZodEnum":
+      return { ...base, enum: def.values };
+    case "ZodLiteral":
+      return { ...base, const: def.value };
+    case "ZodUnion": {
+      const options = def.options.map((o) => zodToJsonSchema(o));
+      return { ...base, anyOf: options };
+    }
+    case "ZodDiscriminatedUnion": {
+      const options = def.options.map((o) => zodToJsonSchema(o));
+      return { ...base, anyOf: options };
+    }
+    case "ZodOptional":
+      return zodToJsonSchema(def.innerType);
+    case "ZodNullable": {
+      const inner = zodToJsonSchema(def.innerType);
+      inner.nullable = true;
+      return inner;
+    }
+    case "ZodNullish": {
+      const inner = zodToJsonSchema(def.innerType);
+      inner.nullable = true;
+      return inner;
+    }
+    case "ZodDefault":
+      return zodToJsonSchema(def.innerType);
+    case "ZodRecord": {
+      const valueSchema = zodToJsonSchema(def.valueType);
+      return { ...base, type: "object", additionalProperties: valueSchema };
+    }
+    case "ZodTuple": {
+      const items = def.items.map((o) => zodToJsonSchema(o));
+      return { ...base, type: "array", items, minItems: items.length, maxItems: items.length };
+    }
+    case "ZodEffects": {
+      return zodToJsonSchema(def.innerType);
+    }
+    case "ZodAny":
+      return {};
+    case "ZodUnknown":
+      return {};
+    case "ZodVoid":
+      return { ...base, type: "null" };
+    case "ZodNever":
+      return { ...base, not: {} };
+    default:
+      return { ...base, type: "string" };
+  }
+}
+function defineTool(config) {
+  const tool = {
+    name: config.name,
+    description: config.description,
+    inputSchema: config.inputSchema,
+    isReadOnly: config.isReadOnly ?? false,
+    isConcurrencySafe: config.isConcurrencySafe ?? false,
+    execute: config.execute,
+    toAPI() {
+      return {
+        name: config.name,
+        description: config.description,
+        input_schema: zodToJsonSchema(config.inputSchema)
+      };
+    },
+    toString(input) {
+      const entries = Object.entries(input).map(([k, v]) => {
+        if (typeof v === "string") return `${k}: "${v}"`;
+        if (v === void 0) return `${k}: undefined`;
+        if (v === null) return `${k}: null`;
+        return `${k}: ${String(v)}`;
+      }).join(", ");
+      return `${config.name}({ ${entries} })`;
+    }
+  };
+  return tool;
+}
+function defineToolFromClass(ctor) {
+  const instance = new ctor();
+  return {
+    name: instance.name,
+    description: instance.description,
+    inputSchema: instance.inputSchema,
+    isReadOnly: instance.isReadOnly,
+    isConcurrencySafe: instance.isConcurrencySafe,
+    execute: (input, context) => instance.execute(input, context),
+    toAPI: () => instance.toAPI(),
+    toString: (input) => instance.toString(input)
+  };
+}
+
+// src/tools/registry.ts
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  constructor(tools) {
+    if (tools) {
+      for (const tool of tools) {
+        this.add(tool);
+      }
+    }
+  }
+  /** Add a tool to the registry. Duplicate names are ignored (first one wins). */
+  add(tool) {
+    if (this.tools.has(tool.name)) {
+      console.warn(`[ToolRegistry] Duplicate tool "${tool.name}" ignored (first one wins)`);
+      return;
+    }
+    this.tools.set(tool.name, tool);
+  }
+  /** Get a tool by name. */
+  get(name) {
+    return this.tools.get(name);
+  }
+  /** Check if a tool exists by name. */
+  has(name) {
+    return this.tools.has(name);
+  }
+  /** Find tool by case-insensitive name. Returns undefined if not found. */
+  findCaseInsensitive(name) {
+    const lower = name.toLowerCase();
+    if (this.tools.has(name)) return name;
+    for (const key of this.tools.keys()) {
+      if (key.toLowerCase() === lower) return key;
+    }
+    return void 0;
+  }
+  /** List all registered tool names. */
+  listNames() {
+    return Array.from(this.tools.keys());
+  }
+  /** Get all registered tools. */
+  getAll() {
+    return Array.from(this.tools.values());
+  }
+  /** Get all tools in API format, sorted by name for cache stability. */
+  getAPI() {
+    return this.getAll().sort((a, b) => a.name.localeCompare(b.name)).map((t) => t.toAPI());
+  }
+  /** Number of registered tools. */
+  get size() {
+    return this.tools.size;
+  }
+};
+
+// src/tools/orchestrator.ts
+var Semaphore = class {
+  constructor(max) {
+    this.max = max;
+  }
+  max;
+  current = 0;
+  queue = [];
+  acquire() {
+    if (this.current < this.max) {
+      this.current++;
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      this.queue.push(resolve);
+    });
+  }
+  release() {
+    this.current--;
+    const next = this.queue.shift();
+    if (next) {
+      this.current++;
+      next();
+    }
+  }
+};
+function partitionToolCalls(toolCalls, registry) {
+  const batches = [];
+  let currentBatch = [];
+  let currentBatchIsConcurrent = false;
+  for (const call of toolCalls) {
+    const tool = registry.get(call.name);
+    const isConcurrent = tool ? tool.isReadOnly && tool.isConcurrencySafe : false;
+    if (isConcurrent && currentBatchIsConcurrent) {
+      currentBatch.push(call);
+    } else {
+      if (currentBatch.length > 0) {
+        batches.push(currentBatch);
+      }
+      currentBatch = [call];
+      currentBatchIsConcurrent = isConcurrent;
+    }
+  }
+  if (currentBatch.length > 0) {
+    batches.push(currentBatch);
+  }
+  return batches;
+}
+async function executeToolCall(call, registry, context, permissionCheck, abortSignal) {
+  if (abortSignal?.aborted) {
+    return {
+      id: call.id,
+      name: call.name,
+      output: "Execution aborted",
+      isError: true,
+      durationMs: 0
+    };
+  }
+  const tool = registry.get(call.name);
+  if (!tool) {
+    return {
+      id: call.id,
+      name: call.name,
+      output: `Unknown tool: ${call.name}`,
+      isError: true,
+      durationMs: 0
+    };
+  }
+  const start = performance.now();
+  try {
+    const parseResult = tool.inputSchema.safeParse(call.input);
+    if (!parseResult.success) {
+      return {
+        id: call.id,
+        name: call.name,
+        output: `Invalid input for ${call.name}: ${parseResult.error.issues.map((i) => i.message).join(", ")}`,
+        isError: true,
+        durationMs: Math.round(performance.now() - start)
+      };
+    }
+    if (permissionCheck) {
+      const allowed = await permissionCheck(call.name, call.input);
+      if (!allowed) {
+        return {
+          id: call.id,
+          name: call.name,
+          output: `Permission denied for tool: ${call.name}`,
+          isError: true,
+          durationMs: Math.round(performance.now() - start)
+        };
+      }
+    }
+    const output = await tool.execute(parseResult.data, context);
+    return {
+      id: call.id,
+      name: call.name,
+      output,
+      isError: false,
+      durationMs: Math.round(performance.now() - start)
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      id: call.id,
+      name: call.name,
+      output: `Error executing ${call.name}: ${message}`,
+      isError: true,
+      durationMs: Math.round(performance.now() - start)
+    };
+  }
+}
+async function orchestrateTools(tools, toolCalls, context, permissionCheck, abortSignal) {
+  const batches = partitionToolCalls(toolCalls, tools);
+  const results = [];
+  for (const batch of batches) {
+    if (abortSignal?.aborted) {
+      for (const call of batch) {
+        results.push({
+          id: call.id,
+          name: call.name,
+          output: "Execution aborted",
+          isError: true,
+          durationMs: 0
+        });
+      }
+      continue;
+    }
+    if (batch.length > 1) {
+      const semaphore = new Semaphore(10);
+      const promises2 = batch.map(
+        (call) => semaphore.acquire().then(async () => {
+          try {
+            return await executeToolCall(call, tools, context, permissionCheck, abortSignal);
+          } finally {
+            semaphore.release();
+          }
+        })
+      );
+      const settled = await Promise.allSettled(promises2);
+      for (let i = 0; i < settled.length; i++) {
+        const s = settled[i];
+        if (s.status === "fulfilled") {
+          results.push(s.value);
+        } else {
+          results.push({
+            id: batch[i].id,
+            name: batch[i].name,
+            output: `Unexpected error: ${s.reason instanceof Error ? s.reason.message : String(s.reason)}`,
+            isError: true,
+            durationMs: 0
+          });
+        }
+      }
+    } else {
+      const result = await executeToolCall(batch[0], tools, context, permissionCheck, abortSignal);
+      results.push(result);
+    }
+  }
+  return results;
+}
+
+// src/tools/bash.ts
+var import_node_child_process = require("child_process");
+var import_zod = require("zod");
+var MAX_OUTPUT = 50 * 1024;
+var TRUNCATE_HALF = 25 * 1024;
+function truncateOutput(output) {
+  if (output.length <= MAX_OUTPUT) return output;
+  const notice = `
+
+... [output truncated: showing first ${TRUNCATE_HALF} and last ${TRUNCATE_HALF} of ${output.length} characters] ...
+
+`;
+  return output.slice(0, TRUNCATE_HALF) + notice + output.slice(-TRUNCATE_HALF);
+}
+var BashTool = defineTool({
+  name: "bash",
+  description: "Execute a shell command. Returns stdout and stderr. Use for running build commands, git operations, package managers, and other CLI tools.",
+  inputSchema: import_zod.z.object({
+    command: import_zod.z.string().describe("The shell command to execute"),
+    timeout: import_zod.z.number().optional().describe("Timeout in milliseconds (default 120000)"),
+    workdir: import_zod.z.string().optional().describe("Working directory for the command")
+  }),
+  isReadOnly: false,
+  isConcurrencySafe: false,
+  execute: async ({ command, timeout = 12e4, workdir }, context) => {
+    return new Promise((resolve) => {
+      let settled = false;
+      const done = (result) => {
+        if (settled) return;
+        settled = true;
+        resolve(result);
+      };
+      if (context.abortSignal?.aborted) {
+        done("Command aborted before execution");
+        return;
+      }
+      const child = (0, import_node_child_process.exec)(
+        command,
+        {
+          cwd: workdir ?? context.cwd,
+          timeout,
+          maxBuffer: 10 * 1024 * 1024,
+          killSignal: "SIGKILL"
+        },
+        (error, stdout, stderr) => {
+          let output = "";
+          if (stdout) output += `STDOUT:
+${stdout}
+
+`;
+          if (stderr) output += `STDERR:
+${stderr}
+
+`;
+          output += `Exit code: ${error?.code ?? 0}`;
+          if (error && error.killed) {
+            output = `Command timed out after ${timeout}ms
+
+${output}`;
+          }
+          done(truncateOutput(output));
+        }
+      );
+      child.on("error", (err) => {
+        done(`Failed to execute command: ${err.message}`);
+      });
+      if (context.abortSignal) {
+        context.abortSignal.addEventListener(
+          "abort",
+          () => {
+            child.kill("SIGKILL");
+            done("Command aborted");
+          },
+          { once: true }
+        );
+      }
+    });
+  }
+});
+
+// src/tools/file-read.ts
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_node_path = __toESM(require("path"), 1);
+var import_zod2 = require("zod");
+var MAX_LINE_LENGTH = 2e3;
+var FileReadTool = defineTool({
+  name: "file_read",
+  description: "Read the contents of a file. Returns the file content with line numbers. Use GlobTool to find files first.",
+  inputSchema: import_zod2.z.object({
+    path: import_zod2.z.string().describe("Absolute or relative path to the file"),
+    offset: import_zod2.z.number().optional().describe("Line number to start reading from (1-indexed)"),
+    limit: import_zod2.z.number().optional().describe("Maximum number of lines to read")
+  }),
+  isReadOnly: true,
+  isConcurrencySafe: true,
+  execute: async ({ path: filePath, offset, limit }, context) => {
+    try {
+      const resolved = import_node_path.default.isAbsolute(filePath) ? filePath : import_node_path.default.resolve(context.cwd, filePath);
+      const content = await import_promises.default.readFile(resolved, "utf-8");
+      const lines = content.split("\n");
+      const startLine = offset ? Math.max(1, offset) : 1;
+      const startIndex = startLine - 1;
+      const endIndex = limit != null ? startIndex + limit : lines.length;
+      const selected = lines.slice(startIndex, endIndex);
+      const formatted = selected.map((line, i) => {
+        const lineNum = startLine + i;
+        const truncated = line.length > MAX_LINE_LENGTH ? line.slice(0, MAX_LINE_LENGTH) + "..." : line;
+        return `${lineNum}: ${truncated}`;
+      }).join("\n");
+      return formatted;
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        return `Error: File not found: ${filePath}`;
+      }
+      if (err.code === "EISDIR") {
+        return `Error: Path is a directory: ${filePath}`;
+      }
+      return `Error reading file: ${err instanceof Error ? err.message : String(err)}`;
+    }
+  }
+});
+
+// src/tools/file-write.ts
+var import_promises2 = __toESM(require("fs/promises"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+var import_zod3 = require("zod");
+var FileWriteTool = defineTool({
+  name: "file_write",
+  description: "Write content to a file. Creates the file if it doesn't exist, overwrites if it does. Parent directories are created automatically.",
+  inputSchema: import_zod3.z.object({
+    path: import_zod3.z.string().describe("Path to the file"),
+    content: import_zod3.z.string().describe("Content to write")
+  }),
+  isReadOnly: false,
+  isConcurrencySafe: false,
+  execute: async ({ path: filePath, content }, context) => {
+    try {
+      const resolved = import_node_path2.default.isAbsolute(filePath) ? filePath : import_node_path2.default.resolve(context.cwd, filePath);
+      const dir = import_node_path2.default.dirname(resolved);
+      await import_promises2.default.mkdir(dir, { recursive: true });
+      await import_promises2.default.writeFile(resolved, content, "utf-8");
+      return `Wrote ${content.length} characters to ${filePath}`;
+    } catch (err) {
+      return `Error writing file: ${err instanceof Error ? err.message : String(err)}`;
+    }
+  }
+});
+
+// src/tools/file-edit.ts
+var import_promises3 = __toESM(require("fs/promises"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+var import_zod4 = require("zod");
+
+// src/tools/fuzzy-edit.ts
+var FuzzyEditError = class extends Error {
+  constructor(kind, message) {
+    super(message);
+    this.kind = kind;
+    this.name = "FuzzyEditError";
+  }
+  kind;
+};
+function levenshtein(a, b) {
+  const m = a.length;
+  const n = b.length;
+  if (m === 0) return n;
+  if (n === 0) return m;
+  const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+  for (let i = 0; i <= m; i++) dp[i][0] = i;
+  for (let j = 0; j <= n; j++) dp[0][j] = j;
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost);
+    }
+  }
+  return dp[m][n];
+}
+function similarity(a, b) {
+  if (a.length > 1e3 || b.length > 1e3) return a === b ? 1 : 0;
+  const maxLen = Math.max(a.length, b.length);
+  if (maxLen === 0) return 1;
+  return 1 - levenshtein(a, b) / maxLen;
+}
+function* simpleReplacer(content, find) {
+  if (content.includes(find)) yield find;
+}
+function* lineTrimmedReplacer(content, find) {
+  const lines = find.split("\n").map((l) => l.trim());
+  const contentLines = content.split("\n");
+  for (let i = 0; i <= contentLines.length - lines.length; i++) {
+    if (contentLines.slice(i, i + lines.length).every((cl, idx) => cl.trim() === lines[idx])) {
+      yield contentLines.slice(i, i + lines.length).join("\n");
+    }
+  }
+}
+function* blockAnchorReplacer(content, find) {
+  const findLines = find.split("\n");
+  const contentLines = content.split("\n");
+  if (findLines.length < 2) return;
+  const firstLine = findLines[0];
+  const lastLine = findLines[findLines.length - 1];
+  const middleLines = findLines.slice(1, -1);
+  for (let i = 0; i <= contentLines.length - findLines.length; i++) {
+    if (contentLines[i] !== firstLine) continue;
+    const endIdx = i + findLines.length - 1;
+    if (contentLines[endIdx] !== lastLine) continue;
+    const candidates = [];
+    for (let j = i + 1; j < endIdx; j++) {
+      candidates.push({ idx: j, score: 0 });
+    }
+    let totalScore = 0;
+    for (let k = 0; k < middleLines.length; k++) {
+      const contentLine = contentLines[i + 1 + k];
+      const sim = similarity(middleLines[k], contentLine);
+      totalScore += sim;
+      if (candidates[k]) candidates[k].score = sim;
+    }
+    const avgScore = totalScore / middleLines.length;
+    const threshold = candidates.length > 1 ? 0.3 : 0;
+    if (avgScore >= threshold) {
+      yield contentLines.slice(i, i + findLines.length).join("\n");
+    }
+  }
+}
+function* whitespaceNormalizedReplacer(content, find) {
+  const normFind = find.replace(/\s+/g, " ").trim();
+  if (!normFind) return;
+  const normContent = content.replace(/\s+/g, " ").trim();
+  const idx = normContent.indexOf(normFind);
+  if (idx === -1) return;
+  const firstWord = normFind.split(" ")[0];
+  const lastWord = normFind.split(" ").filter(Boolean).pop();
+  const firstIdx = content.indexOf(firstWord);
+  const lastIdx = content.lastIndexOf(lastWord);
+  if (firstIdx === -1 || lastIdx === -1 || lastIdx < firstIdx) return;
+  yield content.substring(firstIdx, lastIdx + lastWord.length);
+}
+function* indentationFlexibleReplacer(content, find) {
+  const lines = find.split("\n");
+  const minIndent = Math.min(...lines.filter((l) => l.trim().length > 0).map((l) => l.match(/^(\s*)/)?.[1].length ?? 0));
+  const dedented = lines.map((l) => l.substring(minIndent)).join("\n");
+  if (content.includes(dedented)) yield dedented;
+}
+function* escapeNormalizedReplacer(content, find) {
+  const normalized = find.replace(/\\n/g, "\n").replace(/\\t/g, "	").replace(/\\"/g, '"').replace(/\\'/g, "'");
+  if (content.includes(normalized)) yield normalized;
+}
+function* trimmedBoundaryReplacer(content, find) {
+  const trimmed = find.trim();
+  if (content.includes(trimmed)) yield trimmed;
+}
+function* contextAwareReplacer(content, find) {
+  const findLines = find.split("\n");
+  if (findLines.length < 3) return;
+  const firstLine = findLines[0].trim();
+  const lastLine = findLines[findLines.length - 1].trim();
+  const contentLines = content.split("\n");
+  for (let i = 0; i <= contentLines.length - 3; i++) {
+    if (contentLines[i].trim() !== firstLine) continue;
+    let bestEndIdx = -1;
+    let bestScore = 0;
+    for (let j = i + 2; j < contentLines.length; j++) {
+      if (contentLines[j].trim() === lastLine) {
+        const middleCount = j - i - 1;
+        let matchCount = 0;
+        for (let k = 1; k <= middleCount; k++) {
+          const fIdx = Math.floor(k / (middleCount + 1) * (findLines.length - 2));
+          if (fIdx >= 0 && fIdx < findLines.length - 2) {
+            if (similarity(contentLines[i + k].trim(), findLines[fIdx + 1].trim()) > 0.5) {
+              matchCount++;
+            }
+          }
+        }
+        const score = matchCount / middleCount;
+        if (score > bestScore) {
+          bestScore = score;
+          bestEndIdx = j;
+        }
+      }
+    }
+    if (bestEndIdx !== -1 && bestScore > 0.5) {
+      yield contentLines.slice(i, bestEndIdx + 1).join("\n");
+    }
+  }
+}
+var REPLACERS = [
+  simpleReplacer,
+  lineTrimmedReplacer,
+  blockAnchorReplacer,
+  whitespaceNormalizedReplacer,
+  indentationFlexibleReplacer,
+  escapeNormalizedReplacer,
+  trimmedBoundaryReplacer,
+  contextAwareReplacer
+];
+function fuzzyReplace(content, oldString, newString, replaceAll = false) {
+  for (const replacer of REPLACERS) {
+    for (const search of replacer(content, oldString)) {
+      const idx = content.indexOf(search);
+      if (idx === -1) continue;
+      if (replaceAll) {
+        return content.split(search).join(newString);
+      }
+      const firstIdx = content.indexOf(search);
+      const lastIdx = content.lastIndexOf(search);
+      if (firstIdx !== lastIdx) continue;
+      return content.substring(0, firstIdx) + newString + content.substring(firstIdx + search.length);
+    }
+  }
+  throw new FuzzyEditError("not_found", `Could not find match for replacement (after 8 fuzzy strategies)`);
+}
+function fuzzyContains(content, find) {
+  try {
+    fuzzyReplace(content, find, "PLACEHOLDER_CHECK");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/tools/file-edit.ts
+var FileEditTool = defineTool({
+  name: "file_edit",
+  description: "Edit an existing file by replacing a string match with new content. Uses 9-strategy fuzzy matching (exact, line-trimmed, block-anchor with Levenshtein, whitespace-normalized, indentation-flexible, escape-normalized, trimmed-boundary, context-aware, multi-occurrence) so the oldString does not need to be a perfect character-for-character match. For multi-line edits, include enough surrounding context to ensure uniqueness.",
+  inputSchema: import_zod4.z.object({
+    path: import_zod4.z.string().describe("Path to the file"),
+    oldString: import_zod4.z.string().describe("The string to find and replace (fuzzy-matched)"),
+    newString: import_zod4.z.string().describe("The replacement string"),
+    replaceAll: import_zod4.z.boolean().optional().describe("Replace all occurrences instead of just the first")
+  }),
+  isReadOnly: false,
+  isConcurrencySafe: false,
+  execute: async ({ path: filePath, oldString, newString, replaceAll = false }, context) => {
+    try {
+      const resolved = import_node_path3.default.isAbsolute(filePath) ? filePath : import_node_path3.default.resolve(context.cwd, filePath);
+      const content = await import_promises3.default.readFile(resolved, "utf-8");
+      let newContent;
+      let count = 0;
+      if (replaceAll) {
+        const occurrences = content.split(oldString).length - 1;
+        if (occurrences === 0) {
+          try {
+            newContent = fuzzyReplace(content, oldString, newString, true);
+            count = 1;
+          } catch {
+            return `Error: oldString not found in ${filePath} (tried 9 fuzzy strategies)`;
+          }
+        } else {
+          newContent = content.split(oldString).join(newString);
+          count = occurrences;
+        }
+      } else {
+        try {
+          newContent = fuzzyReplace(content, oldString, newString, false);
+          count = 1;
+        } catch (err) {
+          const kind = err.kind;
+          if (kind === "ambiguous") {
+            return `Error: Multiple matches for oldString in ${filePath}. Provide more surrounding context or set replaceAll to true.`;
+          }
+          return `Error: oldString not found in ${filePath} (tried 9 fuzzy strategies)`;
+        }
+      }
+      await import_promises3.default.writeFile(resolved, newContent, "utf-8");
+      return `Replaced ${count} occurrence(s) in ${filePath}`;
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        return `Error: File not found: ${filePath}`;
+      }
+      return `Error editing file: ${err instanceof Error ? err.message : String(err)}`;
+    }
+  }
+});
+
+// src/tools/glob.ts
+var import_promises4 = __toESM(require("fs/promises"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
+var import_zod5 = require("zod");
+init_utils();
+var MAX_RESULTS = 200;
+async function walkDir2(dir) {
+  const { walkDir: walk } = await Promise.resolve().then(() => (init_utils(), utils_exports));
+  const entries = await walk(dir);
+  return entries.map((e) => e.path);
+}
+function matchInclude(filePath, includePattern) {
+  if (!includePattern) return true;
+  const base = import_node_path4.default.basename(filePath);
+  const re = globToRegExp(includePattern);
+  return re.test(base);
+}
+var GlobTool = defineTool({
+  name: "glob",
+  description: "Find files matching a glob pattern. Returns matching file paths sorted by modification time.",
+  inputSchema: import_zod5.z.object({
+    pattern: import_zod5.z.string().describe('Glob pattern (e.g., "**/*.ts", "src/**/*.tsx")'),
+    path: import_zod5.z.string().optional().describe("Directory to search in (default: current directory)"),
+    include: import_zod5.z.string().optional().describe('File extension or pattern to include (e.g., "*.ts")')
+  }),
+  isReadOnly: true,
+  isConcurrencySafe: true,
+  execute: async ({ pattern, path: searchPath, include }, context) => {
+    try {
+      const searchDir = searchPath ? import_node_path4.default.isAbsolute(searchPath) ? searchPath : import_node_path4.default.resolve(context.cwd, searchPath) : context.cwd;
+      const allFiles = await walkDir2(searchDir);
+      const re = globToRegExp(pattern);
+      const matched = [];
+      for (const filePath of allFiles) {
+        const relative = import_node_path4.default.relative(searchDir, filePath);
+        if (re.test(relative) && matchInclude(relative, include)) {
+          try {
+            const stat = await import_promises4.default.stat(filePath);
+            matched.push({ filePath: relative, mtimeMs: stat.mtimeMs });
+          } catch {
+            matched.push({ filePath: relative, mtimeMs: 0 });
+          }
+        }
+      }
+      matched.sort((a, b) => b.mtimeMs - a.mtimeMs);
+      const limited = matched.slice(0, MAX_RESULTS);
+      return limited.map((m) => m.filePath).join("\n");
+    } catch (err) {
+      return `Error searching files: ${err instanceof Error ? err.message : String(err)}`;
+    }
+  }
+});
+
+// src/tools/grep.ts
+var import_promises5 = __toESM(require("fs/promises"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
+var import_zod6 = require("zod");
+init_utils();
+var MAX_MATCHES = 200;
+async function walkDir3(dir) {
+  const { walkDir: walk } = await Promise.resolve().then(() => (init_utils(), utils_exports));
+  const entries = await walk(dir);
+  return entries.map((e) => e.path);
+}
+var GrepTool = defineTool({
+  name: "grep",
+  description: "Search file contents using a regular expression. Returns matching file paths with line numbers.",
+  inputSchema: import_zod6.z.object({
+    pattern: import_zod6.z.string().describe("Regular expression to search for"),
+    path: import_zod6.z.string().optional().describe("Directory to search in"),
+    include: import_zod6.z.string().optional().describe('File pattern to include (e.g., "*.ts")')
+  }),
+  isReadOnly: true,
+  isConcurrencySafe: true,
+  execute: async ({ pattern, path: searchPath, include }, context) => {
+    try {
+      let regex;
+      try {
+        regex = new RegExp(pattern);
+      } catch {
+        return `Error: Invalid regular expression: ${pattern}`;
+      }
+      const searchDir = searchPath ? import_node_path5.default.isAbsolute(searchPath) ? searchPath : import_node_path5.default.resolve(context.cwd, searchPath) : context.cwd;
+      const includeRe = include ? globToRegExp(include) : null;
+      const allFiles = await walkDir3(searchDir);
+      const matches = [];
+      for (const filePath of allFiles) {
+        if (matches.length >= MAX_MATCHES) break;
+        if (includeRe) {
+          const base = import_node_path5.default.basename(filePath);
+          if (!includeRe.test(base)) continue;
+        }
+        let content;
+        try {
+          content = await import_promises5.default.readFile(filePath, "utf-8");
+        } catch {
+          continue;
+        }
+        const lines = content.split("\n");
+        const relative = import_node_path5.default.relative(searchDir, filePath);
+        for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+          if (matches.length >= MAX_MATCHES) break;
+          const line = lines[lineIdx];
+          if (regex.test(line)) {
+            matches.push(`${relative}:${lineIdx + 1}: ${line}`);
+            regex.lastIndex = 0;
+          } else {
+            regex.lastIndex = 0;
+          }
+        }
+      }
+      if (matches.length === 0) {
+        return "No matches found.";
+      }
+      return matches.join("\n");
+    } catch (err) {
+      return `Error searching files: ${err instanceof Error ? err.message : String(err)}`;
+    }
+  }
+});
+
+// src/tools/web-fetch.ts
+var import_zod7 = require("zod");
+var MAX_RESPONSE_SIZE = 100 * 1024;
+var WebFetchTool = defineTool({
+  name: "web_fetch",
+  description: "Fetch content from a URL. Returns the response body as text. Supports HTTP and HTTPS.",
+  inputSchema: import_zod7.z.object({
+    url: import_zod7.z.string().url().describe("The URL to fetch"),
+    method: import_zod7.z.enum(["GET", "POST", "PUT", "DELETE"]).optional().describe("HTTP method (default: GET)"),
+    headers: import_zod7.z.record(import_zod7.z.string()).optional().describe("Request headers"),
+    body: import_zod7.z.string().optional().describe("Request body (for POST/PUT)")
+  }),
+  isReadOnly: true,
+  isConcurrencySafe: true,
+  execute: async ({ url, method = "GET", headers, body }, context) => {
+    try {
+      if (context.abortSignal?.aborted) {
+        return "Request aborted before execution";
+      }
+      const timeoutSignal = AbortSignal.timeout(3e4);
+      let signal;
+      if (context.abortSignal) {
+        signal = AbortSignal.any([context.abortSignal, timeoutSignal]);
+      } else {
+        signal = timeoutSignal;
+      }
+      const fetchOptions = {
+        method,
+        headers,
+        signal,
+        redirect: "follow"
+      };
+      if (body && method !== "GET") {
+        fetchOptions.body = body;
+      }
+      const response = await fetch(url, fetchOptions);
+      const contentType = response.headers.get("content-type") ?? "unknown";
+      const status = response.status;
+      const text = await response.text();
+      let result = `Status: ${status}
+Content-Type: ${contentType}
+
+`;
+      if (text.length > MAX_RESPONSE_SIZE) {
+        const half = Math.floor(MAX_RESPONSE_SIZE / 2);
+        const notice = `
+
+... [response truncated: showing first ${half} and last ${half} of ${text.length} characters] ...
+
+`;
+        result += text.slice(0, half) + notice + text.slice(-half);
+      } else {
+        result += text;
+      }
+      return result;
+    } catch (err) {
+      if (err instanceof Error && err.name === "AbortError") {
+        return "Request aborted";
+      }
+      return `Error fetching URL: ${err instanceof Error ? err.message : String(err)}`;
+    }
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BashTool,
+  FileEditTool,
+  FileReadTool,
+  FileWriteTool,
+  FuzzyEditError,
+  GlobTool,
+  GrepTool,
+  ToolRegistry,
+  WebFetchTool,
+  defineTool,
+  defineToolFromClass,
+  fuzzyContains,
+  fuzzyReplace,
+  orchestrateTools
+});
+//# sourceMappingURL=index.cjs.map