@theokit/sdk-tools 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1394 @@
+'use strict';
+
+var promises = require('fs/promises');
+var path = require('path');
+var sdk = require('@theokit/sdk');
+var zod = require('zod');
+var fs = require('fs');
+var child_process = require('child_process');
+
+// src/apply-patch.ts
+var PathTraversalError = class extends sdk.ConfigurationError {
+  name = "PathTraversalError";
+  constructor(input, resolvedPath) {
+    super(`Path traversal attempt: ${input} \u2192 ${resolvedPath}`, {
+      code: "path_traversal"
+    });
+  }
+};
+var ForbiddenPathError = class extends sdk.ConfigurationError {
+  name = "ForbiddenPathError";
+  constructor(path) {
+    super(
+      `Path '${path}' is in the sensitive-file blocklist (.env, .git/, node_modules/, .theo/, lock files)`,
+      {
+        code: "forbidden_path"
+      }
+    );
+  }
+};
+function safePathJoin(base, ...parts) {
+  if (base === "") {
+    throw new Error("safePathJoin: base must be non-empty");
+  }
+  const baseResolved = path.resolve(base);
+  const target = path.resolve(base, ...parts);
+  if (target !== baseResolved && !target.startsWith(baseResolved + path.sep)) {
+    throw new PathTraversalError(parts.join("/"), target);
+  }
+  return target;
+}
+function assertNoSymlinkEscape(path$1, base) {
+  let baseResolved;
+  try {
+    baseResolved = fs.realpathSync(base);
+  } catch {
+    baseResolved = path.resolve(base);
+  }
+  const resolved = realpathOfDeepestExisting(path$1);
+  if (resolved === void 0) return;
+  if (resolved !== baseResolved && !resolved.startsWith(baseResolved + path.sep)) {
+    throw new PathTraversalError(`symlink ${path$1}`, resolved);
+  }
+}
+function realpathOfDeepestExisting(path$1) {
+  try {
+    return fs.realpathSync(path$1);
+  } catch {
+  }
+  try {
+    const stat = fs.lstatSync(path$1);
+    if (stat.isSymbolicLink()) {
+      const target = fs.readlinkSync(path$1);
+      const parentReal = realpathOfDeepestExisting(path.dirname(path$1));
+      const parentBase = parentReal ?? path.dirname(path$1);
+      return path.resolve(parentBase, target);
+    }
+  } catch {
+  }
+  let cursor = path.dirname(path$1);
+  let suffix = path$1.slice(cursor.length);
+  while (cursor !== path.dirname(cursor)) {
+    try {
+      const real = fs.realpathSync(cursor);
+      return path.resolve(real, `.${suffix}`);
+    } catch {
+      suffix = path$1.slice(path.dirname(cursor).length);
+      cursor = path.dirname(cursor);
+    }
+  }
+  return void 0;
+}
+var LOCK_FILES = /* @__PURE__ */ new Set(["pnpm-lock.yaml", "package-lock.json", "yarn.lock", "bun.lockb"]);
+function isForbiddenPath(input) {
+  const normalized = input.replace(/\\/g, "/").replace(/^\.\//, "");
+  if (normalized.length === 0) return false;
+  const segments = normalized.split("/").filter((s) => s.length > 0);
+  if (segments.length === 0) return false;
+  const first = segments[0];
+  if (first === ".env.example") return false;
+  if (first === ".env") return true;
+  if (/^\.env\./.test(first)) return true;
+  if (first === ".git") return true;
+  if (first === "node_modules") return true;
+  if (first === ".theo") return true;
+  const basename = segments[segments.length - 1];
+  if (LOCK_FILES.has(basename)) return true;
+  return false;
+}
+
+// src/apply-patch.ts
+function createApplyPatchTool(opts) {
+  const { projectRoot } = opts;
+  return sdk.defineTool({
+    name: "apply_patch",
+    description: "Apply a unified diff patch to project files. Each file in the diff is security-checked against the project root. Creates .bak backups before modifying. Returns { ok, files_patched } or { ok: false, error }.",
+    inputSchema: zod.z.object({
+      patch: zod.z.string().min(1).describe("Unified diff content.")
+    }),
+    // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: unified diff parsing is inherently complex
+    handler: async ({ patch }) => {
+      const hunks = parsePatch(patch);
+      if (hunks.length === 0) {
+        return JSON.stringify({ ok: false, error: "parse_error", detail: "no file hunks found" });
+      }
+      for (const hunk of hunks) {
+        if (isForbiddenPath(hunk.file)) {
+          return JSON.stringify({ ok: false, error: "forbidden_path", path: hunk.file });
+        }
+        try {
+          const abs = safePathJoin(projectRoot, hunk.file);
+          assertNoSymlinkEscape(abs, projectRoot);
+        } catch (err) {
+          if (err instanceof PathTraversalError || err instanceof ForbiddenPathError) {
+            return JSON.stringify({ ok: false, error: "path_traversal", path: hunk.file });
+          }
+          throw err;
+        }
+      }
+      const patched = [];
+      for (const hunk of hunks) {
+        const absolutePath = safePathJoin(projectRoot, hunk.file);
+        let content;
+        try {
+          content = await promises.readFile(absolutePath, "utf-8");
+        } catch (err) {
+          const e = err;
+          if (e.code === "ENOENT") {
+            content = "";
+          } else {
+            throw err;
+          }
+        }
+        const result = applyHunks(content, hunk.changes);
+        if (result === null) {
+          return JSON.stringify({
+            ok: false,
+            error: "patch_failed",
+            path: hunk.file,
+            detail: "hunk context mismatch"
+          });
+        }
+        if (content !== "") {
+          await promises.copyFile(absolutePath, `${absolutePath}.bak`);
+        }
+        await promises.mkdir(path.dirname(absolutePath), { recursive: true });
+        await promises.writeFile(absolutePath, result, "utf-8");
+        patched.push(hunk.file);
+      }
+      return JSON.stringify({ ok: true, files_patched: patched });
+    }
+  });
+}
+function parsePatch(patch) {
+  const lines = patch.split("\n");
+  const hunks = [];
+  let current = null;
+  for (const line of lines) {
+    if (line.startsWith("+++ ")) {
+      const filePath = line.slice(4).replace(/^b\//, "").trim();
+      if (filePath && filePath !== "/dev/null") {
+        current = { file: filePath, changes: [] };
+        hunks.push(current);
+      }
+      continue;
+    }
+    if (line.startsWith("--- ")) continue;
+    if (line.startsWith("@@ ")) continue;
+    if (current === null) continue;
+    if (line.startsWith("+")) {
+      current.changes.push({ type: "add", content: line.slice(1) });
+    } else if (line.startsWith("-")) {
+      current.changes.push({ type: "remove", content: line.slice(1) });
+    } else if (line.startsWith(" ")) {
+      current.changes.push({ type: "context", content: line.slice(1) });
+    }
+  }
+  return hunks;
+}
+function applyHunks(content, changes) {
+  const originalLines = content.split("\n");
+  const result = [];
+  let origIdx = 0;
+  const firstContext = changes.find((c) => c.type === "context" || c.type === "remove");
+  if (firstContext) {
+    const startIdx = originalLines.indexOf(firstContext.content, origIdx);
+    if (startIdx === -1) return null;
+    for (let i = 0; i < startIdx; i++) {
+      result.push(originalLines[i]);
+    }
+    origIdx = startIdx;
+  }
+  for (const change of changes) {
+    if (change.type === "context") {
+      if (origIdx >= originalLines.length || originalLines[origIdx] !== change.content) {
+        return null;
+      }
+      result.push(change.content);
+      origIdx++;
+    } else if (change.type === "remove") {
+      if (origIdx >= originalLines.length || originalLines[origIdx] !== change.content) {
+        return null;
+      }
+      origIdx++;
+    } else if (change.type === "add") {
+      result.push(change.content);
+    }
+  }
+  while (origIdx < originalLines.length) {
+    result.push(originalLines[origIdx]);
+    origIdx++;
+  }
+  return result.join("\n");
+}
+function createEditFileTool(opts) {
+  const { projectRoot } = opts;
+  return sdk.defineTool({
+    name: "edit_file",
+    description: "Replace the first occurrence of old_string with new_string in a project-relative file. Falls back to whitespace-normalized matching when the exact match fails. Creates a .bak backup before editing. Returns { ok, replacements } or { ok: false, error }.",
+    inputSchema: zod.z.object({
+      path: zod.z.string().min(1).describe("Project-relative file path."),
+      old_string: zod.z.string().min(1).describe("String to find in the file."),
+      new_string: zod.z.string().describe("Replacement string.")
+    }),
+    // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: unified diff parsing is inherently complex
+    handler: async ({ path, old_string, new_string }) => {
+      if (isForbiddenPath(path)) {
+        return JSON.stringify({ ok: false, error: "forbidden_path", path });
+      }
+      let absolutePath;
+      try {
+        absolutePath = safePathJoin(projectRoot, path);
+        assertNoSymlinkEscape(absolutePath, projectRoot);
+      } catch (err) {
+        if (err instanceof PathTraversalError || err instanceof ForbiddenPathError) {
+          return JSON.stringify({ ok: false, error: "path_traversal", path });
+        }
+        throw err;
+      }
+      let content;
+      try {
+        content = await promises.readFile(absolutePath, "utf-8");
+      } catch (err) {
+        const e = err;
+        if (e.code === "ENOENT") {
+          return JSON.stringify({ ok: false, error: "not_found", path });
+        }
+        throw err;
+      }
+      const exactIdx = content.indexOf(old_string);
+      if (exactIdx !== -1) {
+        await promises.copyFile(absolutePath, `${absolutePath}.bak`);
+        const result2 = content.slice(0, exactIdx) + new_string + content.slice(exactIdx + old_string.length);
+        await promises.writeFile(absolutePath, result2, "utf-8");
+        return JSON.stringify({ ok: true, replacements: 1 });
+      }
+      const normalizedContent = normalizeWhitespace(content);
+      const normalizedOld = normalizeWhitespace(old_string);
+      const normalizedIdx = normalizedContent.indexOf(normalizedOld);
+      if (normalizedIdx === -1) {
+        return JSON.stringify({ ok: false, error: "no_match", path });
+      }
+      const span = findOriginalSpan(
+        content,
+        normalizedContent,
+        normalizedIdx,
+        normalizedOld.length
+      );
+      await promises.copyFile(absolutePath, `${absolutePath}.bak`);
+      const result = content.slice(0, span.start) + new_string + content.slice(span.end);
+      await promises.writeFile(absolutePath, result, "utf-8");
+      return JSON.stringify({ ok: true, replacements: 1 });
+    }
+  });
+}
+function normalizeWhitespace(s) {
+  return s.replace(/\s+/g, " ").trim();
+}
+function findOriginalSpan(original, _normalized, normStart, normLen) {
+  let origIdx = 0;
+  let normIdx = 0;
+  while (origIdx < original.length && /\s/.test(original[origIdx])) {
+    origIdx++;
+  }
+  while (normIdx < normStart && origIdx < original.length) {
+    if (/\s/.test(original[origIdx])) {
+      while (origIdx < original.length && /\s/.test(original[origIdx])) {
+        origIdx++;
+      }
+      normIdx++;
+    } else {
+      origIdx++;
+      normIdx++;
+    }
+  }
+  const start = origIdx;
+  let walked = 0;
+  while (walked < normLen && origIdx < original.length) {
+    if (/\s/.test(original[origIdx])) {
+      while (origIdx < original.length && /\s/.test(original[origIdx])) {
+        origIdx++;
+      }
+      walked++;
+    } else {
+      origIdx++;
+      walked++;
+    }
+  }
+  return { start, end: origIdx };
+}
+
+// src/formatter.ts
+function formatCode(language, code) {
+  return `\`\`\`${language}
+${code}
+\`\`\``;
+}
+function formatDiff(diff) {
+  return `\`\`\`diff
+${diff}
+\`\`\``;
+}
+function formatFileList(files) {
+  if (files.length === 0) return "(no files)";
+  return files.map((f) => `- ${f}`).join("\n");
+}
+function formatError(message, code) {
+  const prefix = code ? `[${code}] ` : "";
+  return `> **Error:** ${prefix}${message}`;
+}
+
+// src/path-scope.ts
+function checkPathScope(path, projectRoot) {
+  if (path === void 0 || path === "") return null;
+  try {
+    const abs = safePathJoin(projectRoot, path);
+    assertNoSymlinkEscape(abs, projectRoot);
+    return null;
+  } catch (err) {
+    if (err instanceof PathTraversalError || err instanceof ForbiddenPathError) {
+      return JSON.stringify({ ok: false, error: "path_traversal", path });
+    }
+    throw err;
+  }
+}
+
+// src/subprocess.ts
+function createSettleGate(timer) {
+  let done = false;
+  return {
+    settled: () => done,
+    fire: (onSettle) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      onSettle();
+    }
+  };
+}
+function armTimeoutKill(child, timeoutMs, onTimeout, resolve2) {
+  const timer = setTimeout(() => {
+    gate.fire(() => {
+      try {
+        process.kill(-(child.pid ?? 0), "SIGKILL");
+      } catch {
+      }
+      resolve2(onTimeout());
+    });
+  }, timeoutMs);
+  const gate = createSettleGate(timer);
+  return gate;
+}
+function attachChildSettlers(child, gate, onClose, onError, resolve2) {
+  child.on("close", (code) => {
+    gate.fire(() => resolve2(onClose(code)));
+  });
+  child.on("error", (err) => {
+    gate.fire(() => resolve2(onError(err)));
+  });
+}
+
+// src/git-diff.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_STDOUT_BYTES = 5 * 1024 * 1024;
+function createGitDiffTool(opts) {
+  const {
+    projectRoot,
+    timeoutMs = DEFAULT_TIMEOUT_MS,
+    maxStdoutBytes = DEFAULT_MAX_STDOUT_BYTES
+  } = opts;
+  return sdk.defineTool({
+    name: "git_diff",
+    description: "Return the unified diff of the project's working tree (or staged changes when cached=true). Scoped to a single file when 'path' is provided. Requires the project to be a git repository. Returns { ok, diff, truncated? } or { ok: false, error }.",
+    inputSchema: zod.z.object({
+      path: zod.z.string().optional().describe("Optional project-relative file or dir scope."),
+      cached: zod.z.boolean().optional().describe("If true, show staged changes (git diff --cached). Default false.")
+    }),
+    handler: async ({ path: path$1, cached }) => {
+      if (!fs.existsSync(path.join(projectRoot, ".git"))) {
+        return JSON.stringify({ ok: false, error: "not_a_repo" });
+      }
+      const scopeCheck = checkPathScope(path$1, projectRoot);
+      if (scopeCheck !== null) return scopeCheck;
+      const args = buildDiffArgs(cached, path$1);
+      const result = await runGitProcess(projectRoot, args, timeoutMs, maxStdoutBytes);
+      return formatGitResult(result, timeoutMs);
+    }
+  });
+}
+function buildDiffArgs(cached, path) {
+  const args = ["diff", "--no-color"];
+  if (cached === true) args.push("--cached");
+  if (path !== void 0 && path !== "") args.push("--", path);
+  return args;
+}
+function formatGitResult(result, timeoutMs) {
+  if (result.kind === "timeout") {
+    return JSON.stringify({ ok: false, error: "timeout", timeoutMs });
+  }
+  if (result.kind === "error") {
+    return JSON.stringify({ ok: false, error: "git_failed", stderr: result.stderr });
+  }
+  return JSON.stringify({ ok: true, diff: result.stdout, truncated: result.truncated });
+}
+function runGitProcess(cwd, args, timeoutMs, maxStdoutBytes) {
+  return new Promise((resolve2) => {
+    const child = child_process.spawn("git", args, { cwd, detached: true, stdio: ["ignore", "pipe", "pipe"] });
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    let stdoutBytes = 0;
+    let truncated = false;
+    const gate = armTimeoutKill(
+      child,
+      timeoutMs,
+      () => ({ kind: "timeout" }),
+      resolve2
+    );
+    child.stdout.on("data", (chunk) => {
+      if (gate.settled()) return;
+      if (stdoutBytes >= maxStdoutBytes) {
+        truncated = true;
+        return;
+      }
+      const remaining = maxStdoutBytes - stdoutBytes;
+      if (chunk.length > remaining) {
+        stdoutChunks.push(chunk.subarray(0, remaining));
+        stdoutBytes = maxStdoutBytes;
+        truncated = true;
+      } else {
+        stdoutChunks.push(chunk);
+        stdoutBytes += chunk.length;
+      }
+    });
+    child.stderr.on("data", (chunk) => {
+      stderrChunks.push(chunk);
+    });
+    attachChildSettlers(
+      child,
+      gate,
+      (code) => {
+        const stdout = Buffer.concat(stdoutChunks).toString("utf-8");
+        const stderr = Buffer.concat(stderrChunks).toString("utf-8");
+        return code === 0 ? { kind: "ok", stdout, truncated } : { kind: "error", stderr };
+      },
+      (err) => ({ kind: "error", stderr: err.message }),
+      resolve2
+    );
+  });
+}
+var DEFAULT_EXCLUDES = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", ".theo"]);
+function createGlobTool(opts) {
+  const { projectRoot } = opts;
+  return sdk.defineTool({
+    name: "glob_files",
+    description: "List project files matching a glob-like pattern. Excludes node_modules, .git, dist, .theo by default. Returns relative paths. Pattern supports * and ** wildcards. Returns { ok, files } or { ok: false, error }.",
+    inputSchema: zod.z.object({
+      pattern: zod.z.string().min(1).describe("Glob pattern (e.g. '**/*.ts', 'src/**/*.json')."),
+      cwd: zod.z.string().optional().describe("Project-relative subdirectory to search from.")
+    }),
+    handler: async ({ pattern, cwd }) => {
+      let searchRoot = projectRoot;
+      if (cwd) {
+        try {
+          searchRoot = safePathJoin(projectRoot, cwd);
+          assertNoSymlinkEscape(searchRoot, projectRoot);
+        } catch (err) {
+          if (err instanceof PathTraversalError || err instanceof ForbiddenPathError) {
+            return JSON.stringify({ ok: false, error: "path_traversal", path: cwd });
+          }
+          throw err;
+        }
+      }
+      const regex = globToRegex(pattern);
+      const files = [];
+      await walkDir(searchRoot, searchRoot, regex, files);
+      const relativePaths = files.map((f) => path.relative(projectRoot, f)).sort();
+      return JSON.stringify({ ok: true, files: relativePaths, count: relativePaths.length });
+    }
+  });
+}
+async function walkDir(base, dir, pattern, results) {
+  let entries;
+  try {
+    entries = await promises.readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (DEFAULT_EXCLUDES.has(entry.name)) continue;
+    const fullPath = path.join(dir, entry.name);
+    const relPath = path.relative(base, fullPath);
+    if (entry.isDirectory()) {
+      await walkDir(base, fullPath, pattern, results);
+    } else if (entry.isFile() && pattern.test(relPath)) {
+      results.push(fullPath);
+    }
+  }
+}
+function globToRegex(pattern) {
+  let regexStr = "";
+  let i = 0;
+  while (i < pattern.length) {
+    const ch = pattern[i];
+    if (ch === "*" && pattern[i + 1] === "*") {
+      regexStr += ".*";
+      i += 2;
+      if (pattern[i] === "/") i++;
+    } else if (ch === "*") {
+      regexStr += "[^/]*";
+      i++;
+    } else if (ch === "?") {
+      regexStr += "[^/]";
+      i++;
+    } else if (".+^${}()|[]\\".includes(ch)) {
+      regexStr += `\\${ch}`;
+      i++;
+    } else {
+      regexStr += ch;
+      i++;
+    }
+  }
+  return new RegExp(`^${regexStr}$`);
+}
+var DEFAULT_MAX_ENTRIES = 500;
+function createListDirTool(opts) {
+  const { projectRoot, max = DEFAULT_MAX_ENTRIES } = opts;
+  return sdk.defineTool({
+    name: "list_dir",
+    description: `Return the direct entries of a project-relative directory. Refuses paths outside the project root or in the sensitive-file blocklist (.env, .git/, node_modules/, .theo/, lock files). Caps at ${String(max)} entries by default; result carries truncated + totalCount.`,
+    inputSchema: zod.z.object({
+      path: zod.z.string().min(1).describe("Project-relative directory path. Use '.' for root.")
+    }),
+    handler: async ({ path }) => {
+      const relative2 = path === "" || path === "." ? "." : path;
+      if (relative2 !== "." && isForbiddenPath(relative2)) {
+        return JSON.stringify({ ok: false, error: "forbidden_path", path });
+      }
+      const boundary = resolveDirBoundary(relative2, projectRoot, path);
+      if ("error" in boundary) return boundary.error;
+      const readResult = await readDirSafe(boundary.absolutePath, path);
+      if ("error" in readResult) return readResult.error;
+      return formatListing(readResult.dirents, max);
+    }
+  });
+}
+function resolveDirBoundary(relative2, projectRoot, originalPath) {
+  try {
+    const absolutePath = relative2 === "." ? projectRoot : safePathJoin(projectRoot, relative2);
+    assertNoSymlinkEscape(absolutePath, projectRoot);
+    return { absolutePath };
+  } catch (err) {
+    if (err instanceof PathTraversalError || err instanceof ForbiddenPathError) {
+      return { error: JSON.stringify({ ok: false, error: "path_traversal", path: originalPath }) };
+    }
+    throw err;
+  }
+}
+async function readDirSafe(absolutePath, originalPath) {
+  try {
+    const dirents = await promises.readdir(absolutePath, { withFileTypes: true });
+    return { dirents };
+  } catch (err) {
+    const e = err;
+    if (e.code === "ENOENT" || e.code === "ENOTDIR") {
+      return { error: JSON.stringify({ ok: false, error: "not_found", path: originalPath }) };
+    }
+    throw err;
+  }
+}
+function formatListing(dirents, max) {
+  const totalCount = dirents.length;
+  const truncated = totalCount > max;
+  const entries = dirents.slice(0, max).map((d) => ({
+    name: d.name,
+    type: d.isDirectory() ? "directory" : "file"
+  }));
+  return JSON.stringify({ ok: true, entries, truncated, totalCount });
+}
+
+// src/plan-mode.ts
+var PLAN_INSTRUCTIONS = [
+  "You are now in PLAN MODE.",
+  "Outline the steps you will take before executing any code changes.",
+  "Number each step. Include file paths and what will change.",
+  "Do NOT make any edits or tool calls other than reading files.",
+  "When ready, use plan_mode with action 'exit' to return to normal mode."
+].join("\n");
+var NORMAL_INSTRUCTIONS = "Returned to NORMAL MODE. You may now execute changes.";
+function createPlanModeTool() {
+  let mode = "normal";
+  return {
+    name: "plan_mode",
+    description: "Toggle between normal and plan mode. Actions: 'enter' (switch to plan mode), 'exit' (return to normal), 'status' (check current mode). Returns { ok, mode, message }.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["enter", "exit", "status"],
+          description: "The action to perform."
+        }
+      },
+      required: ["action"]
+    },
+    handler: (input) => {
+      switch (input.action) {
+        case "enter":
+          mode = "plan";
+          return JSON.stringify({ ok: true, mode, message: PLAN_INSTRUCTIONS });
+        case "exit":
+          mode = "normal";
+          return JSON.stringify({ ok: true, mode, message: NORMAL_INSTRUCTIONS });
+        case "status":
+          return JSON.stringify({ ok: true, mode, message: `Current mode: ${mode}` });
+        default:
+          return JSON.stringify({
+            ok: false,
+            error: "invalid_action",
+            message: `Unknown action '${input.action}'. Valid: enter, exit, status.`
+          });
+      }
+    },
+    currentMode: () => mode
+  };
+}
+
+// src/question.ts
+function createQuestionTool(opts) {
+  const timeoutMs = opts.timeoutMs ?? 3e5;
+  return {
+    name: "question",
+    description: "Ask the user a question and wait for their response. Use when you need clarification or confirmation before proceeding. Returns { ok, answer } or { ok: false, error: 'timeout' }.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        question: { type: "string", description: "The question to ask the user." }
+      },
+      required: ["question"]
+    },
+    handler: async (input) => {
+      const timeout = new Promise((_, reject) => {
+        setTimeout(() => reject(new Error("timeout")), timeoutMs);
+      });
+      try {
+        const answer = await Promise.race([opts.askUser(input.question), timeout]);
+        return JSON.stringify({ ok: true, answer });
+      } catch (err) {
+        if (err instanceof Error && err.message === "timeout") {
+          return JSON.stringify({
+            ok: false,
+            error: "timeout",
+            message: "User did not respond within timeout."
+          });
+        }
+        throw err;
+      }
+    }
+  };
+}
+var MAX_FILE_SIZE = 5 * 1024 * 1024;
+var BINARY_PROBE_BYTES = 8 * 1024;
+function createReadFileTool(opts) {
+  const { projectRoot } = opts;
+  return sdk.defineTool({
+    name: "read_file",
+    description: "Read a single project-relative text file as UTF-8. Refuses paths that escape the project root, are in the sensitive-file blocklist (.env, .git/, node_modules/, .theo/, lock files), or contain a null byte in the first 8 KB (binary file). Returns { ok, content } or { ok: false, error }.",
+    inputSchema: zod.z.object({
+      path: zod.z.string().min(1).describe("Project-relative file path.")
+    }),
+    handler: async ({ path }) => {
+      if (isForbiddenPath(path)) {
+        return JSON.stringify({ ok: false, error: "forbidden_path", path });
+      }
+      const boundary = resolveBoundary(path, projectRoot);
+      if ("error" in boundary) return boundary.error;
+      const opened = await openHandleSafe(boundary.absolutePath, path);
+      if ("error" in opened) return opened.error;
+      try {
+        return await readContent(opened.handle, path);
+      } finally {
+        await opened.handle.close();
+      }
+    }
+  });
+}
+function resolveBoundary(path, projectRoot) {
+  try {
+    const absolutePath = safePathJoin(projectRoot, path);
+    assertNoSymlinkEscape(absolutePath, projectRoot);
+    return { absolutePath };
+  } catch (err) {
+    if (err instanceof PathTraversalError || err instanceof ForbiddenPathError) {
+      return { error: JSON.stringify({ ok: false, error: "path_traversal", path }) };
+    }
+    throw err;
+  }
+}
+async function openHandleSafe(absolutePath, path) {
+  try {
+    const handle = await promises.open(absolutePath, "r");
+    return { handle };
+  } catch (err) {
+    const e = err;
+    if (e.code === "ENOENT") {
+      return { error: JSON.stringify({ ok: false, error: "not_found", path }) };
+    }
+    throw err;
+  }
+}
+async function readContent(handle, path) {
+  const stat = await handle.stat();
+  if (stat.size > MAX_FILE_SIZE) {
+    return JSON.stringify({
+      ok: false,
+      error: "too_large",
+      path,
+      size: stat.size,
+      limit: MAX_FILE_SIZE
+    });
+  }
+  if (await isBinaryProbe(handle, Number(stat.size))) {
+    return JSON.stringify({ ok: false, error: "binary_file", path, size: stat.size });
+  }
+  const content = await handle.readFile({ encoding: "utf-8" });
+  return JSON.stringify({ ok: true, content, size: stat.size });
+}
+async function isBinaryProbe(handle, size) {
+  const probeLen = Math.min(BINARY_PROBE_BYTES, size);
+  if (probeLen <= 0) return false;
+  const probe = Buffer.alloc(probeLen);
+  const { bytesRead } = await handle.read(probe, 0, probeLen, 0);
+  for (let i = 0; i < bytesRead; i += 1) {
+    if (probe[i] === 0) return true;
+  }
+  return false;
+}
+var DEFAULT_TIMEOUT_MS2 = 12e4;
+var DEFAULT_MAX_STDOUT_BYTES2 = 10 * 1024 * 1024;
+function createRunVitestTool(opts) {
+  const {
+    projectRoot,
+    timeoutMs = DEFAULT_TIMEOUT_MS2,
+    maxStdoutBytes = DEFAULT_MAX_STDOUT_BYTES2
+  } = opts;
+  return sdk.defineTool({
+    name: "run_vitest",
+    description: "Run the project's vitest suite, optionally scoped to a file or pattern via 'path'. Returns parsed { ok, summary } or { ok: false, error }. Vitest stdout warnings are stripped \u2014 the parser extracts the trailing JSON report.",
+    inputSchema: zod.z.object({
+      path: zod.z.string().optional().describe("Optional vitest pattern or file path (project-relative).")
+    }),
+    handler: async ({ path }) => {
+      const scopeError = validateVitestScope(path, projectRoot);
+      if (scopeError !== null) return scopeError;
+      const args = ["--no-install", "vitest", "run", "--reporter=json"];
+      if (path !== void 0 && path !== "") args.push(path);
+      const result = await runProcess(projectRoot, "npx", args, timeoutMs, maxStdoutBytes);
+      return formatVitestResult(result, timeoutMs);
+    }
+  });
+}
+function validateVitestScope(path, projectRoot) {
+  if (path !== void 0 && path !== "" && isForbiddenPath(path)) {
+    return JSON.stringify({ ok: false, error: "forbidden_path", path });
+  }
+  return checkPathScope(path, projectRoot);
+}
+function formatVitestResult(result, timeoutMs) {
+  if (result.kind === "timeout") {
+    return JSON.stringify({ ok: false, error: "timeout", timeoutMs });
+  }
+  if (result.kind === "spawn_error") {
+    return JSON.stringify({ ok: false, error: "no_vitest", detail: result.message });
+  }
+  const summary = extractTrailingJson(result.stdout);
+  if (summary === null) {
+    return JSON.stringify({
+      ok: false,
+      error: "unparseable_output",
+      stderrPreview: result.stderr.slice(0, 500)
+    });
+  }
+  return JSON.stringify({ ok: true, summary });
+}
+function extractTrailingJson(stdout) {
+  const lines = stdout.split(/\r?\n/);
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    const line = lines[i].trim();
+    if (line.length === 0) continue;
+    if (line[0] !== "{" && line[0] !== "[") continue;
+    try {
+      return JSON.parse(line);
+    } catch {
+    }
+  }
+  return null;
+}
+function appendCapped(chunks, chunk, current, cap) {
+  if (current >= cap) return current;
+  const remaining = cap - current;
+  if (chunk.length > remaining) {
+    chunks.push(chunk.subarray(0, remaining));
+    return cap;
+  }
+  chunks.push(chunk);
+  return current + chunk.length;
+}
+function runProcess(cwd, command, args, timeoutMs, maxStdoutBytes) {
+  return new Promise((resolve2) => {
+    const child = child_process.spawn(command, args, {
+      cwd,
+      detached: true,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    let stdoutBytes = 0;
+    const gate = armTimeoutKill(
+      child,
+      timeoutMs,
+      () => ({ kind: "timeout" }),
+      resolve2
+    );
+    child.stdout.on("data", (chunk) => {
+      if (gate.settled()) return;
+      stdoutBytes = appendCapped(stdoutChunks, chunk, stdoutBytes, maxStdoutBytes);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderrChunks.push(chunk);
+    });
+    attachChildSettlers(
+      child,
+      gate,
+      (code) => ({
+        kind: "ok",
+        stdout: Buffer.concat(stdoutChunks).toString("utf-8"),
+        stderr: Buffer.concat(stderrChunks).toString("utf-8"),
+        exitCode: code ?? 0
+      }),
+      (err) => ({ kind: "spawn_error", message: err.message }),
+      resolve2
+    );
+  });
+}
+var DEFAULT_MAX_MATCHES = 100;
+var DEFAULT_MAX_FILE_SIZE = 1024 * 1024;
+var BINARY_PROBE_BYTES2 = 8 * 1024;
+var PREVIEW_MAX = 200;
+function createSearchTextTool(opts) {
+  const {
+    projectRoot,
+    maxMatches = DEFAULT_MAX_MATCHES,
+    maxFileSize = DEFAULT_MAX_FILE_SIZE
+  } = opts;
+  return sdk.defineTool({
+    name: "search_text",
+    description: `Search the project tree for a literal text query. Skips sensitive dirs (.env/.git/node_modules/.theo), binary files, and files over 1 MB. Returns up to ${String(maxMatches)} matches as { file, line, preview }. Use 'path' to scope the search to a subdirectory.`,
+    inputSchema: zod.z.object({
+      query: zod.z.string().min(1).describe("Literal text to search for. Case-sensitive."),
+      path: zod.z.string().optional().describe("Optional project-relative directory to scope the search.")
+    }),
+    handler: async ({ query, path }) => {
+      const scope = resolveSearchScope(path, projectRoot);
+      if ("error" in scope) return scope.error;
+      const state = {
+        matches: [],
+        totalMatches: 0,
+        truncated: false,
+        query,
+        maxMatches,
+        maxFileSize,
+        projectRoot
+      };
+      await walk(scope.scopeAbs, state);
+      return JSON.stringify({
+        ok: true,
+        matches: state.matches,
+        truncated: state.truncated,
+        totalMatches: state.totalMatches
+      });
+    }
+  });
+}
+function resolveSearchScope(path, projectRoot) {
+  const scopeRel = path === void 0 || path === "" || path === "." ? "." : path;
+  try {
+    const scopeAbs = scopeRel === "." ? projectRoot : safePathJoin(projectRoot, scopeRel);
+    assertNoSymlinkEscape(scopeAbs, projectRoot);
+    return { scopeAbs };
+  } catch (err) {
+    if (err instanceof PathTraversalError || err instanceof ForbiddenPathError) {
+      return { error: JSON.stringify({ ok: false, error: "path_traversal", path }) };
+    }
+    throw err;
+  }
+}
+async function handleEntry(entry, absDir, state) {
+  const entryAbs = path.join(absDir, entry.name);
+  const entryRel = path.relative(state.projectRoot, entryAbs);
+  if (isForbiddenPath(entryRel)) return;
+  if (entry.isDirectory()) {
+    await walk(entryAbs, state);
+    return;
+  }
+  if (entry.isFile()) await scanFile(entryAbs, entryRel, state);
+}
+async function walk(absDir, state) {
+  if (state.truncated) return;
+  const entries = await readEntriesQuiet(absDir);
+  if (entries === null) return;
+  for (const entry of entries) {
+    if (state.truncated) return;
+    await handleEntry(entry, absDir, state);
+  }
+}
+async function readEntriesQuiet(absDir) {
+  try {
+    return await promises.readdir(absDir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+}
+async function readBufferQuiet(absPath) {
+  try {
+    return await promises.readFile(absPath);
+  } catch {
+    return null;
+  }
+}
+function isBinaryBuffer(buffer) {
+  const probeEnd = Math.min(buffer.length, BINARY_PROBE_BYTES2);
+  for (let i = 0; i < probeEnd; i += 1) {
+    if (buffer[i] === 0) return true;
+  }
+  return false;
+}
+function recordMatch(state, file, line, lineText) {
+  state.totalMatches += 1;
+  if (state.matches.length < state.maxMatches) {
+    state.matches.push({
+      file,
+      line,
+      preview: lineText.length > PREVIEW_MAX ? `${lineText.slice(0, PREVIEW_MAX)}\u2026` : lineText
+    });
+    return true;
+  }
+  state.truncated = true;
+  return false;
+}
+async function scanFile(absPath, relPath, state) {
+  const buffer = await readBufferQuiet(absPath);
+  if (buffer === null || buffer.length > state.maxFileSize) return;
+  if (isBinaryBuffer(buffer)) return;
+  const lines = buffer.toString("utf-8").split("\n");
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i];
+    if (!line.includes(state.query)) continue;
+    if (!recordMatch(state, relPath, i + 1, line)) return;
+  }
+}
+var DEFAULT_TIMEOUT_MS3 = 3e4;
+var MAX_TIMEOUT_MS = 3e5;
+var MAX_OUTPUT_BYTES = 5 * 1024 * 1024;
+function createShellTool(opts) {
+  const { projectRoot, defaultTimeoutMs = DEFAULT_TIMEOUT_MS3 } = opts;
+  return sdk.defineTool({
+    name: "shell_exec",
+    description: "Execute a shell command in the project directory. Returns stdout, stderr, and exit code. Default timeout 30s, max 5 minutes. Output capped at 5 MB. Returns { ok, stdout, stderr, exit_code } or { ok: false, error }.",
+    inputSchema: zod.z.object({
+      command: zod.z.string().min(1).describe("Shell command to execute."),
+      timeout_ms: zod.z.number().int().positive().optional().describe("Timeout in milliseconds (default 30000, max 300000).")
+    }),
+    handler: async ({ command, timeout_ms }) => {
+      const timeoutMs = Math.min(timeout_ms ?? defaultTimeoutMs, MAX_TIMEOUT_MS);
+      const result = await runShell(projectRoot, command, timeoutMs);
+      return result;
+    }
+  });
+}
+function runShell(cwd, command, timeoutMs) {
+  return new Promise((resolve2) => {
+    const child = child_process.spawn("/bin/sh", ["-c", command], {
+      cwd,
+      detached: true,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
+    const gate = armTimeoutKill(
+      child,
+      timeoutMs,
+      () => ({ kind: "timeout" }),
+      (result) => resolve2(formatResult(result, timeoutMs))
+    );
+    child.stdout.on("data", (chunk) => {
+      if (gate.settled()) return;
+      if (stdoutBytes >= MAX_OUTPUT_BYTES) {
+        return;
+      }
+      const remaining = MAX_OUTPUT_BYTES - stdoutBytes;
+      if (chunk.length > remaining) {
+        stdoutChunks.push(chunk.subarray(0, remaining));
+        stdoutBytes = MAX_OUTPUT_BYTES;
+      } else {
+        stdoutChunks.push(chunk);
+        stdoutBytes += chunk.length;
+      }
+    });
+    child.stderr.on("data", (chunk) => {
+      if (gate.settled()) return;
+      if (stderrBytes >= MAX_OUTPUT_BYTES) return;
+      const remaining = MAX_OUTPUT_BYTES - stderrBytes;
+      if (chunk.length > remaining) {
+        stderrChunks.push(chunk.subarray(0, remaining));
+        stderrBytes = MAX_OUTPUT_BYTES;
+      } else {
+        stderrChunks.push(chunk);
+        stderrBytes += chunk.length;
+      }
+    });
+    attachChildSettlers(
+      child,
+      gate,
+      (code) => ({
+        kind: "ok",
+        stdout: Buffer.concat(stdoutChunks).toString("utf-8"),
+        stderr: Buffer.concat(stderrChunks).toString("utf-8"),
+        exitCode: code
+      }),
+      (err) => ({ kind: "error", message: err.message }),
+      (result) => resolve2(formatResult(result, timeoutMs))
+    );
+  });
+}
+function formatResult(result, timeoutMs) {
+  if (result.kind === "timeout") {
+    return JSON.stringify({ ok: false, error: "timeout", timeout_ms: timeoutMs });
+  }
+  if (result.kind === "error") {
+    return JSON.stringify({ ok: false, error: "exec_failed", message: result.message });
+  }
+  return JSON.stringify({
+    ok: true,
+    stdout: result.stdout,
+    stderr: result.stderr,
+    exit_code: result.exitCode
+  });
+}
+
+// src/todolist.ts
+function ok(data) {
+  return JSON.stringify({ ok: true, ...data });
+}
+function fail(data) {
+  return JSON.stringify({ ok: false, ...data });
+}
+function requireId(input) {
+  if (!("id" in input) || !input.id) return null;
+  return input.id;
+}
+function createTodolistTool() {
+  const items = [];
+  let nextId = 1;
+  function genId() {
+    return `todo-${nextId++}`;
+  }
+  function findById(id) {
+    return items.find((i) => i.id === id);
+  }
+  function formatList() {
+    if (items.length === 0) return "No tasks. Use action 'add' to create one.";
+    const lines = items.map((item) => {
+      const icon = item.status === "done" ? "[x]" : item.status === "in_progress" ? "[>]" : "[ ]";
+      return `${icon} ${item.id}: ${item.title}`;
+    });
+    const pending = items.filter((i) => i.status === "pending").length;
+    const inProg = items.filter((i) => i.status === "in_progress").length;
+    const done = items.filter((i) => i.status === "done").length;
+    lines.push(`
+${done}/${items.length} done | ${inProg} in progress | ${pending} pending`);
+    return lines.join("\n");
+  }
+  function handleAdd(input) {
+    if (!("title" in input) || !input.title) return fail({ error: "missing_title" });
+    const item = {
+      id: genId(),
+      title: input.title,
+      status: "pending",
+      createdAt: Date.now()
+    };
+    items.push(item);
+    return ok({ id: item.id, message: `Added: ${item.title}`, items_summary: formatList() });
+  }
+  function handleSetStatus(input, status) {
+    const id = requireId(input);
+    if (!id) return fail({ error: "missing_id" });
+    const item = findById(id);
+    if (!item) return fail({ error: "not_found", id });
+    item.status = status;
+    if (status === "done") item.completedAt = Date.now();
+    const verb = status === "done" ? "Completed" : "Started";
+    return ok({ message: `${verb}: ${item.title}`, items_summary: formatList() });
+  }
+  function handleRemove(input) {
+    const id = requireId(input);
+    if (!id) return fail({ error: "missing_id" });
+    const idx = items.findIndex((i) => i.id === id);
+    if (idx === -1) return fail({ error: "not_found", id });
+    const removed = items.splice(idx, 1)[0];
+    return ok({ message: `Removed: ${removed.title}`, items_summary: formatList() });
+  }
+  function handleClearCompleted() {
+    const before = items.length;
+    const kept = items.filter((i) => i.status !== "done");
+    items.length = 0;
+    items.push(...kept);
+    return ok({
+      message: `Cleared ${before - items.length} completed items`,
+      items_summary: formatList()
+    });
+  }
+  const actions = {
+    add: handleAdd,
+    in_progress: (input) => handleSetStatus(input, "in_progress"),
+    complete: (input) => handleSetStatus(input, "done"),
+    remove: handleRemove,
+    list: () => ok({ items_summary: formatList() }),
+    clear_completed: handleClearCompleted
+  };
+  return {
+    name: "todolist",
+    description: "Track multi-step task progress. Actions: 'add' (create task with title), 'complete' (mark done by id), 'in_progress' (mark started by id), 'remove' (delete by id), 'list' (show all), 'clear_completed' (remove done items). Returns { ok, items_summary }.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["add", "complete", "in_progress", "remove", "list", "clear_completed"],
+          description: "The action to perform."
+        },
+        title: {
+          type: "string",
+          description: "Title for a new todo item (required for 'add')."
+        },
+        id: {
+          type: "string",
+          description: "ID of the todo item (required for 'complete', 'in_progress', 'remove')."
+        }
+      },
+      required: ["action"]
+    },
+    handler: (input) => {
+      const action = actions[input.action];
+      if (!action) return fail({ error: "invalid_action" });
+      return action(input);
+    },
+    getItems: () => [...items]
+  };
+}
+function truncateOutput(output, opts) {
+  const maxBytes = opts?.maxBytes ?? 3e4;
+  const outputDir = opts?.outputDir ?? ".theocode/tool-output";
+  const byteLength = Buffer.byteLength(output, "utf-8");
+  if (byteLength <= maxBytes) {
+    return { content: output, truncated: false };
+  }
+  fs.mkdirSync(outputDir, { recursive: true });
+  const filename = `overflow-${Date.now()}.txt`;
+  const overflowPath = path.join(outputDir, filename);
+  fs.writeFileSync(overflowPath, output, "utf-8");
+  const truncated = Buffer.from(output, "utf-8").subarray(0, maxBytes).toString("utf-8");
+  const trailer = `
+
+[Output truncated. Full output: ${overflowPath}]`;
+  return {
+    content: truncated + trailer,
+    truncated: true,
+    overflowPath
+  };
+}
+var DEFAULT_TIMEOUT_MS4 = 3e4;
+var MAX_BODY_BYTES = 1 * 1024 * 1024;
+function createWebFetchTool(opts) {
+  const defaultTimeoutMs = opts?.defaultTimeoutMs ?? DEFAULT_TIMEOUT_MS4;
+  return sdk.defineTool({
+    name: "web_fetch",
+    description: "Fetch content from a URL via HTTP/HTTPS. Rejects non-http(s) URLs. Response body capped at 1 MB. Returns { ok, content, status_code } or { ok: false, error }.",
+    inputSchema: zod.z.object({
+      url: zod.z.string().min(1).describe("URL to fetch (http or https only)."),
+      timeout_ms: zod.z.number().int().positive().optional().describe("Timeout in milliseconds (default 30000).")
+    }),
+    // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: fetch with guards
+    handler: async ({ url, timeout_ms }) => {
+      let parsed;
+      try {
+        parsed = new URL(url);
+      } catch {
+        return JSON.stringify({ ok: false, error: "invalid_url", url });
+      }
+      if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        return JSON.stringify({
+          ok: false,
+          error: "invalid_url",
+          url,
+          detail: "only http and https protocols allowed"
+        });
+      }
+      const timeoutMs = timeout_ms ?? defaultTimeoutMs;
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeoutMs);
+      try {
+        const response = await fetch(url, { signal: controller.signal });
+        clearTimeout(timer);
+        const contentLength = response.headers.get("content-length");
+        if (contentLength && Number(contentLength) > MAX_BODY_BYTES) {
+          return JSON.stringify({
+            ok: false,
+            error: "too_large",
+            url,
+            size: Number(contentLength),
+            limit: MAX_BODY_BYTES
+          });
+        }
+        const buffer = await response.arrayBuffer();
+        if (buffer.byteLength > MAX_BODY_BYTES) {
+          return JSON.stringify({
+            ok: false,
+            error: "too_large",
+            url,
+            size: buffer.byteLength,
+            limit: MAX_BODY_BYTES
+          });
+        }
+        const content = new TextDecoder("utf-8").decode(buffer);
+        const contentType = response.headers.get("content-type") ?? void 0;
+        return JSON.stringify({
+          ok: true,
+          content,
+          status_code: response.status,
+          content_type: contentType
+        });
+      } catch (err) {
+        clearTimeout(timer);
+        const e = err;
+        if (e.name === "AbortError") {
+          return JSON.stringify({ ok: false, error: "timeout", url, timeout_ms: timeoutMs });
+        }
+        return JSON.stringify({
+          ok: false,
+          error: "fetch_failed",
+          url,
+          message: e.message ?? "unknown"
+        });
+      }
+    }
+  });
+}
+function createWebSearchTool(opts) {
+  const { search, defaultMaxResults = 5 } = opts;
+  return sdk.defineTool({
+    name: "web_search",
+    description: "Search the web for a query. Returns a list of results with title, URL, and snippet. The search provider is injected by the consumer. Returns { ok, results } or { ok: false, error }.",
+    inputSchema: zod.z.object({
+      query: zod.z.string().min(1).describe("Search query."),
+      max_results: zod.z.number().int().positive().max(20).optional().describe("Maximum results to return (default 5, max 20).")
+    }),
+    handler: async ({ query, max_results }) => {
+      const maxResults = max_results ?? defaultMaxResults;
+      try {
+        const results = await search(query, maxResults);
+        return JSON.stringify({
+          ok: true,
+          results: results.slice(0, maxResults),
+          count: Math.min(results.length, maxResults)
+        });
+      } catch (err) {
+        const e = err;
+        return JSON.stringify({
+          ok: false,
+          error: "search_failed",
+          message: e.message ?? "unknown"
+        });
+      }
+    }
+  });
+}
+var BINARY_PROBE_BYTES3 = 8 * 1024;
+function createWriteFileTool(opts) {
+  const { projectRoot } = opts;
+  return sdk.defineTool({
+    name: "write_file",
+    description: "Write UTF-8 content to a project-relative file. Creates parent directories recursively. Refuses paths that escape the project root, sensitive files (.env, .git/, node_modules/, .theo/, lock files), and binary-file overwrites. Returns { ok, path, bytes } or { ok: false, error }.",
+    inputSchema: zod.z.object({
+      path: zod.z.string().min(1).describe("Project-relative file path."),
+      content: zod.z.string().describe("UTF-8 content to write.")
+    }),
+    handler: async ({ path: path$1, content }) => {
+      if (isForbiddenPath(path$1)) {
+        return JSON.stringify({ ok: false, error: "forbidden_path", path: path$1 });
+      }
+      let absolutePath;
+      try {
+        absolutePath = safePathJoin(projectRoot, path$1);
+        assertNoSymlinkEscape(absolutePath, projectRoot);
+      } catch (err) {
+        if (err instanceof PathTraversalError || err instanceof ForbiddenPathError) {
+          return JSON.stringify({ ok: false, error: "path_traversal", path: path$1 });
+        }
+        throw err;
+      }
+      if (await isBinaryFile(absolutePath)) {
+        return JSON.stringify({ ok: false, error: "binary_file", path: path$1 });
+      }
+      await promises.mkdir(path.dirname(absolutePath), { recursive: true });
+      await promises.writeFile(absolutePath, content, "utf-8");
+      const bytes = Buffer.byteLength(content, "utf-8");
+      return JSON.stringify({ ok: true, path: path$1, bytes });
+    }
+  });
+}
+async function isBinaryFile(absolutePath) {
+  let handle;
+  try {
+    handle = await promises.open(absolutePath, "r");
+  } catch {
+    return false;
+  }
+  try {
+    const stat = await handle.stat();
+    const probeLen = Math.min(BINARY_PROBE_BYTES3, Number(stat.size));
+    if (probeLen <= 0) return false;
+    const probe = Buffer.alloc(probeLen);
+    const { bytesRead } = await handle.read(probe, 0, probeLen, 0);
+    for (let i = 0; i < bytesRead; i += 1) {
+      if (probe[i] === 0) return true;
+    }
+    return false;
+  } finally {
+    await handle.close();
+  }
+}
+
+exports.createApplyPatchTool = createApplyPatchTool;
+exports.createEditFileTool = createEditFileTool;
+exports.createGitDiffTool = createGitDiffTool;
+exports.createGlobTool = createGlobTool;
+exports.createListDirTool = createListDirTool;
+exports.createPlanModeTool = createPlanModeTool;
+exports.createQuestionTool = createQuestionTool;
+exports.createReadFileTool = createReadFileTool;
+exports.createRunVitestTool = createRunVitestTool;
+exports.createSearchTextTool = createSearchTextTool;
+exports.createShellTool = createShellTool;
+exports.createTodolistTool = createTodolistTool;
+exports.createWebFetchTool = createWebFetchTool;
+exports.createWebSearchTool = createWebSearchTool;
+exports.createWriteFileTool = createWriteFileTool;
+exports.formatCode = formatCode;
+exports.formatDiff = formatDiff;
+exports.formatError = formatError;
+exports.formatFileList = formatFileList;
+exports.truncateOutput = truncateOutput;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map