bashkit 0.1.0

package/dist/index.js

@@ -0,0 +1,1805 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/middleware/anthropic-cache.ts
+function ensureCacheMarker(message) {
+  if (!message)
+    return;
+  if (!("content" in message))
+    return;
+  const content = message.content;
+  if (!content || !Array.isArray(content))
+    return;
+  const lastPart = content.at(-1);
+  if (!lastPart || typeof lastPart === "string")
+    return;
+  lastPart.providerOptions = {
+    ...lastPart.providerOptions,
+    anthropic: {
+      cacheControl: { type: "ephemeral" }
+    }
+  };
+}
+var anthropicPromptCacheMiddleware = {
+  transformParams: async ({
+    params
+  }) => {
+    const messages = params.prompt;
+    if (!messages || messages.length === 0) {
+      return params;
+    }
+    ensureCacheMarker(messages.at(-1));
+    ensureCacheMarker(messages.slice(0, -1).findLast((m) => m.role !== "assistant"));
+    return {
+      ...params,
+      prompt: messages
+    };
+  }
+};
+// src/sandbox/e2b.ts
+import { Sandbox as E2BSandboxSDK } from "@e2b/code-interpreter";
+function createE2BSandbox(config = {}) {
+  let sandbox = null;
+  const workingDirectory = config.cwd || "/home/user";
+  const timeout = config.timeout ?? 300000;
+  const ensureSandbox = async () => {
+    if (sandbox)
+      return sandbox;
+    sandbox = await E2BSandboxSDK.create({
+      apiKey: config.apiKey,
+      timeoutMs: timeout,
+      metadata: config.metadata
+    });
+    return sandbox;
+  };
+  const exec = async (command, options) => {
+    const sbx = await ensureSandbox();
+    const startTime = performance.now();
+    try {
+      const result = await sbx.commands.run(command, {
+        cwd: options?.cwd || workingDirectory,
+        timeoutMs: options?.timeout
+      });
+      const durationMs = Math.round(performance.now() - startTime);
+      return {
+        stdout: result.stdout,
+        stderr: result.stderr,
+        exitCode: result.exitCode,
+        durationMs,
+        interrupted: false
+      };
+    } catch (error) {
+      const durationMs = Math.round(performance.now() - startTime);
+      if (error instanceof Error && error.message.toLowerCase().includes("timeout")) {
+        return {
+          stdout: "",
+          stderr: "Command timed out",
+          exitCode: 124,
+          durationMs,
+          interrupted: true
+        };
+      }
+      if (error instanceof Error) {
+        const exitMatch = error.message.match(/exit status (\d+)/i);
+        const exitCode = exitMatch ? parseInt(exitMatch[1], 10) : 1;
+        return {
+          stdout: "",
+          stderr: error.message,
+          exitCode,
+          durationMs,
+          interrupted: false
+        };
+      }
+      throw error;
+    }
+  };
+  return {
+    exec,
+    async readFile(path) {
+      const result = await exec(`cat "${path}"`);
+      if (result.exitCode !== 0) {
+        throw new Error(`Failed to read file: ${result.stderr}`);
+      }
+      return result.stdout;
+    },
+    async writeFile(path, content) {
+      const sbx = await ensureSandbox();
+      await sbx.files.write(path, content);
+    },
+    async readDir(path) {
+      const result = await exec(`ls -1 "${path}"`);
+      if (result.exitCode !== 0) {
+        throw new Error(`Failed to read directory: ${result.stderr}`);
+      }
+      return result.stdout.split(`
+`).filter(Boolean);
+    },
+    async fileExists(path) {
+      const result = await exec(`test -e "${path}"`);
+      return result.exitCode === 0;
+    },
+    async isDirectory(path) {
+      const result = await exec(`test -d "${path}"`);
+      return result.exitCode === 0;
+    },
+    async destroy() {
+      if (sandbox) {
+        await sandbox.kill();
+        sandbox = null;
+      }
+    }
+  };
+}
+// src/sandbox/local.ts
+import { existsSync, mkdirSync } from "node:fs";
+function createLocalSandbox(config = {}) {
+  const workingDirectory = config.cwd || "/tmp";
+  if (!existsSync(workingDirectory)) {
+    mkdirSync(workingDirectory, { recursive: true });
+  }
+  const exec = async (command, options) => {
+    const startTime = performance.now();
+    let interrupted = false;
+    const cwd = options?.cwd || workingDirectory;
+    if (!existsSync(cwd)) {
+      mkdirSync(cwd, { recursive: true });
+    }
+    const proc = Bun.spawn(["sh", "-c", command], {
+      cwd,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    let timeoutId;
+    if (options?.timeout) {
+      timeoutId = setTimeout(() => {
+        interrupted = true;
+        proc.kill();
+      }, options.timeout);
+    }
+    const stdout = await new Response(proc.stdout).text();
+    const stderr = await new Response(proc.stderr).text();
+    const exitCode = await proc.exited;
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    const durationMs = Math.round(performance.now() - startTime);
+    return {
+      stdout,
+      stderr,
+      exitCode,
+      durationMs,
+      interrupted
+    };
+  };
+  return {
+    exec,
+    async readFile(path) {
+      const fullPath = path.startsWith("/") ? path : `${workingDirectory}/${path}`;
+      const file = Bun.file(fullPath);
+      return await file.text();
+    },
+    async writeFile(path, content) {
+      const fullPath = path.startsWith("/") ? path : `${workingDirectory}/${path}`;
+      await Bun.write(fullPath, content);
+    },
+    async readDir(path) {
+      const fullPath = path.startsWith("/") ? path : `${workingDirectory}/${path}`;
+      const fs = await import("fs/promises");
+      return await fs.readdir(fullPath);
+    },
+    async fileExists(path) {
+      const fullPath = path.startsWith("/") ? path : `${workingDirectory}/${path}`;
+      const fs = await import("fs/promises");
+      try {
+        await fs.stat(fullPath);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    async isDirectory(path) {
+      const fullPath = path.startsWith("/") ? path : `${workingDirectory}/${path}`;
+      const fs = await import("fs/promises");
+      try {
+        const stat = await fs.stat(fullPath);
+        return stat.isDirectory();
+      } catch {
+        return false;
+      }
+    },
+    async destroy() {}
+  };
+}
+// src/sandbox/vercel.ts
+import { Sandbox as VercelSandboxSDK } from "@vercel/sandbox";
+function createVercelSandbox(config = {}) {
+  let sandbox = null;
+  const workingDirectory = config.cwd || "/vercel/sandbox";
+  const resolvedConfig = {
+    runtime: config.runtime ?? "node22",
+    resources: config.resources ?? { vcpus: 2 },
+    timeout: config.timeout ?? 300000
+  };
+  const ensureSandbox = async () => {
+    if (sandbox)
+      return sandbox;
+    const createOptions = {
+      runtime: resolvedConfig.runtime,
+      resources: resolvedConfig.resources,
+      timeout: resolvedConfig.timeout
+    };
+    if (config.teamId && config.token) {
+      Object.assign(createOptions, {
+        teamId: config.teamId,
+        token: config.token
+      });
+    }
+    sandbox = await VercelSandboxSDK.create(createOptions);
+    return sandbox;
+  };
+  const exec = async (command, options) => {
+    const sbx = await ensureSandbox();
+    const startTime = performance.now();
+    let interrupted = false;
+    const abortController = new AbortController;
+    let timeoutId;
+    if (options?.timeout) {
+      timeoutId = setTimeout(() => {
+        interrupted = true;
+        abortController.abort();
+      }, options.timeout);
+    }
+    try {
+      const result = await sbx.runCommand({
+        cmd: "bash",
+        args: ["-c", command],
+        cwd: options?.cwd || workingDirectory,
+        signal: abortController.signal
+      });
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      const stdout = await result.stdout();
+      const stderr = await result.stderr();
+      const durationMs = Math.round(performance.now() - startTime);
+      return {
+        stdout,
+        stderr,
+        exitCode: result.exitCode,
+        durationMs,
+        interrupted
+      };
+    } catch (error) {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      const durationMs = Math.round(performance.now() - startTime);
+      if (interrupted) {
+        return {
+          stdout: "",
+          stderr: "Command timed out",
+          exitCode: 124,
+          durationMs,
+          interrupted: true
+        };
+      }
+      throw error;
+    }
+  };
+  return {
+    exec,
+    async readFile(path) {
+      const sbx = await ensureSandbox();
+      const stream = await sbx.readFile({ path });
+      if (!stream) {
+        throw new Error(`File not found: ${path}`);
+      }
+      const chunks = [];
+      for await (const chunk of stream) {
+        chunks.push(Buffer.from(chunk));
+      }
+      return Buffer.concat(chunks).toString("utf-8");
+    },
+    async writeFile(path, content) {
+      const sbx = await ensureSandbox();
+      await sbx.writeFiles([
+        {
+          path,
+          content: Buffer.from(content, "utf-8")
+        }
+      ]);
+    },
+    async readDir(path) {
+      const result = await exec(`ls -1 ${path}`);
+      if (result.exitCode !== 0) {
+        throw new Error(`Failed to read directory: ${result.stderr}`);
+      }
+      return result.stdout.split(`
+`).filter(Boolean);
+    },
+    async fileExists(path) {
+      const result = await exec(`test -e ${path}`);
+      return result.exitCode === 0;
+    },
+    async isDirectory(path) {
+      const result = await exec(`test -d ${path}`);
+      return result.exitCode === 0;
+    },
+    async destroy() {
+      if (sandbox) {
+        await sandbox.stop();
+        sandbox = null;
+      }
+    }
+  };
+}
+// src/types.ts
+var DEFAULT_CONFIG = {
+  defaultTimeout: 120000,
+  workingDirectory: "/tmp",
+  tools: {
+    Bash: { maxOutputLength: 30000 }
+  }
+};
+
+// src/tools/bash.ts
+import { tool, zodSchema } from "ai";
+import { z } from "zod";
+var bashInputSchema = z.object({
+  command: z.string().describe("The command to execute"),
+  timeout: z.number().optional().describe("Optional timeout in milliseconds (max 600000)"),
+  description: z.string().optional().describe("Clear, concise description of what this command does in 5-10 words"),
+  run_in_background: z.boolean().optional().describe("Set to true to run this command in the background")
+});
+var BASH_DESCRIPTION = `Executes bash commands in a persistent shell session with optional timeout and background execution.
+
+**Important guidelines:**
+- Always quote file paths containing spaces with double quotes (e.g., cd "/path/with spaces")
+- Avoid using search commands like \`find\` and \`grep\` - use the Glob and Grep tools instead
+- Avoid using \`cat\`, \`head\`, \`tail\` - use the Read tool instead
+- When issuing multiple commands, use \`;\` or \`&&\` to separate them (not newlines)
+- If output exceeds 30000 characters, it will be truncated
+- Default timeout is 2 minutes; maximum is 10 minutes`;
+function createBashTool(sandbox, config) {
+  const maxOutputLength = config?.maxOutputLength ?? 30000;
+  const defaultTimeout = config?.timeout ?? 120000;
+  return tool({
+    description: BASH_DESCRIPTION,
+    inputSchema: zodSchema(bashInputSchema),
+    execute: async ({
+      command,
+      timeout,
+      description: _description,
+      run_in_background: _run_in_background
+    }) => {
+      if (config?.blockedCommands) {
+        for (const blocked of config.blockedCommands) {
+          if (command.includes(blocked)) {
+            return {
+              error: `Command blocked: contains '${blocked}'`
+            };
+          }
+        }
+      }
+      try {
+        const effectiveTimeout = Math.min(timeout ?? defaultTimeout, 600000);
+        const result = await sandbox.exec(command, {
+          timeout: effectiveTimeout
+        });
+        let stdout = result.stdout;
+        let stderr = result.stderr;
+        if (stdout.length > maxOutputLength) {
+          stdout = stdout.slice(0, maxOutputLength) + `
+[output truncated, ${stdout.length - maxOutputLength} chars omitted]`;
+        }
+        if (stderr.length > maxOutputLength) {
+          stderr = stderr.slice(0, maxOutputLength) + `
+[output truncated, ${stderr.length - maxOutputLength} chars omitted]`;
+        }
+        return {
+          stdout,
+          stderr,
+          exit_code: result.exitCode,
+          interrupted: result.interrupted,
+          duration_ms: result.durationMs
+        };
+      } catch (error) {
+        return {
+          error: error instanceof Error ? error.message : "Unknown error"
+        };
+      }
+    }
+  });
+}
+
+// src/tools/edit.ts
+import { tool as tool2, zodSchema as zodSchema2 } from "ai";
+import { z as z2 } from "zod";
+var editInputSchema = z2.object({
+  file_path: z2.string().describe("The absolute path to the file to modify"),
+  old_string: z2.string().describe("The text to replace"),
+  new_string: z2.string().describe("The text to replace it with (must be different from old_string)"),
+  replace_all: z2.boolean().optional().describe("Replace all occurrences of old_string (default false)")
+});
+function createEditTool(sandbox, config) {
+  return tool2({
+    description: "Performs exact string replacements in files.",
+    inputSchema: zodSchema2(editInputSchema),
+    execute: async ({
+      file_path,
+      old_string,
+      new_string,
+      replace_all = false
+    }) => {
+      if (old_string === new_string) {
+        return { error: "old_string and new_string must be different" };
+      }
+      if (config?.allowedPaths) {
+        const isAllowed = config.allowedPaths.some((allowed) => file_path.startsWith(allowed));
+        if (!isAllowed) {
+          return { error: `Path not allowed: ${file_path}` };
+        }
+      }
+      try {
+        const exists = await sandbox.fileExists(file_path);
+        if (!exists) {
+          return { error: `File not found: ${file_path}` };
+        }
+        const content = await sandbox.readFile(file_path);
+        const occurrences = content.split(old_string).length - 1;
+        if (occurrences === 0) {
+          return { error: `String not found in file: "${old_string}"` };
+        }
+        if (!replace_all && occurrences > 1) {
+          return {
+            error: `String appears ${occurrences} times in file. Use replace_all=true to replace all, or provide a more unique string.`
+          };
+        }
+        let newContent;
+        let replacements;
+        if (replace_all) {
+          newContent = content.split(old_string).join(new_string);
+          replacements = occurrences;
+        } else {
+          newContent = content.replace(old_string, new_string);
+          replacements = 1;
+        }
+        await sandbox.writeFile(file_path, newContent);
+        return {
+          message: `Successfully edited ${file_path}`,
+          file_path,
+          replacements
+        };
+      } catch (error) {
+        return {
+          error: error instanceof Error ? error.message : "Unknown error"
+        };
+      }
+    }
+  });
+}
+
+// src/tools/glob.ts
+import { tool as tool3, zodSchema as zodSchema3 } from "ai";
+import { z as z3 } from "zod";
+var globInputSchema = z3.object({
+  pattern: z3.string().describe('Glob pattern to match files (e.g., "**/*.ts", "src/**/*.js", "*.md")'),
+  path: z3.string().optional().describe("Directory to search in (defaults to working directory)")
+});
+function createGlobTool(sandbox, config) {
+  return tool3({
+    description: "Search for files matching a glob pattern. Returns file paths sorted by modification time. Use this instead of `find` command.",
+    inputSchema: zodSchema3(globInputSchema),
+    execute: async ({
+      pattern,
+      path
+    }) => {
+      const searchPath = path || ".";
+      if (config?.allowedPaths) {
+        const isAllowed = config.allowedPaths.some((allowed) => searchPath.startsWith(allowed));
+        if (!isAllowed) {
+          return { error: `Path not allowed: ${searchPath}` };
+        }
+      }
+      try {
+        const result = await sandbox.exec(`find ${searchPath} -type f -name "${pattern}" 2>/dev/null | head -1000`, { timeout: config?.timeout });
+        if (result.exitCode !== 0 && result.stderr) {
+          return { error: result.stderr };
+        }
+        const matches = result.stdout.split(`
+`).filter(Boolean).map((p) => p.trim());
+        return {
+          matches,
+          count: matches.length,
+          search_path: searchPath
+        };
+      } catch (error) {
+        return {
+          error: error instanceof Error ? error.message : "Unknown error"
+        };
+      }
+    }
+  });
+}
+
+// src/tools/grep.ts
+import { tool as tool4, zodSchema as zodSchema4 } from "ai";
+import { z as z4 } from "zod";
+var grepInputSchema = z4.object({
+  pattern: z4.string().describe("The regular expression pattern to search for"),
+  path: z4.string().optional().describe("File or directory to search in (defaults to cwd)"),
+  glob: z4.string().optional().describe('Glob pattern to filter files (e.g. "*.js")'),
+  type: z4.string().optional().describe('File type to search (e.g. "js", "py", "rust")'),
+  output_mode: z4.enum(["content", "files_with_matches", "count"]).optional().describe('Output mode: "content", "files_with_matches", or "count"'),
+  "-i": z4.boolean().optional().describe("Case insensitive search"),
+  "-n": z4.boolean().optional().describe("Show line numbers (for content mode)"),
+  "-B": z4.number().optional().describe("Lines to show before each match"),
+  "-A": z4.number().optional().describe("Lines to show after each match"),
+  "-C": z4.number().optional().describe("Lines to show before and after each match"),
+  head_limit: z4.number().optional().describe("Limit output to first N lines/entries"),
+  multiline: z4.boolean().optional().describe("Enable multiline mode")
+});
+function createGrepTool(sandbox, config) {
+  return tool4({
+    description: "Powerful search tool built on ripgrep with regex support. Use this instead of the grep command.",
+    inputSchema: zodSchema4(grepInputSchema),
+    execute: async (input) => {
+      const {
+        pattern,
+        path,
+        glob,
+        type,
+        output_mode = "content",
+        "-i": caseInsensitive,
+        "-n": showLineNumbers = true,
+        "-B": beforeContext,
+        "-A": afterContext,
+        "-C": context,
+        head_limit,
+        multiline
+      } = input;
+      const searchPath = path || ".";
+      if (config?.allowedPaths) {
+        const isAllowed = config.allowedPaths.some((allowed) => searchPath.startsWith(allowed));
+        if (!isAllowed) {
+          return { error: `Path not allowed: ${searchPath}` };
+        }
+      }
+      try {
+        const flags = [];
+        if (caseInsensitive)
+          flags.push("-i");
+        if (showLineNumbers && output_mode === "content")
+          flags.push("-n");
+        if (multiline)
+          flags.push("-U");
+        if (context) {
+          flags.push(`-C ${context}`);
+        } else {
+          if (beforeContext)
+            flags.push(`-B ${beforeContext}`);
+          if (afterContext)
+            flags.push(`-A ${afterContext}`);
+        }
+        if (glob)
+          flags.push(`--include="${glob}"`);
+        if (type)
+          flags.push(`--include="*.${type}"`);
+        const flagStr = flags.join(" ");
+        const limit = head_limit || 1000;
+        let cmd;
+        if (output_mode === "files_with_matches") {
+          cmd = `grep -rl ${flagStr} "${pattern}" ${searchPath} 2>/dev/null | head -${limit}`;
+          const result = await sandbox.exec(cmd, { timeout: config?.timeout });
+          const files = result.stdout.split(`
+`).filter(Boolean);
+          return {
+            files,
+            count: files.length
+          };
+        } else if (output_mode === "count") {
+          cmd = `grep -rc ${flagStr} "${pattern}" ${searchPath} 2>/dev/null | grep -v ':0$' | head -${limit}`;
+          const result = await sandbox.exec(cmd, { timeout: config?.timeout });
+          const lines = result.stdout.split(`
+`).filter(Boolean);
+          const counts = lines.map((line) => {
+            const lastColon = line.lastIndexOf(":");
+            return {
+              file: line.slice(0, lastColon),
+              count: parseInt(line.slice(lastColon + 1), 10)
+            };
+          });
+          const total = counts.reduce((sum, c) => sum + c.count, 0);
+          return {
+            counts,
+            total
+          };
+        } else {
+          cmd = `grep -rn ${flagStr} "${pattern}" ${searchPath} 2>/dev/null | head -${limit}`;
+          const result = await sandbox.exec(cmd, { timeout: config?.timeout });
+          if (!result.stdout.trim()) {
+            return {
+              matches: [],
+              total_matches: 0
+            };
+          }
+          const lines = result.stdout.split(`
+`).filter(Boolean);
+          const matches = [];
+          for (const line of lines) {
+            const colonMatch = line.match(/^(.+?):(\d+)[:|-](.*)$/);
+            if (colonMatch) {
+              const [, file, lineNum, content] = colonMatch;
+              matches.push({
+                file,
+                line_number: parseInt(lineNum, 10),
+                line: content
+              });
+            }
+          }
+          return {
+            matches,
+            total_matches: matches.length
+          };
+        }
+      } catch (error) {
+        return {
+          error: error instanceof Error ? error.message : "Unknown error"
+        };
+      }
+    }
+  });
+}
+
+// src/tools/read.ts
+import { tool as tool5, zodSchema as zodSchema5 } from "ai";
+import { z as z5 } from "zod";
+var readInputSchema = z5.object({
+  file_path: z5.string().describe("Absolute path to file or directory"),
+  offset: z5.number().optional().describe("Line number to start reading from (1-indexed)"),
+  limit: z5.number().optional().describe("Maximum number of lines to read")
+});
+function createReadTool(sandbox, config) {
+  return tool5({
+    description: "Read the contents of a file or list directory entries. For text files, returns numbered lines with total line count. For directories, returns file/folder names. Use this instead of `cat`, `head`, or `tail` commands.",
+    inputSchema: zodSchema5(readInputSchema),
+    execute: async ({
+      file_path,
+      offset,
+      limit
+    }) => {
+      if (config?.allowedPaths) {
+        const isAllowed = config.allowedPaths.some((allowed) => file_path.startsWith(allowed));
+        if (!isAllowed) {
+          return { error: `Path not allowed: ${file_path}` };
+        }
+      }
+      try {
+        const exists = await sandbox.fileExists(file_path);
+        if (!exists) {
+          return { error: `Path not found: ${file_path}` };
+        }
+        const isDir = await sandbox.isDirectory(file_path);
+        if (isDir) {
+          const entries = await sandbox.readDir(file_path);
+          return {
+            type: "directory",
+            entries,
+            count: entries.length
+          };
+        }
+        const content = await sandbox.readFile(file_path);
+        const nullByteIndex = content.indexOf("\x00");
+        if (nullByteIndex !== -1 && nullByteIndex < 1000) {
+          const ext = file_path.split(".").pop()?.toLowerCase();
+          const binaryExtensions = [
+            "pdf",
+            "png",
+            "jpg",
+            "jpeg",
+            "gif",
+            "zip",
+            "tar",
+            "gz",
+            "exe",
+            "bin",
+            "so",
+            "dylib"
+          ];
+          if (binaryExtensions.includes(ext || "")) {
+            return {
+              error: `Cannot read binary file: ${file_path} (file exists, ${content.length} bytes). Use appropriate tools to process ${ext?.toUpperCase()} files (e.g., Python scripts for PDFs).`
+            };
+          }
+        }
+        const allLines = content.split(`
+`);
+        const totalLines = allLines.length;
+        const maxLinesWithoutLimit = config?.maxFileSize || 500;
+        if (!limit && totalLines > maxLinesWithoutLimit) {
+          return {
+            error: `File is large (${totalLines} lines). Use 'offset' and 'limit' to read in chunks. Example: offset=1, limit=100 for first 100 lines.`
+          };
+        }
+        const startLine = offset ? offset - 1 : 0;
+        const endLine = limit ? startLine + limit : allLines.length;
+        const selectedLines = allLines.slice(startLine, endLine);
+        const lines = selectedLines.map((line, i) => ({
+          line_number: startLine + i + 1,
+          content: line
+        }));
+        return {
+          type: "text",
+          content: selectedLines.join(`
+`),
+          lines,
+          total_lines: totalLines
+        };
+      } catch (error) {
+        return {
+          error: error instanceof Error ? error.message : "Unknown error"
+        };
+      }
+    }
+  });
+}
+
+// src/tools/web-fetch.ts
+import { generateText, tool as tool6, zodSchema as zodSchema6 } from "ai";
+import Parallel from "parallel-web";
+import { z as z6 } from "zod";
+var webFetchInputSchema = z6.object({
+  url: z6.string().describe("The URL to fetch content from"),
+  prompt: z6.string().describe("The prompt to run on the fetched content")
+});
+var RETRYABLE_CODES = [408, 429, 500, 502, 503];
+function createWebFetchTool(config) {
+  const { apiKey, model } = config;
+  return tool6({
+    description: "Fetches content from a URL and processes it with an AI model. Use this to analyze web pages, extract information, or summarize content.",
+    inputSchema: zodSchema6(webFetchInputSchema),
+    execute: async (input) => {
+      const { url, prompt } = input;
+      try {
+        const client = new Parallel({ apiKey });
+        const extract = await client.beta.extract({
+          urls: [url],
+          excerpts: true,
+          full_content: true
+        });
+        if (!extract.results || extract.results.length === 0) {
+          return {
+            error: "No content extracted from URL",
+            status_code: 404,
+            retryable: false
+          };
+        }
+        const extractedResult = extract.results[0];
+        const content = extractedResult.full_content || extractedResult.excerpts?.join(`
+
+`) || "";
+        if (!content) {
+          return {
+            error: "No content available from URL",
+            status_code: 404,
+            retryable: false
+          };
+        }
+        const result = await generateText({
+          model,
+          prompt: `${prompt}
+
+Content from ${url}:
+
+${content}`
+        });
+        return {
+          response: result.text,
+          url,
+          final_url: extractedResult.url || url
+        };
+      } catch (error) {
+        if (error && typeof error === "object" && "status" in error) {
+          const statusCode = error.status;
+          const message = error.message || "API request failed";
+          return {
+            error: message,
+            status_code: statusCode,
+            retryable: RETRYABLE_CODES.includes(statusCode)
+          };
+        }
+        return {
+          error: error instanceof Error ? error.message : "Unknown error"
+        };
+      }
+    }
+  });
+}
+
+// src/tools/web-search.ts
+import { tool as tool7, zodSchema as zodSchema7 } from "ai";
+import Parallel2 from "parallel-web";
+import { z as z7 } from "zod";
+var webSearchInputSchema = z7.object({
+  query: z7.string().describe("The search query to use"),
+  allowed_domains: z7.array(z7.string()).optional().describe("Only include results from these domains"),
+  blocked_domains: z7.array(z7.string()).optional().describe("Never include results from these domains")
+});
+var RETRYABLE_CODES2 = [408, 429, 500, 502, 503];
+function createWebSearchTool(config) {
+  const { apiKey } = config;
+  return tool7({
+    description: "Searches the web and returns formatted results. Use this to find current information, documentation, articles, and more.",
+    inputSchema: zodSchema7(webSearchInputSchema),
+    execute: async (input) => {
+      const { query, allowed_domains, blocked_domains } = input;
+      try {
+        const client = new Parallel2({ apiKey });
+        const sourcePolicy = allowed_domains || blocked_domains ? {
+          ...allowed_domains && { include_domains: allowed_domains },
+          ...blocked_domains && { exclude_domains: blocked_domains }
+        } : undefined;
+        const search = await client.beta.search({
+          mode: "agentic",
+          objective: query,
+          max_results: 10,
+          ...sourcePolicy && { source_policy: sourcePolicy }
+        });
+        const results = (search.results || []).map((result) => ({
+          title: result.title ?? "",
+          url: result.url ?? "",
+          snippet: result.excerpts?.join(`
+`) ?? "",
+          metadata: result.publish_date ? { publish_date: result.publish_date } : undefined
+        }));
+        return {
+          results,
+          total_results: results.length,
+          query
+        };
+      } catch (error) {
+        if (error && typeof error === "object" && "status" in error) {
+          const statusCode = error.status;
+          const message = error.message || "API request failed";
+          return {
+            error: message,
+            status_code: statusCode,
+            retryable: RETRYABLE_CODES2.includes(statusCode)
+          };
+        }
+        return {
+          error: error instanceof Error ? error.message : "Unknown error"
+        };
+      }
+    }
+  });
+}
+
+// src/tools/write.ts
+import { tool as tool8, zodSchema as zodSchema8 } from "ai";
+import { z as z8 } from "zod";
+var writeInputSchema = z8.object({
+  file_path: z8.string().describe("Path to the file to write"),
+  content: z8.string().describe("Content to write to the file")
+});
+function createWriteTool(sandbox, config) {
+  return tool8({
+    description: "Write content to a file. Creates the file if it does not exist, overwrites if it does.",
+    inputSchema: zodSchema8(writeInputSchema),
+    execute: async ({
+      file_path,
+      content
+    }) => {
+      const byteLength = Buffer.byteLength(content, "utf-8");
+      if (config?.maxFileSize && byteLength > config.maxFileSize) {
+        return {
+          error: `File content exceeds maximum size of ${config.maxFileSize} bytes (got ${byteLength})`
+        };
+      }
+      if (config?.allowedPaths) {
+        const isAllowed = config.allowedPaths.some((allowed) => file_path.startsWith(allowed));
+        if (!isAllowed) {
+          return { error: `Path not allowed: ${file_path}` };
+        }
+      }
+      try {
+        await sandbox.writeFile(file_path, content);
+        return {
+          message: `Successfully wrote to ${file_path}`,
+          bytes_written: byteLength,
+          file_path
+        };
+      } catch (error) {
+        return {
+          error: error instanceof Error ? error.message : "Unknown error"
+        };
+      }
+    }
+  });
+}
+// src/tools/exit-plan-mode.ts
+import { tool as tool9, zodSchema as zodSchema9 } from "ai";
+import { z as z9 } from "zod";
+var exitPlanModeInputSchema = z9.object({
+  plan: z9.string().describe("The plan to present to the user for approval")
+});
+function createExitPlanModeTool(config, onPlanSubmit) {
+  return tool9({
+    description: "Exits planning mode and prompts the user to approve the plan. Use this when you have finished planning and want user confirmation before proceeding.",
+    inputSchema: zodSchema9(exitPlanModeInputSchema),
+    execute: async ({
+      plan
+    }) => {
+      try {
+        let approved;
+        if (onPlanSubmit) {
+          approved = await onPlanSubmit(plan);
+        }
+        return {
+          message: approved ? "Plan approved, proceeding with execution" : "Plan submitted for review",
+          approved
+        };
+      } catch (error) {
+        return {
+          error: error instanceof Error ? error.message : "Unknown error"
+        };
+      }
+    }
+  });
+}
+// src/tools/task.ts
+import {
+  generateText as generateText2,
+  stepCountIs,
+  tool as tool10,
+  zodSchema as zodSchema10
+} from "ai";
+import { z as z10 } from "zod";
+var taskInputSchema = z10.object({
+  description: z10.string().describe("A short (3-5 word) description of the task"),
+  prompt: z10.string().describe("The task for the agent to perform"),
+  subagent_type: z10.string().describe("The type of specialized agent to use for this task")
+});
+function filterTools(allTools, allowedTools) {
+  if (!allowedTools)
+    return allTools;
+  const filtered = {};
+  for (const name of allowedTools) {
+    if (allTools[name]) {
+      filtered[name] = allTools[name];
+    }
+  }
+  return filtered;
+}
+function createTaskTool(config) {
+  const {
+    model: defaultModel,
+    tools: allTools,
+    subagentTypes = {},
+    costPerInputToken = 0.000003,
+    costPerOutputToken = 0.000015,
+    defaultStopWhen,
+    defaultOnStepFinish
+  } = config;
+  return tool10({
+    description: "Launches a new agent to handle complex, multi-step tasks autonomously. Use this for tasks that require multiple steps, research, or specialized expertise.",
+    inputSchema: zodSchema10(taskInputSchema),
+    execute: async ({
+      description,
+      prompt,
+      subagent_type
+    }) => {
+      const startTime = performance.now();
+      try {
+        const typeConfig = subagentTypes[subagent_type] || {};
+        const model = typeConfig.model || defaultModel;
+        const tools = filterTools(allTools, typeConfig.tools);
+        const systemPrompt = typeConfig.systemPrompt;
+        const result = await generateText2({
+          model,
+          tools,
+          system: systemPrompt,
+          prompt,
+          stopWhen: typeConfig.stopWhen ?? defaultStopWhen ?? stepCountIs(15),
+          prepareStep: typeConfig.prepareStep,
+          onStepFinish: async (step) => {
+            await typeConfig.onStepFinish?.(step);
+            await defaultOnStepFinish?.({
+              subagentType: subagent_type,
+              description,
+              step
+            });
+          }
+        });
+        const durationMs = Math.round(performance.now() - startTime);
+        const usage = result.usage.inputTokens !== undefined && result.usage.outputTokens !== undefined ? {
+          input_tokens: result.usage.inputTokens,
+          output_tokens: result.usage.outputTokens
+        } : undefined;
+        let totalCostUsd;
+        if (usage) {
+          totalCostUsd = usage.input_tokens * costPerInputToken + usage.output_tokens * costPerOutputToken;
+        }
+        return {
+          result: result.text,
+          usage,
+          total_cost_usd: totalCostUsd,
+          duration_ms: durationMs
+        };
+      } catch (error) {
+        return {
+          error: error instanceof Error ? error.message : "Unknown error"
+        };
+      }
+    }
+  });
+}
+// src/tools/todo-write.ts
+import { tool as tool11, zodSchema as zodSchema11 } from "ai";
+import { z as z11 } from "zod";
+var todoWriteInputSchema = z11.object({
+  todos: z11.array(z11.object({
+    content: z11.string().describe("The task description"),
+    status: z11.enum(["pending", "in_progress", "completed"]).describe("The task status"),
+    activeForm: z11.string().describe("Active form of the task description")
+  })).describe("The updated todo list")
+});
+function createTodoWriteTool(state, config, onUpdate) {
+  return tool11({
+    description: "Creates and manages a structured task list for tracking progress. Use this to plan complex tasks and track completion.",
+    inputSchema: zodSchema11(todoWriteInputSchema),
+    execute: async ({
+      todos
+    }) => {
+      try {
+        state.todos = todos;
+        if (onUpdate) {
+          onUpdate(todos);
+        }
+        const stats = {
+          total: todos.length,
+          pending: todos.filter((t) => t.status === "pending").length,
+          in_progress: todos.filter((t) => t.status === "in_progress").length,
+          completed: todos.filter((t) => t.status === "completed").length
+        };
+        return {
+          message: "Todo list updated successfully",
+          stats
+        };
+      } catch (error) {
+        return {
+          error: error instanceof Error ? error.message : "Unknown error"
+        };
+      }
+    }
+  });
+}
+
+// src/tools/index.ts
+function createAgentTools(sandbox, config) {
+  const toolsConfig = {
+    ...DEFAULT_CONFIG.tools,
+    ...config?.tools
+  };
+  const tools = {
+    Bash: createBashTool(sandbox, toolsConfig.Bash),
+    Read: createReadTool(sandbox, toolsConfig.Read),
+    Write: createWriteTool(sandbox, toolsConfig.Write),
+    Edit: createEditTool(sandbox, toolsConfig.Edit),
+    Glob: createGlobTool(sandbox, toolsConfig.Glob),
+    Grep: createGrepTool(sandbox, toolsConfig.Grep)
+  };
+  if (config?.webSearch) {
+    tools.WebSearch = createWebSearchTool(config.webSearch);
+  }
+  if (config?.webFetch) {
+    tools.WebFetch = createWebFetchTool(config.webFetch);
+  }
+  return tools;
+}
+// src/utils/compact-conversation.ts
+import { generateText as generateText3 } from "ai";
+
+// src/utils/prune-messages.ts
+var DEFAULT_CONFIG2 = {
+  targetTokens: 40000,
+  minSavingsThreshold: 20000,
+  protectLastNUserMessages: 3
+};
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function estimateMessageTokens(message) {
+  let tokens = 0;
+  if (typeof message.content === "string") {
+    tokens += estimateTokens(message.content);
+  } else if (Array.isArray(message.content)) {
+    for (const part of message.content) {
+      if (typeof part === "string") {
+        tokens += estimateTokens(part);
+      } else if ("text" in part && typeof part.text === "string") {
+        tokens += estimateTokens(part.text);
+      } else if ("result" in part) {
+        tokens += estimateTokens(JSON.stringify(part.result));
+      } else if ("args" in part) {
+        tokens += estimateTokens(JSON.stringify(part.args));
+      } else {
+        tokens += estimateTokens(JSON.stringify(part));
+      }
+    }
+  }
+  tokens += 4;
+  return tokens;
+}
+function estimateMessagesTokens(messages) {
+  return messages.reduce((sum, msg) => sum + estimateMessageTokens(msg), 0);
+}
+function findLastNUserMessageIndices(messages, n) {
+  const indices = new Set;
+  let count = 0;
+  for (let i = messages.length - 1;i >= 0 && count < n; i--) {
+    if (messages[i].role === "user") {
+      indices.add(i);
+      count++;
+    }
+  }
+  return indices;
+}
+function findProtectedIndices(messages, protectLastN) {
+  const userIndices = findLastNUserMessageIndices(messages, protectLastN);
+  const protected_ = new Set;
+  if (userIndices.size === 0)
+    return protected_;
+  const earliestProtected = Math.min(...userIndices);
+  for (let i = earliestProtected;i < messages.length; i++) {
+    protected_.add(i);
+  }
+  return protected_;
+}
+function pruneMessageContent(message) {
+  if (message.role !== "assistant" || typeof message.content === "string") {
+    return message;
+  }
+  if (!Array.isArray(message.content)) {
+    return message;
+  }
+  const prunedContent = message.content.map((part) => {
+    if (typeof part === "object" && "toolName" in part && "args" in part) {
+      return {
+        ...part,
+        args: { _pruned: true, toolName: part.toolName }
+      };
+    }
+    return part;
+  });
+  return { ...message, content: prunedContent };
+}
+function pruneToolMessage(message) {
+  if (message.role !== "tool") {
+    return message;
+  }
+  if (!Array.isArray(message.content)) {
+    return message;
+  }
+  const prunedContent = message.content.map((part) => {
+    if (typeof part === "object" && "result" in part) {
+      return {
+        ...part,
+        result: { _pruned: true }
+      };
+    }
+    return part;
+  });
+  return { ...message, content: prunedContent };
+}
+function pruneMessagesByTokens(messages, config) {
+  const { targetTokens, minSavingsThreshold, protectLastNUserMessages } = {
+    ...DEFAULT_CONFIG2,
+    ...config
+  };
+  const totalTokens = estimateMessagesTokens(messages);
+  const potentialSavings = totalTokens - targetTokens;
+  if (potentialSavings <= minSavingsThreshold) {
+    return messages;
+  }
+  const protectedIndices = findProtectedIndices(messages, protectLastNUserMessages);
+  const prunedMessages = [];
+  let currentTokens = 0;
+  let savedTokens = 0;
+  for (let i = 0;i < messages.length; i++) {
+    const message = messages[i];
+    const isProtected = protectedIndices.has(i);
+    if (isProtected) {
+      prunedMessages.push(message);
+      currentTokens += estimateMessageTokens(message);
+    } else {
+      const originalTokens = estimateMessageTokens(message);
+      if (currentTokens + originalTokens > targetTokens) {
+        let prunedMessage = message;
+        if (message.role === "assistant") {
+          prunedMessage = pruneMessageContent(message);
+        } else if (message.role === "tool") {
+          prunedMessage = pruneToolMessage(message);
+        }
+        const prunedTokens = estimateMessageTokens(prunedMessage);
+        savedTokens += originalTokens - prunedTokens;
+        prunedMessages.push(prunedMessage);
+        currentTokens += prunedTokens;
+      } else {
+        prunedMessages.push(message);
+        currentTokens += originalTokens;
+      }
+    }
+  }
+  return prunedMessages;
+}
+
+// src/utils/compact-conversation.ts
+async function compactConversation(messages, config, state = { conversationSummary: "" }) {
+  const currentTokens = estimateMessagesTokens(messages);
+  const threshold = config.compactionThreshold ?? 0.85;
+  const limit = config.maxTokens * threshold;
+  if (currentTokens < limit) {
+    return { messages, state, didCompact: false };
+  }
+  const protectCount = config.protectRecentMessages ?? 10;
+  const recentMessages = messages.slice(-protectCount);
+  const oldMessages = messages.slice(0, -protectCount);
+  if (oldMessages.length === 0) {
+    return { messages, state, didCompact: false };
+  }
+  const newSummary = await summarizeMessages(oldMessages, config.summarizerModel, config.taskContext, state.conversationSummary);
+  const compactedMessages = [
+    {
+      role: "user",
+      content: `[Previous conversation summary]
+
+${newSummary}
+
+[Continuing from recent messages below...]`
+    },
+    {
+      role: "assistant",
+      content: "I understand the context from the previous conversation. Continuing from where we left off."
+    },
+    ...recentMessages
+  ];
+  return {
+    messages: compactedMessages,
+    state: { conversationSummary: newSummary },
+    didCompact: true
+  };
+}
+var SUMMARIZATION_PROMPT = `<context>
+You are a conversation summarizer for an AI coding agent. The agent has been working on a task and the conversation has grown too long to fit in context. Your job is to create a comprehensive summary that allows the conversation to continue seamlessly.
+</context>
+
+<task>
+Create a structured summary of the conversation below. This summary will replace the old messages, so it MUST preserve all information needed to continue the work.
+</task>
+
+<original-goal>
+{{TASK_CONTEXT}}
+</original-goal>
+
+<previous-summary>
+{{PREVIOUS_SUMMARY}}
+</previous-summary>
+
+<conversation-to-summarize>
+{{CONVERSATION}}
+</conversation-to-summarize>
+
+<output-format>
+Structure your summary with these sections:
+
+## Task Overview
+Brief description of what the user asked for and the current goal.
+
+## Progress Made
+- What has been accomplished so far
+- Key milestones reached
+
+## Files & Code
+- Files created: list with paths
+- Files modified: list with paths and what changed
+- Files read/analyzed: list with paths
+- Key code patterns or architecture decisions
+
+## Technical Decisions
+- Important choices made and why
+- Configurations or settings established
+- Dependencies or tools being used
+
+## Errors & Resolutions
+- Problems encountered
+- How they were solved (or if still unresolved)
+
+## Current State
+- Where the work left off
+- What was being worked on when summarized
+- Any pending questions or blockers
+
+## Key Context
+- Important facts, names, or values that must not be forgotten
+- User preferences or requirements mentioned
+</output-format>
+
+<instructions>
+- Be thorough. Missing information cannot be recovered.
+- Preserve exact file paths, variable names, and code snippets where relevant.
+- If tool calls were made, note what tools were used and their outcomes.
+- Maintain the user's original terminology and naming.
+- Do not editorialize or add suggestions - just capture what happened.
+- Omit sections that have no relevant information.
+</instructions>`;
+async function summarizeMessages(messages, model, taskContext, previousSummary) {
+  const prompt = SUMMARIZATION_PROMPT.replace("{{TASK_CONTEXT}}", taskContext || "Not specified").replace("{{PREVIOUS_SUMMARY}}", previousSummary || "None - this is the first compaction").replace("{{CONVERSATION}}", formatMessagesForSummary(messages));
+  const result = await generateText3({
+    model,
+    messages: [
+      {
+        role: "user",
+        content: prompt
+      }
+    ]
+  });
+  return result.text;
+}
+function formatMessagesForSummary(messages) {
+  return messages.map((msg, index) => {
+    const role = msg.role.toUpperCase();
+    if (typeof msg.content === "string") {
+      return `<message index="${index}" role="${role}">
+${msg.content}
+</message>`;
+    }
+    if (Array.isArray(msg.content)) {
+      const parts = msg.content.map((part) => {
+        if (typeof part === "string") {
+          return part;
+        }
+        if ("text" in part && typeof part.text === "string") {
+          return part.text;
+        }
+        if ("toolName" in part && "args" in part) {
+          return `[Tool Call: ${part.toolName}]
+Args: ${JSON.stringify(part.args, null, 2)}`;
+        }
+        if ("result" in part) {
+          const resultStr = typeof part.result === "string" ? part.result : JSON.stringify(part.result, null, 2);
+          return `[Tool Result]
+${resultStr}`;
+        }
+        return JSON.stringify(part, null, 2);
+      }).join(`
+
+`);
+      return `<message index="${index}" role="${role}">
+${parts}
+</message>`;
+    }
+    return `<message index="${index}" role="${role}">
+${JSON.stringify(msg.content, null, 2)}
+</message>`;
+  }).join(`
+
+`);
+}
+var MODEL_CONTEXT_LIMITS = {
+  "claude-opus-4-5": 200000,
+  "claude-sonnet-4-5": 200000,
+  "claude-haiku-4": 200000,
+  "gpt-4o": 128000,
+  "gpt-4-turbo": 128000,
+  "gpt-4": 8192,
+  "gpt-3.5-turbo": 16385,
+  "gemini-2.5-pro": 1e6,
+  "gemini-2.5-flash": 1e6
+};
+function createCompactConfig(modelId, summarizerModel, overrides) {
+  const maxTokens = MODEL_CONTEXT_LIMITS[modelId];
+  return {
+    maxTokens,
+    summarizerModel,
+    ...overrides
+  };
+}
+// src/utils/context-status.ts
+var DEFAULT_CONFIG3 = {
+  elevatedThreshold: 0.5,
+  highThreshold: 0.7,
+  criticalThreshold: 0.85
+};
+function defaultHighGuidance(metrics) {
+  const used = Math.round(metrics.usagePercent * 100);
+  const remaining = Math.round((1 - metrics.usagePercent) * 100);
+  return `Context usage: ${used}%. You still have ${remaining}% remaining—no need to rush. Continue working thoroughly.`;
+}
+function defaultCriticalGuidance(metrics) {
+  const used = Math.round(metrics.usagePercent * 100);
+  return `Context usage: ${used}%. Consider wrapping up the current task or summarizing progress before continuing.`;
+}
+function getContextStatus(messages, maxTokens, config) {
+  const { elevatedThreshold, highThreshold, criticalThreshold } = {
+    ...DEFAULT_CONFIG3,
+    ...config
+  };
+  const usedTokens = estimateMessagesTokens(messages);
+  const usagePercent = usedTokens / maxTokens;
+  const baseStatus = { usedTokens, maxTokens, usagePercent };
+  if (usagePercent < elevatedThreshold) {
+    return { ...baseStatus, status: "comfortable" };
+  }
+  if (usagePercent < highThreshold) {
+    return { ...baseStatus, status: "elevated" };
+  }
+  if (usagePercent < criticalThreshold) {
+    const guidance2 = typeof config?.highGuidance === "function" ? config.highGuidance(baseStatus) : config?.highGuidance ?? defaultHighGuidance(baseStatus);
+    return { ...baseStatus, status: "high", guidance: guidance2 };
+  }
+  const guidance = typeof config?.criticalGuidance === "function" ? config.criticalGuidance(baseStatus) : config?.criticalGuidance ?? defaultCriticalGuidance(baseStatus);
+  return { ...baseStatus, status: "critical", guidance };
+}
+function contextNeedsAttention(status) {
+  return status.status === "high" || status.status === "critical";
+}
+function contextNeedsCompaction(status) {
+  return status.status === "critical";
+}
+// src/skills/discovery.ts
+import { readdir, readFile, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+
+// src/skills/loader.ts
+function parseSkillMetadata(content, skillPath) {
+  const frontmatter = extractFrontmatter(content);
+  if (!frontmatter) {
+    throw new Error(`No YAML frontmatter found in ${skillPath}`);
+  }
+  const parsed = parseYaml(frontmatter);
+  if (!parsed.name || typeof parsed.name !== "string") {
+    throw new Error(`Missing or invalid 'name' field in ${skillPath}`);
+  }
+  if (!parsed.description || typeof parsed.description !== "string") {
+    throw new Error(`Missing or invalid 'description' field in ${skillPath}`);
+  }
+  const nameRegex = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/;
+  if (parsed.name.length > 64 || parsed.name.length > 1 && !nameRegex.test(parsed.name) || parsed.name.includes("--")) {
+    throw new Error(`Invalid 'name' format in ${skillPath}: must be 1-64 lowercase chars/hyphens, no start/end/consecutive hyphens`);
+  }
+  let allowedTools;
+  if (parsed["allowed-tools"]) {
+    const toolsStr = String(parsed["allowed-tools"]);
+    allowedTools = toolsStr.split(/\s+/).filter(Boolean);
+  }
+  let metadata;
+  if (parsed.metadata && typeof parsed.metadata === "object") {
+    metadata = {};
+    for (const [key, value] of Object.entries(parsed.metadata)) {
+      metadata[key] = String(value);
+    }
+  }
+  return {
+    name: parsed.name,
+    description: parsed.description,
+    path: skillPath,
+    license: parsed.license ? String(parsed.license) : undefined,
+    compatibility: parsed.compatibility ? String(parsed.compatibility) : undefined,
+    metadata,
+    allowedTools
+  };
+}
+function extractFrontmatter(content) {
+  const trimmed = content.trimStart();
+  if (!trimmed.startsWith("---")) {
+    return null;
+  }
+  const endIndex = trimmed.indexOf(`
+---`, 3);
+  if (endIndex === -1) {
+    return null;
+  }
+  return trimmed.slice(3, endIndex).trim();
+}
+function parseYaml(yaml) {
+  const result = {};
+  const lines = yaml.split(`
+`);
+  let currentKey = null;
+  let currentObject = null;
+  for (const line of lines) {
+    if (!line.trim() || line.trim().startsWith("#")) {
+      continue;
+    }
+    const nestedMatch = line.match(/^(\s{2,})(\w+):\s*(.*)$/);
+    if (nestedMatch && currentKey && currentObject) {
+      const [, , key, value] = nestedMatch;
+      currentObject[key] = value.trim().replace(/^["']|["']$/g, "");
+      continue;
+    }
+    const topMatch = line.match(/^(\w[\w-]*):\s*(.*)$/);
+    if (topMatch) {
+      if (currentKey && currentObject) {
+        result[currentKey] = currentObject;
+        currentObject = null;
+      }
+      const [, key, value] = topMatch;
+      const trimmedValue = value.trim();
+      if (trimmedValue === "" || trimmedValue === "|" || trimmedValue === ">") {
+        currentKey = key;
+        currentObject = {};
+      } else {
+        result[key] = trimmedValue.replace(/^["']|["']$/g, "");
+        currentKey = null;
+      }
+    }
+  }
+  if (currentKey && currentObject && Object.keys(currentObject).length > 0) {
+    result[currentKey] = currentObject;
+  }
+  return result;
+}
+
+// src/skills/discovery.ts
+var DEFAULT_SKILL_PATHS = [".skills", "~/.bashkit/skills"];
+async function discoverSkills(options) {
+  const cwd = options?.cwd ?? process.cwd();
+  const searchPaths = options?.paths ?? DEFAULT_SKILL_PATHS;
+  const skills = [];
+  const seenNames = new Set;
+  for (const searchPath of searchPaths) {
+    const resolvedPath = resolvePath(searchPath, cwd);
+    const foundSkills = await scanDirectory(resolvedPath);
+    for (const skill of foundSkills) {
+      if (!seenNames.has(skill.name)) {
+        seenNames.add(skill.name);
+        skills.push(skill);
+      }
+    }
+  }
+  return skills;
+}
+function resolvePath(path, cwd) {
+  if (path.startsWith("~/")) {
+    return join(homedir(), path.slice(2));
+  }
+  if (path.startsWith("/")) {
+    return path;
+  }
+  return resolve(cwd, path);
+}
+async function scanDirectory(dirPath) {
+  const skills = [];
+  try {
+    const entries = await readdir(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) {
+        continue;
+      }
+      const skillPath = join(dirPath, entry.name, "SKILL.md");
+      try {
+        const skillStat = await stat(skillPath);
+        if (!skillStat.isFile()) {
+          continue;
+        }
+        const content = await readFile(skillPath, "utf-8");
+        const metadata = parseSkillMetadata(content, skillPath);
+        if (metadata.name !== entry.name) {
+          console.warn(`Skill name "${metadata.name}" does not match folder name "${entry.name}" in ${skillPath}`);
+        }
+        skills.push(metadata);
+      } catch {}
+    }
+  } catch {
+    return [];
+  }
+  return skills;
+}
+// src/skills/fetch.ts
+function parseGitHubRef(ref) {
+  const parts = ref.split("/");
+  if (parts.length < 3) {
+    throw new Error(`Invalid skill reference "${ref}". Expected format: owner/repo/skillName (e.g., anthropics/skills/pdf)`);
+  }
+  const owner = parts[0];
+  const repo = parts[1];
+  const skillName = parts[parts.length - 1];
+  return { owner, repo, skillName };
+}
+async function fetchDirectoryContents(owner, repo, path, basePath, branch = "main") {
+  const apiUrl = `https://api.github.com/repos/${owner}/${repo}/contents/${path}?ref=${branch}`;
+  const response = await fetch(apiUrl, {
+    headers: {
+      Accept: "application/vnd.github.v3+json",
+      "User-Agent": "bashkit"
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch directory contents from "${path}": ${response.status} ${response.statusText}`);
+  }
+  const items = await response.json();
+  const files = {};
+  await Promise.all(items.map(async (item) => {
+    if (item.type === "file" && item.download_url) {
+      const fileResponse = await fetch(item.download_url);
+      if (fileResponse.ok) {
+        const relativePath = item.path.slice(basePath.length + 1);
+        files[relativePath] = await fileResponse.text();
+      }
+    } else if (item.type === "dir") {
+      const subFiles = await fetchDirectoryContents(owner, repo, item.path, basePath, branch);
+      for (const [subPath, content] of Object.entries(subFiles)) {
+        files[subPath] = content;
+      }
+    }
+  }));
+  return files;
+}
+async function fetchSkill(ref) {
+  const { owner, repo, skillName } = parseGitHubRef(ref);
+  const skillPath = `skills/${skillName}`;
+  const files = await fetchDirectoryContents(owner, repo, skillPath, skillPath);
+  if (!files["SKILL.md"]) {
+    throw new Error(`Skill "${ref}" does not contain a SKILL.md file. Found files: ${Object.keys(files).join(", ")}`);
+  }
+  return {
+    name: skillName,
+    files
+  };
+}
+async function fetchSkills(refs) {
+  const results = await Promise.all(refs.map(async (ref) => {
+    const bundle = await fetchSkill(ref);
+    return { name: bundle.name, bundle };
+  }));
+  return Object.fromEntries(results.map(({ name, bundle }) => [name, bundle]));
+}
+// src/skills/xml.ts
+function skillsToXml(skills) {
+  if (skills.length === 0) {
+    return `<available_skills>
+</available_skills>`;
+  }
+  const skillElements = skills.map((skill) => {
+    const name = escapeXml(skill.name);
+    const description = escapeXml(skill.description);
+    const location = escapeXml(skill.path);
+    return `  <skill>
+    <name>${name}</name>
+    <description>${description}</description>
+    <location>${location}</location>
+  </skill>`;
+  }).join(`
+`);
+  return `<available_skills>
+${skillElements}
+</available_skills>`;
+}
+function escapeXml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+// src/setup/setup-environment.ts
+function isSkillBundle(content) {
+  return typeof content === "object" && "files" in content;
+}
+async function setupAgentEnvironment(sandbox, config) {
+  const skills = [];
+  if (config.workspace) {
+    for (const path of Object.values(config.workspace)) {
+      await createDirectory(sandbox, path);
+    }
+  }
+  if (config.skills) {
+    await createDirectory(sandbox, ".skills");
+    for (const [name, content] of Object.entries(config.skills)) {
+      const skillDir = `.skills/${name}`;
+      if (isSkillBundle(content)) {
+        await seedSkillBundle(sandbox, skillDir, content);
+        const skillMdContent = content.files["SKILL.md"];
+        if (skillMdContent) {
+          try {
+            const metadata = parseSkillMetadata(skillMdContent, `${skillDir}/SKILL.md`);
+            skills.push(metadata);
+          } catch {
+            skills.push({
+              name,
+              description: `Skill: ${name}`,
+              path: `${skillDir}/SKILL.md`
+            });
+          }
+        }
+      } else {
+        const skillPath = `${skillDir}/SKILL.md`;
+        await createDirectory(sandbox, skillDir);
+        await sandbox.writeFile(skillPath, content);
+        try {
+          const metadata = parseSkillMetadata(content, skillPath);
+          skills.push(metadata);
+        } catch {
+          skills.push({
+            name,
+            description: `Skill: ${name}`,
+            path: skillPath
+          });
+        }
+      }
+    }
+  }
+  return { skills };
+}
+async function seedSkillBundle(sandbox, skillDir, bundle) {
+  await createDirectory(sandbox, skillDir);
+  for (const [relativePath, content] of Object.entries(bundle.files)) {
+    const fullPath = `${skillDir}/${relativePath}`;
+    const parentDir = fullPath.substring(0, fullPath.lastIndexOf("/"));
+    if (parentDir && parentDir !== skillDir) {
+      await createDirectory(sandbox, parentDir);
+    }
+    await sandbox.writeFile(fullPath, content);
+  }
+}
+async function createDirectory(sandbox, path) {
+  const normalizedPath = path.replace(/\/+$/, "");
+  if (!normalizedPath)
+    return;
+  const exists = await sandbox.fileExists(normalizedPath);
+  if (exists) {
+    const isDir = await sandbox.isDirectory(normalizedPath);
+    if (isDir)
+      return;
+  }
+  await sandbox.exec(`mkdir -p "${normalizedPath}"`);
+}
+export {
+  skillsToXml,
+  setupAgentEnvironment,
+  pruneMessagesByTokens,
+  parseSkillMetadata,
+  getContextStatus,
+  fetchSkills,
+  fetchSkill,
+  estimateTokens,
+  estimateMessagesTokens,
+  estimateMessageTokens,
+  discoverSkills,
+  createWriteTool,
+  createWebSearchTool,
+  createWebFetchTool,
+  createVercelSandbox,
+  createTodoWriteTool,
+  createTaskTool,
+  createReadTool,
+  createLocalSandbox,
+  createGrepTool,
+  createGlobTool,
+  createExitPlanModeTool,
+  createEditTool,
+  createE2BSandbox,
+  createCompactConfig,
+  createBashTool,
+  createAgentTools,
+  contextNeedsCompaction,
+  contextNeedsAttention,
+  compactConversation,
+  anthropicPromptCacheMiddleware,
+  MODEL_CONTEXT_LIMITS,
+  DEFAULT_CONFIG
+};