@cuylabs/agent-code 0.1.0

package/dist/chunk-IOXLKDEB.js

@@ -0,0 +1,815 @@
+// src/tools/bash.ts
+import { z } from "zod";
+import { Tool, truncateOutput } from "@cuylabs/agent-core";
+var DEFAULT_TIMEOUT = 2 * 60 * 1e3;
+var bashParameters = z.object({
+  command: z.string().describe("The shell command to execute"),
+  timeout: z.number().optional().describe("Timeout in milliseconds (default: 120000)"),
+  workdir: z.string().optional().describe("Working directory to run the command in. Defaults to current working directory."),
+  description: z.string().describe("Clear, concise description of what this command does in 5-10 words")
+});
+async function executeBash(params, host, cwd, abort) {
+  const workdir = params.workdir || cwd;
+  const timeout = params.timeout ?? DEFAULT_TIMEOUT;
+  if (!await host.exists(workdir)) {
+    throw new Error(`Working directory does not exist: ${workdir}`);
+  }
+  return host.exec(params.command, {
+    cwd: workdir,
+    timeout,
+    signal: abort,
+    env: {
+      // Force color output
+      FORCE_COLOR: "1",
+      TERM: "xterm-256color"
+    }
+  });
+}
+var bashTool = Tool.define("bash", {
+  description: `Execute a shell command in the working directory.
+
+IMPORTANT:
+- Commands run in a non-interactive shell
+- Long-running commands will timeout after 2 minutes by default
+- Use 'workdir' parameter instead of 'cd' commands
+- Output is automatically truncated if too long
+- For pager commands, output is piped through 'cat' automatically`,
+  parameters: bashParameters,
+  async execute(params, ctx) {
+    const host = ctx.host;
+    const result = await executeBash(params, host, ctx.cwd, ctx.abort);
+    let output = "";
+    if (result.stdout) {
+      output += result.stdout;
+    }
+    if (result.stderr) {
+      if (output) output += "\n";
+      output += `[stderr]
+${result.stderr}`;
+    }
+    if (result.timedOut) {
+      output += `
+
+[Command timed out after ${params.timeout ?? DEFAULT_TIMEOUT}ms]`;
+    } else if (result.exitCode !== 0) {
+      output += `
+
+[Exit code: ${result.exitCode}]`;
+    }
+    const truncated = truncateOutput(output);
+    return {
+      title: params.description || params.command.slice(0, 50),
+      output: truncated.content,
+      metadata: {
+        exitCode: result.exitCode,
+        timedOut: result.timedOut,
+        truncated: truncated.truncated,
+        outputPath: truncated.outputPath
+      }
+    };
+  }
+});
+
+// src/tools/read.ts
+import { z as z2 } from "zod";
+import * as path from "path";
+import { Tool as Tool2 } from "@cuylabs/agent-core";
+var DEFAULT_READ_LIMIT = 2e3;
+var MAX_LINE_LENGTH = 2e3;
+var MAX_BYTES = 50 * 1024;
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".zip",
+  ".tar",
+  ".gz",
+  ".exe",
+  ".dll",
+  ".so",
+  ".class",
+  ".jar",
+  ".war",
+  ".7z",
+  ".doc",
+  ".docx",
+  ".xls",
+  ".xlsx",
+  ".ppt",
+  ".pptx",
+  ".odt",
+  ".ods",
+  ".odp",
+  ".bin",
+  ".dat",
+  ".obj",
+  ".o",
+  ".a",
+  ".lib",
+  ".wasm",
+  ".pyc",
+  ".pyo",
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".bmp",
+  ".ico",
+  ".webp",
+  ".mp3",
+  ".mp4",
+  ".avi",
+  ".mov",
+  ".mkv",
+  ".wav",
+  ".flac"
+]);
+async function isBinaryFile(filepath, host) {
+  const ext = path.extname(filepath).toLowerCase();
+  if (BINARY_EXTENSIONS.has(ext)) {
+    return true;
+  }
+  try {
+    const buffer = await host.readBytes(filepath, 0, 4096);
+    for (let i = 0; i < buffer.length; i++) {
+      if (buffer[i] === 0) {
+        return true;
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+var readParameters = z2.object({
+  filePath: z2.string().describe("The path to the file to read"),
+  offset: z2.number().optional().describe("The line number to start reading from (0-based)"),
+  limit: z2.number().optional().describe(`The number of lines to read (defaults to ${DEFAULT_READ_LIMIT})`)
+});
+var readTool = Tool2.define("read", {
+  description: `Read the contents of a file.
+
+IMPORTANT:
+- Returns content with line numbers for easy reference
+- Large files are automatically truncated
+- Use 'offset' parameter to read beyond the default limit
+- Binary files cannot be read
+- Images and PDFs are returned as attachments`,
+  parameters: readParameters,
+  async execute(params, ctx) {
+    const host = ctx.host;
+    let filepath = params.filePath;
+    if (!path.isAbsolute(filepath)) {
+      filepath = path.resolve(ctx.cwd, filepath);
+    }
+    const title = path.relative(ctx.cwd, filepath);
+    if (!await host.exists(filepath)) {
+      const dir = path.dirname(filepath);
+      const base = path.basename(filepath);
+      let suggestions = [];
+      try {
+        const entries = await host.readdir(dir);
+        suggestions = entries.filter(
+          (entry) => entry.name.toLowerCase().includes(base.toLowerCase()) || base.toLowerCase().includes(entry.name.toLowerCase())
+        ).map((entry) => path.join(dir, entry.name)).slice(0, 3);
+      } catch {
+      }
+      if (suggestions.length > 0) {
+        throw new Error(
+          `File not found: ${filepath}
+
+Did you mean one of these?
+${suggestions.join("\n")}`
+        );
+      }
+      throw new Error(`File not found: ${filepath}`);
+    }
+    if (await isBinaryFile(filepath, host)) {
+      throw new Error(`Cannot read binary file: ${filepath}`);
+    }
+    const content = await host.readFile(filepath);
+    const allLines = content.split("\n");
+    const limit = params.limit ?? DEFAULT_READ_LIMIT;
+    const offset = params.offset || 0;
+    const lines = [];
+    let bytes = 0;
+    let truncatedByBytes = false;
+    for (let i = offset; i < Math.min(allLines.length, offset + limit); i++) {
+      let line = allLines[i];
+      if (line.length > MAX_LINE_LENGTH) {
+        line = line.substring(0, MAX_LINE_LENGTH) + "...";
+      }
+      const size = Buffer.byteLength(line, "utf-8") + (lines.length > 0 ? 1 : 0);
+      if (bytes + size > MAX_BYTES) {
+        truncatedByBytes = true;
+        break;
+      }
+      lines.push(line);
+      bytes += size;
+    }
+    const formatted = lines.map((line, index) => {
+      const lineNum = (index + offset + 1).toString().padStart(5, "0");
+      return `${lineNum}| ${line}`;
+    });
+    let output = "<file>\n";
+    output += formatted.join("\n");
+    const totalLines = allLines.length;
+    const lastReadLine = offset + lines.length;
+    const hasMoreLines = totalLines > lastReadLine;
+    const truncated = hasMoreLines || truncatedByBytes;
+    if (truncatedByBytes) {
+      output += `
+
+(Output truncated at ${MAX_BYTES} bytes. Use 'offset' parameter to read beyond line ${lastReadLine})`;
+    } else if (hasMoreLines) {
+      output += `
+
+(File has more lines. Use 'offset' parameter to read beyond line ${lastReadLine})`;
+    } else {
+      output += `
+
+(End of file - total ${totalLines} lines)`;
+    }
+    output += "\n</file>";
+    return {
+      title,
+      output,
+      metadata: {
+        totalLines,
+        linesRead: lines.length,
+        offset,
+        truncated,
+        preview: lines.slice(0, 20).join("\n")
+      }
+    };
+  }
+});
+
+// src/tools/edit.ts
+import { z as z3 } from "zod";
+import * as path2 from "path";
+import { Tool as Tool3 } from "@cuylabs/agent-core";
+function normalizeLineEndings(text) {
+  return text.replaceAll("\r\n", "\n");
+}
+function createDiff(filepath, oldContent, newContent) {
+  const oldLines = normalizeLineEndings(oldContent).split("\n");
+  const newLines = normalizeLineEndings(newContent).split("\n");
+  const diff = [];
+  diff.push(`--- ${filepath}`);
+  diff.push(`+++ ${filepath}`);
+  let i = 0, j = 0;
+  let chunk = [];
+  let chunkStart = 0;
+  let inChunk = false;
+  while (i < oldLines.length || j < newLines.length) {
+    if (i < oldLines.length && j < newLines.length && oldLines[i] === newLines[j]) {
+      if (inChunk && chunk.length > 0) {
+        const context = oldLines.slice(i, Math.min(i + 3, oldLines.length));
+        chunk.push(...context.map((l) => ` ${l}`));
+        diff.push(`@@ -${chunkStart + 1} +${chunkStart + 1} @@`);
+        diff.push(...chunk);
+        chunk = [];
+        inChunk = false;
+      }
+      i++;
+      j++;
+    } else {
+      if (!inChunk) {
+        chunkStart = Math.max(0, i - 3);
+        const context = oldLines.slice(chunkStart, i);
+        chunk = context.map((l) => ` ${l}`);
+        inChunk = true;
+      }
+      if (i < oldLines.length && (j >= newLines.length || oldLines[i] !== newLines[j])) {
+        chunk.push(`-${oldLines[i]}`);
+        i++;
+      }
+      if (j < newLines.length && (i >= oldLines.length || oldLines[i - 1] !== newLines[j])) {
+        chunk.push(`+${newLines[j]}`);
+        j++;
+      }
+    }
+  }
+  if (chunk.length > 0) {
+    diff.push(`@@ -${chunkStart + 1} +${chunkStart + 1} @@`);
+    diff.push(...chunk);
+  }
+  return diff.join("\n");
+}
+function findTextFuzzy(content, searchText) {
+  const exactIndex = content.indexOf(searchText);
+  if (exactIndex !== -1) {
+    return { index: exactIndex, match: searchText };
+  }
+  const normalizedSearch = searchText.replace(/\s+/g, " ").trim();
+  const normalizedContent = content.replace(/\s+/g, " ");
+  const normalizedIndex = normalizedContent.indexOf(normalizedSearch);
+  if (normalizedIndex !== -1) {
+    let origIndex = 0;
+    let normIndex = 0;
+    while (normIndex < normalizedIndex && origIndex < content.length) {
+      if (/\s/.test(content[origIndex])) {
+        while (origIndex < content.length && /\s/.test(content[origIndex])) {
+          origIndex++;
+        }
+        normIndex++;
+      } else {
+        origIndex++;
+        normIndex++;
+      }
+    }
+    let endOrigIndex = origIndex;
+    let endNormIndex = normIndex;
+    while (endNormIndex < normalizedIndex + normalizedSearch.length && endOrigIndex < content.length) {
+      if (/\s/.test(content[endOrigIndex])) {
+        while (endOrigIndex < content.length && /\s/.test(content[endOrigIndex])) {
+          endOrigIndex++;
+        }
+        endNormIndex++;
+      } else {
+        endOrigIndex++;
+        endNormIndex++;
+      }
+    }
+    return {
+      index: origIndex,
+      match: content.slice(origIndex, endOrigIndex)
+    };
+  }
+  return null;
+}
+var editParameters = z3.object({
+  filePath: z3.string().describe("The absolute path to the file to modify"),
+  oldString: z3.string().describe("The text to replace (must match exactly or with minor whitespace differences)"),
+  newString: z3.string().describe("The text to replace it with (must be different from oldString)"),
+  replaceAll: z3.boolean().optional().describe("Replace all occurrences of oldString (default: false)")
+});
+var editTool = Tool3.define("edit", {
+  description: `Edit a file by replacing exact text with new text.
+
+IMPORTANT:
+- The oldString must match text in the file exactly (whitespace matters)
+- oldString and newString must be different
+- By default, only the first occurrence is replaced
+- Use replaceAll: true to replace all occurrences
+- For creating new files, use the write tool instead`,
+  parameters: editParameters,
+  // Enable automatic baseline capture for turn tracking
+  fileOps: {
+    pathArgs: ["filePath"],
+    operationType: "write"
+  },
+  async execute(params, ctx) {
+    if (params.oldString === params.newString) {
+      throw new Error("oldString and newString must be different");
+    }
+    let filepath = params.filePath;
+    if (!path2.isAbsolute(filepath)) {
+      filepath = path2.resolve(ctx.cwd, filepath);
+    }
+    const host = ctx.host;
+    const title = path2.relative(ctx.cwd, filepath);
+    if (params.oldString === "") {
+      await host.mkdir(path2.dirname(filepath));
+      await host.writeFile(filepath, params.newString);
+      return {
+        title,
+        output: `Created new file: ${filepath}`,
+        metadata: {
+          filepath,
+          created: true,
+          additions: params.newString.split("\n").length,
+          deletions: 0,
+          diff: ""
+        }
+      };
+    }
+    let content;
+    try {
+      content = await host.readFile(filepath);
+    } catch {
+      throw new Error(`File not found: ${filepath}`);
+    }
+    const found = findTextFuzzy(content, params.oldString);
+    if (!found) {
+      const lines = content.split("\n").slice(0, 50);
+      throw new Error(
+        `Could not find the specified text in the file.
+
+First 50 lines of file:
+${lines.map((l, i) => `${i + 1}: ${l}`).join("\n")}`
+      );
+    }
+    let newContent;
+    if (params.replaceAll) {
+      newContent = content.split(found.match).join(params.newString);
+    } else {
+      newContent = content.slice(0, found.index) + params.newString + content.slice(found.index + found.match.length);
+    }
+    await host.writeFile(filepath, newContent);
+    const diff = createDiff(filepath, content, newContent);
+    let additions = 0;
+    let deletions = 0;
+    const oldLines = content.split("\n").length;
+    const newLines = newContent.split("\n").length;
+    additions = Math.max(0, newLines - oldLines);
+    deletions = Math.max(0, oldLines - newLines);
+    return {
+      title,
+      output: `Edit applied successfully.
+
+${diff}`,
+      metadata: {
+        filepath,
+        created: false,
+        additions,
+        deletions,
+        diff
+      }
+    };
+  }
+});
+
+// src/tools/write.ts
+import { z as z4 } from "zod";
+import * as path3 from "path";
+import { Tool as Tool4 } from "@cuylabs/agent-core";
+var writeParameters = z4.object({
+  filePath: z4.string().describe("The absolute path to the file to write"),
+  content: z4.string().describe("The content to write to the file")
+});
+var writeTool = Tool4.define("write", {
+  description: `Write content to a file, creating it if it doesn't exist or overwriting if it does.
+
+IMPORTANT:
+- Use this for creating new files
+- For modifying existing files, prefer the edit tool
+- Parent directories are created automatically
+- Existing content is completely replaced`,
+  parameters: writeParameters,
+  // Enable automatic baseline capture for turn tracking
+  fileOps: {
+    pathArgs: ["filePath"],
+    operationType: "write"
+  },
+  async execute(params, ctx) {
+    let filepath = params.filePath;
+    if (!path3.isAbsolute(filepath)) {
+      filepath = path3.resolve(ctx.cwd, filepath);
+    }
+    const title = path3.relative(ctx.cwd, filepath);
+    const host = ctx.host;
+    let exists = false;
+    let oldContent = "";
+    try {
+      oldContent = await host.readFile(filepath);
+      exists = true;
+    } catch {
+    }
+    await host.mkdir(path3.dirname(filepath));
+    await host.writeFile(filepath, params.content);
+    const action = exists ? "Updated" : "Created";
+    let output = `${action} file: ${filepath}`;
+    if (exists && oldContent !== params.content) {
+      const oldLines = oldContent.split("\n").length;
+      const newLines = params.content.split("\n").length;
+      output += `
+
+Changes: ${oldLines} \u2192 ${newLines} lines`;
+    } else if (!exists) {
+      const lines = params.content.split("\n").length;
+      output += `
+
+Created with ${lines} lines`;
+    }
+    return {
+      title,
+      output,
+      metadata: {
+        filepath,
+        created: !exists,
+        updated: exists,
+        lines: params.content.split("\n").length
+      }
+    };
+  }
+});
+
+// src/tools/grep.ts
+import { z as z5 } from "zod";
+import * as path4 from "path";
+import { Tool as Tool5 } from "@cuylabs/agent-core";
+var MAX_LINE_LENGTH2 = 2e3;
+var MAX_RESULTS = 100;
+function sq(s) {
+  return "'" + s.replace(/'/g, "'\\''") + "'";
+}
+var grepParameters = z5.object({
+  pattern: z5.string().describe("The regex pattern to search for in file contents"),
+  path: z5.string().optional().describe("The directory to search in. Defaults to current working directory."),
+  include: z5.string().optional().describe('File pattern to include in the search (e.g. "*.js", "*.{ts,tsx}")')
+});
+async function executeGrep(params, host, cwd, abort) {
+  const searchPath = params.path ? path4.isAbsolute(params.path) ? params.path : path4.resolve(cwd, params.path) : cwd;
+  const parts = [
+    "rg",
+    "-nH",
+    "--hidden",
+    "--no-messages",
+    sq("--field-match-separator=|"),
+    "--regexp",
+    sq(params.pattern)
+  ];
+  if (params.include) {
+    parts.push("--glob", sq(params.include));
+  }
+  parts.push(sq(searchPath));
+  const result = await host.exec(parts.join(" "), {
+    cwd: searchPath,
+    signal: abort
+  });
+  if (result.exitCode === 1 || result.exitCode === 2 && !result.stdout.trim()) {
+    return { matches: [], truncated: false };
+  }
+  if (result.exitCode !== 0 && result.exitCode !== 2) {
+    throw new Error(`ripgrep failed: ${result.stderr}`);
+  }
+  const lines = result.stdout.trim().split(/\r?\n/);
+  const matches = [];
+  let truncated = false;
+  for (const line of lines) {
+    if (!line) continue;
+    const [filePath, lineNumStr, ...textParts] = line.split("|");
+    if (!filePath || !lineNumStr || textParts.length === 0) continue;
+    const lineNum = parseInt(lineNumStr, 10);
+    let lineText = textParts.join("|");
+    if (lineText.length > MAX_LINE_LENGTH2) {
+      lineText = lineText.slice(0, MAX_LINE_LENGTH2) + "...";
+    }
+    if (matches.length >= MAX_RESULTS) {
+      truncated = true;
+      break;
+    }
+    matches.push({
+      file: filePath,
+      line: lineNum,
+      text: lineText
+    });
+  }
+  return { matches, truncated };
+}
+var grepTool = Tool5.define("grep", {
+  description: `Search for a pattern in file contents using ripgrep.
+
+IMPORTANT:
+- Uses regex pattern matching
+- Searches recursively in the specified directory
+- Use 'include' to filter by file extension
+- Results are sorted by modification time (newest first)
+- Maximum ${MAX_RESULTS} results returned`,
+  parameters: grepParameters,
+  async execute(params, ctx) {
+    if (!params.pattern) {
+      throw new Error("pattern is required");
+    }
+    const host = ctx.host;
+    const result = await executeGrep(params, host, ctx.cwd, ctx.abort);
+    if (result.matches.length === 0) {
+      return {
+        title: params.pattern,
+        output: "No matches found",
+        metadata: { matches: 0, truncated: false }
+      };
+    }
+    const output = result.matches.map((m) => `${m.file}:${m.line}: ${m.text}`);
+    if (result.truncated) {
+      output.push("");
+      output.push(`(Results truncated to ${MAX_RESULTS} matches)`);
+    }
+    return {
+      title: params.pattern,
+      output: output.join("\n"),
+      metadata: {
+        matches: result.matches.length,
+        truncated: result.truncated
+      }
+    };
+  }
+});
+
+// src/tools/glob.ts
+import { z as z6 } from "zod";
+import * as path5 from "path";
+import { Tool as Tool6 } from "@cuylabs/agent-core";
+var MAX_RESULTS2 = 100;
+function sq2(s) {
+  return "'" + s.replace(/'/g, "'\\''") + "'";
+}
+async function findFiles(pattern, cwd, host, abort) {
+  const files = [];
+  let truncated = false;
+  try {
+    const result = await host.exec(
+      `rg --files --glob ${sq2(pattern)}`,
+      { cwd, signal: abort }
+    );
+    if (result.exitCode === 0 || result.exitCode === 1) {
+      const found = result.stdout.trim().split(/\r?\n/).filter(Boolean);
+      for (const file of found) {
+        if (files.length >= MAX_RESULTS2) {
+          truncated = true;
+          break;
+        }
+        files.push(path5.resolve(cwd, file));
+      }
+      return { files, truncated };
+    }
+  } catch {
+  }
+  const globPattern = new RegExp(
+    "^" + pattern.replace(/\*\*/g, "<<<DOUBLESTAR>>>").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(/<<<DOUBLESTAR>>>/g, ".*") + "$"
+  );
+  async function walk(dir, base = "") {
+    if (abort?.aborted) return;
+    if (files.length >= MAX_RESULTS2) {
+      truncated = true;
+      return;
+    }
+    const entries = await host.readdir(dir);
+    for (const entry of entries) {
+      if (abort?.aborted || files.length >= MAX_RESULTS2) {
+        truncated = true;
+        break;
+      }
+      if (entry.name.startsWith(".") || entry.name === "node_modules") {
+        continue;
+      }
+      const relativePath = base ? `${base}/${entry.name}` : entry.name;
+      const fullPath = path5.join(dir, entry.name);
+      if (entry.isDirectory) {
+        await walk(fullPath, relativePath);
+      } else if (globPattern.test(relativePath)) {
+        files.push(fullPath);
+      }
+    }
+  }
+  await walk(cwd);
+  return { files, truncated };
+}
+var globParameters = z6.object({
+  pattern: z6.string().describe('The glob pattern to match files (e.g. "**/*.ts", "src/**/*.js")'),
+  path: z6.string().optional().describe("The directory to search in. Defaults to current working directory.")
+});
+var globTool = Tool6.define("glob", {
+  description: `Find files matching a glob pattern.
+
+IMPORTANT:
+- Use ** to match any directory depth
+- Use * to match any characters within a path segment
+- Results are sorted by modification time (newest first)
+- Maximum ${MAX_RESULTS2} results returned`,
+  parameters: globParameters,
+  async execute(params, ctx) {
+    const host = ctx.host;
+    const searchPath = params.path ? path5.isAbsolute(params.path) ? params.path : path5.resolve(ctx.cwd, params.path) : ctx.cwd;
+    const { files, truncated } = await findFiles(params.pattern, searchPath, host, ctx.abort);
+    if (files.length === 0) {
+      return {
+        title: params.pattern,
+        output: "No files found",
+        metadata: { count: 0, truncated: false }
+      };
+    }
+    const filesWithMtime = await Promise.all(
+      files.map(async (f) => {
+        try {
+          const s = await host.stat(f);
+          return { path: f, mtime: s.mtime.getTime() };
+        } catch {
+          return { path: f, mtime: 0 };
+        }
+      })
+    );
+    filesWithMtime.sort((a, b) => b.mtime - a.mtime);
+    const output = filesWithMtime.map((f) => f.path);
+    if (truncated) {
+      output.push("");
+      output.push(`(Results truncated to ${MAX_RESULTS2} files)`);
+    }
+    return {
+      title: path5.relative(ctx.cwd, searchPath) || ".",
+      output: output.join("\n"),
+      metadata: {
+        count: files.length,
+        truncated
+      }
+    };
+  }
+});
+
+// src/tools/defaults.ts
+var defaultCodingTools = [
+  bashTool,
+  readTool,
+  editTool,
+  writeTool,
+  grepTool,
+  globTool
+];
+
+// src/tools/toolset.ts
+import { defaultRegistry } from "@cuylabs/agent-core";
+function setupToolRegistry() {
+  for (const tool of [bashTool, readTool, editTool, writeTool, grepTool, globTool]) {
+    defaultRegistry.set(tool);
+  }
+  defaultRegistry.registerGroup("all", ["bash", "read", "edit", "write", "grep", "glob"]);
+  defaultRegistry.registerGroup("read-only", ["read", "grep", "glob"]);
+  defaultRegistry.registerGroup("safe", ["read", "edit", "write", "grep", "glob"]);
+  defaultRegistry.registerGroup("minimal", ["read", "write"]);
+}
+var ToolsetBuilder = class {
+  tools;
+  constructor(base) {
+    setupToolRegistry();
+    this.tools = /* @__PURE__ */ new Map();
+    if (base !== void 0) {
+      const resolved = defaultRegistry.resolve(base);
+      for (const tool of resolved) {
+        this.tools.set(tool.id, tool);
+      }
+    }
+  }
+  /** Add a tool by ID (from registry) or by instance. */
+  add(tool) {
+    if (typeof tool === "string") {
+      if (defaultRegistry.hasGroup(tool)) {
+        const group = defaultRegistry.getGroup(tool);
+        for (const t of group) {
+          this.tools.set(t.id, t);
+        }
+      } else {
+        const resolved = defaultRegistry.get(tool);
+        if (resolved) {
+          this.tools.set(resolved.id, resolved);
+        }
+      }
+    } else {
+      this.tools.set(tool.id, tool);
+    }
+    return this;
+  }
+  /** Remove a tool by ID. */
+  remove(id) {
+    if (defaultRegistry.hasGroup(id)) {
+      const group = defaultRegistry.getGroup(id);
+      for (const t of group) {
+        this.tools.delete(t.id);
+      }
+    } else {
+      this.tools.delete(id);
+    }
+    return this;
+  }
+  /** Keep only the specified tool IDs (intersection). */
+  only(...ids) {
+    const keep = new Set(ids);
+    for (const id of Array.from(this.tools.keys())) {
+      if (!keep.has(id)) {
+        this.tools.delete(id);
+      }
+    }
+    return this;
+  }
+  /** Return the final tool array. */
+  build() {
+    return Array.from(this.tools.values());
+  }
+};
+function toolset(base) {
+  return new ToolsetBuilder(base);
+}
+function resolveTools(spec) {
+  setupToolRegistry();
+  return defaultRegistry.resolve(spec);
+}
+
+export {
+  bashParameters,
+  executeBash,
+  bashTool,
+  readParameters,
+  readTool,
+  editParameters,
+  editTool,
+  writeParameters,
+  writeTool,
+  grepParameters,
+  executeGrep,
+  grepTool,
+  globParameters,
+  globTool,
+  defaultCodingTools,
+  setupToolRegistry,
+  ToolsetBuilder,
+  toolset,
+  resolveTools
+};