workermill 0.1.0

package/dist/chunk-3KIFXIBC.js

@@ -0,0 +1,1906 @@
+// src/config.js
+import fs from "fs";
+import path from "path";
+import os from "os";
+var CONFIG_DIR = path.join(os.homedir(), ".workermill");
+var CONFIG_FILE = path.join(CONFIG_DIR, "cli.json");
+function loadConfig() {
+  try {
+    if (!fs.existsSync(CONFIG_FILE))
+      return null;
+    const raw = fs.readFileSync(CONFIG_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function saveConfig(config) {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+function getProviderForPersona(config, persona) {
+  const providerName = persona && config.routing?.[persona] || config.default;
+  const providerConfig = config.providers[providerName];
+  if (!providerConfig) {
+    throw new Error(`Provider "${providerName}" not found in configuration.`);
+  }
+  return {
+    provider: providerName,
+    model: providerConfig.model,
+    apiKey: providerConfig.apiKey?.startsWith("{env:") ? process.env[providerConfig.apiKey.slice(5, -1)] || void 0 : providerConfig.apiKey,
+    host: providerConfig.host
+  };
+}
+
+// ../packages/engine/src/model-factory.js
+import { anthropic } from "@ai-sdk/anthropic";
+import { openai } from "@ai-sdk/openai";
+import { google } from "@ai-sdk/google";
+import { createOllama } from "ollama-ai-provider-v2";
+function createModel(provider, modelName, ollamaHost) {
+  switch (provider) {
+    case "anthropic":
+      return anthropic(modelName);
+    case "openai":
+      return openai(modelName);
+    case "google":
+    case "gemini":
+      return google(modelName);
+    case "ollama": {
+      const host = ollamaHost || "http://localhost:11434";
+      const ollamaProvider = createOllama({ baseURL: `${host}/api` });
+      return ollamaProvider(modelName);
+    }
+    default:
+      throw new Error(`Unsupported provider: ${provider}`);
+  }
+}
+
+// ../packages/engine/src/tools/index.js
+import { tool } from "ai";
+import { z } from "zod";
+import path9 from "path";
+
+// ../packages/engine/src/tools/bash.js
+import { spawn } from "child_process";
+var activeChild = null;
+function killActiveProcess() {
+  if (activeChild?.pid) {
+    try {
+      process.kill(-activeChild.pid, "SIGTERM");
+      setTimeout(() => {
+        try {
+          if (activeChild?.pid)
+            process.kill(-activeChild.pid, "SIGKILL");
+        } catch {
+        }
+      }, 3e3);
+    } catch {
+    }
+  }
+}
+var description = "Execute a bash command and return the output. Use for running shell commands, git operations, npm commands, etc.";
+var LONG_RUNNING_PATTERNS = [
+  /\bnpm\s+(?:run\s+)?(?:dev|start|serve)\b/,
+  /\bnpx\s+(?:next|vite|webpack-dev-server|react-scripts\s+start)\b/,
+  /\bnodemon\b/,
+  /\btsc\s+--watch\b/,
+  /\bwebpack\s+serve\b/,
+  /\byarn\s+(?:dev|start|serve)\b/,
+  /\bpnpm\s+(?:dev|start|serve)\b/,
+  /\bpython\s+-m\s+(?:http\.server|flask\s+run|uvicorn|gunicorn)\b/,
+  /\brails\s+server\b/,
+  /\bphp\s+-S\b/,
+  /\bdocker\s+compose\s+up(?!\s+--build\b.*--exit)/
+];
+function isLongRunning(command) {
+  for (const pattern of LONG_RUNNING_PATTERNS) {
+    if (pattern.test(command)) {
+      const match = command.match(pattern);
+      return match ? match[0] : "long-running process";
+    }
+  }
+  return null;
+}
+async function execute({ command, cwd, timeout = 12e4 }) {
+  const longRunning = isLongRunning(command);
+  if (longRunning) {
+    return {
+      success: false,
+      exitCode: -1,
+      stdout: "",
+      stderr: "",
+      error: `Blocked: "${longRunning}" is a long-running process that would block execution. Use a one-shot command instead (e.g., "npx tsc --noEmit" to check compilation, "npm test" to run tests).`,
+      duration: 0
+    };
+  }
+  return new Promise((resolve) => {
+    const startTime = Date.now();
+    let stdout = "";
+    let stderr = "";
+    let killed = false;
+    const child = spawn("/bin/bash", ["-c", command], {
+      cwd: cwd || process.cwd(),
+      env: {
+        ...process.env,
+        PATH: "/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin"
+      },
+      stdio: ["pipe", "pipe", "pipe"],
+      detached: true
+    });
+    activeChild = child;
+    const timeoutId = setTimeout(() => {
+      killed = true;
+      try {
+        process.kill(-child.pid, "SIGTERM");
+      } catch {
+      }
+      setTimeout(() => {
+        try {
+          process.kill(-child.pid, "SIGKILL");
+        } catch {
+        }
+      }, 5e3);
+    }, timeout);
+    child.stdout.on("data", (data) => {
+      stdout += data.toString();
+      if (stdout.length > 1024 * 1024) {
+        stdout = stdout.slice(0, 1024 * 1024) + "\n... [output truncated]";
+      }
+    });
+    child.stderr.on("data", (data) => {
+      stderr += data.toString();
+      if (stderr.length > 1024 * 1024) {
+        stderr = stderr.slice(0, 1024 * 1024) + "\n... [output truncated]";
+      }
+    });
+    child.on("close", (code) => {
+      clearTimeout(timeoutId);
+      activeChild = null;
+      const duration = Date.now() - startTime;
+      if (killed) {
+        resolve({
+          success: false,
+          exitCode: code,
+          stdout: stdout.trim(),
+          stderr: stderr.trim(),
+          error: `Command timed out after ${timeout}ms`,
+          duration
+        });
+      } else if (code === 0) {
+        resolve({
+          success: true,
+          exitCode: 0,
+          stdout: stdout.trim(),
+          stderr: stderr.trim(),
+          duration
+        });
+      } else {
+        resolve({
+          success: false,
+          exitCode: code,
+          stdout: stdout.trim(),
+          stderr: stderr.trim(),
+          error: `Command exited with code ${code}`,
+          duration
+        });
+      }
+    });
+    child.on("error", (err) => {
+      clearTimeout(timeoutId);
+      activeChild = null;
+      const duration = Date.now() - startTime;
+      resolve({
+        success: false,
+        exitCode: -1,
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+        error: `Failed to execute command: ${err.message}`,
+        duration
+      });
+    });
+  });
+}
+
+// ../packages/engine/src/tools/read-file.js
+import fs2 from "fs";
+import path2 from "path";
+var description2 = "Read the contents of a file. Returns the file content as a string. Supports text files of any type.";
+async function execute2({ path: filePath, encoding = "utf8", maxLines, startLine }) {
+  try {
+    const absolutePath = path2.isAbsolute(filePath) ? filePath : path2.resolve(process.cwd(), filePath);
+    if (!fs2.existsSync(absolutePath)) {
+      return {
+        success: false,
+        error: `File not found: ${absolutePath}`
+      };
+    }
+    const stats = fs2.statSync(absolutePath);
+    if (stats.isDirectory()) {
+      return {
+        success: false,
+        error: `Path is a directory, not a file: ${absolutePath}`
+      };
+    }
+    const maxSize = 10 * 1024 * 1024;
+    if (stats.size > maxSize) {
+      return {
+        success: false,
+        error: `File is too large (${(stats.size / 1024 / 1024).toFixed(2)}MB). Max size: 10MB. Use maxLines parameter to read partial content.`
+      };
+    }
+    let content = fs2.readFileSync(absolutePath, encoding);
+    if (startLine !== void 0 || maxLines !== void 0) {
+      const lines = content.split("\n");
+      const start = (startLine || 1) - 1;
+      const end = maxLines !== void 0 ? start + maxLines : lines.length;
+      content = lines.slice(start, end).join("\n");
+      return {
+        success: true,
+        content,
+        path: absolutePath,
+        totalLines: lines.length,
+        linesReturned: Math.min(end - start, lines.length - start),
+        startLine: start + 1,
+        endLine: Math.min(end, lines.length)
+      };
+    }
+    return {
+      success: true,
+      content,
+      path: absolutePath,
+      size: stats.size
+    };
+  } catch (err) {
+    return {
+      success: false,
+      error: `Failed to read file: ${err.message}`
+    };
+  }
+}
+
+// ../packages/engine/src/tools/write-file.js
+import fs3 from "fs";
+import path3 from "path";
+var description3 = "Write content to a file. Creates the file if it does not exist, and creates any necessary parent directories. Overwrites existing content.";
+async function execute3({ path: filePath, content, encoding = "utf8", append = false }) {
+  try {
+    const absolutePath = path3.isAbsolute(filePath) ? filePath : path3.resolve(process.cwd(), filePath);
+    const dirPath = path3.dirname(absolutePath);
+    if (!fs3.existsSync(dirPath)) {
+      fs3.mkdirSync(dirPath, { recursive: true });
+    }
+    if (fs3.existsSync(absolutePath)) {
+      const stats2 = fs3.statSync(absolutePath);
+      if (stats2.isDirectory()) {
+        return {
+          success: false,
+          error: `Path is a directory, cannot write as file: ${absolutePath}`
+        };
+      }
+    }
+    if (append) {
+      fs3.appendFileSync(absolutePath, content, encoding);
+    } else {
+      fs3.writeFileSync(absolutePath, content, encoding);
+    }
+    const stats = fs3.statSync(absolutePath);
+    return {
+      success: true,
+      path: absolutePath,
+      size: stats.size,
+      action: append ? "appended" : "written",
+      linesWritten: content.split("\n").length
+    };
+  } catch (err) {
+    return {
+      success: false,
+      error: `Failed to write file: ${err.message}`
+    };
+  }
+}
+
+// ../packages/engine/src/tools/edit-file.js
+import fs4 from "fs";
+import path4 from "path";
+var description4 = "Edit a file by finding and replacing text. The old_string must be unique in the file (or use replaceAll for multiple occurrences). Use this instead of write_file when making targeted changes to existing files.";
+async function execute4({ path: filePath, old_string, new_string, replaceAll = false }) {
+  try {
+    const absolutePath = path4.isAbsolute(filePath) ? filePath : path4.resolve(process.cwd(), filePath);
+    if (!fs4.existsSync(absolutePath)) {
+      return {
+        success: false,
+        error: `File not found: ${absolutePath}`
+      };
+    }
+    const stats = fs4.statSync(absolutePath);
+    if (stats.isDirectory()) {
+      return {
+        success: false,
+        error: `Path is a directory, not a file: ${absolutePath}`
+      };
+    }
+    const content = fs4.readFileSync(absolutePath, "utf8");
+    if (!content.includes(old_string)) {
+      const lines = content.split("\n");
+      const preview = lines.slice(0, 20).map((l, i) => `${i + 1}: ${l}`).join("\n");
+      return {
+        success: false,
+        error: `old_string not found in file. Make sure it matches exactly including whitespace and indentation.`,
+        hint: "Use read_file first to see the exact content.",
+        filePreview: preview.length < 2e3 ? preview : preview.slice(0, 2e3) + "\n... [truncated]"
+      };
+    }
+    const occurrences = content.split(old_string).length - 1;
+    if (!replaceAll && occurrences > 1) {
+      return {
+        success: false,
+        error: `old_string found ${occurrences} times in file. Either provide more context to make it unique, or set replaceAll: true.`,
+        occurrences
+      };
+    }
+    let newContent;
+    if (replaceAll) {
+      newContent = content.split(old_string).join(new_string);
+    } else {
+      newContent = content.replace(old_string, new_string);
+    }
+    if (content === newContent) {
+      return {
+        success: false,
+        error: "No changes made. old_string and new_string may be identical."
+      };
+    }
+    fs4.writeFileSync(absolutePath, newContent, "utf8");
+    const oldLines = content.split("\n").length;
+    const newLines = newContent.split("\n").length;
+    const linesDiff = newLines - oldLines;
+    return {
+      success: true,
+      path: absolutePath,
+      replacements: replaceAll ? occurrences : 1,
+      linesBefore: oldLines,
+      linesAfter: newLines,
+      linesDiff: linesDiff > 0 ? `+${linesDiff}` : linesDiff.toString()
+    };
+  } catch (err) {
+    return {
+      success: false,
+      error: `Failed to edit file: ${err.message}`
+    };
+  }
+}
+
+// ../packages/engine/src/tools/glob.js
+import fs5 from "fs";
+import path5 from "path";
+function globToRegex(pattern) {
+  let regex = "";
+  let i = 0;
+  const len = pattern.length;
+  while (i < len) {
+    const c = pattern[i];
+    if (c === "*") {
+      if (pattern[i + 1] === "*") {
+        if (pattern[i + 2] === "/" || pattern[i + 2] === void 0) {
+          regex += "(?:[^/]*(?:/[^/]*)*)";
+          i += pattern[i + 2] === "/" ? 3 : 2;
+          continue;
+        }
+      }
+      regex += "[^/]*";
+      i++;
+    } else if (c === "?") {
+      regex += "[^/]";
+      i++;
+    } else if (c === "[") {
+      let j = i + 1;
+      let classContent = "";
+      if (pattern[j] === "!") {
+        classContent += "^";
+        j++;
+      }
+      while (j < len && pattern[j] !== "]") {
+        classContent += pattern[j];
+        j++;
+      }
+      regex += `[${classContent}]`;
+      i = j + 1;
+    } else if (c === "{") {
+      let j = i + 1;
+      const options = [];
+      let current = "";
+      while (j < len && pattern[j] !== "}") {
+        if (pattern[j] === ",") {
+          options.push(current);
+          current = "";
+        } else {
+          current += pattern[j];
+        }
+        j++;
+      }
+      options.push(current);
+      regex += `(?:${options.map((o) => o.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|")})`;
+      i = j + 1;
+    } else if (c === "/" || c === "\\") {
+      regex += "[/\\\\]";
+      i++;
+    } else if (".+^${}()|[]\\".includes(c)) {
+      regex += "\\" + c;
+      i++;
+    } else {
+      regex += c;
+      i++;
+    }
+  }
+  return new RegExp(`^${regex}$`);
+}
+function walkDir(dir, files = [], maxDepth = 20, currentDepth = 0) {
+  if (currentDepth > maxDepth)
+    return files;
+  try {
+    const entries = fs5.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") && entry.name !== ".")
+        continue;
+      if (entry.name === "node_modules")
+        continue;
+      if (entry.name === "__pycache__")
+        continue;
+      if (entry.name === ".git")
+        continue;
+      const fullPath = path5.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walkDir(fullPath, files, maxDepth, currentDepth + 1);
+      } else if (entry.isFile()) {
+        files.push(fullPath);
+      }
+    }
+  } catch (_err) {
+  }
+  return files;
+}
+var description5 = 'Find files matching a glob pattern. Supports patterns like "**/*.ts", "src/**/*.js", "*.{ts,tsx}". Excludes node_modules and hidden files by default.';
+async function execute5({ pattern, cwd, maxResults = 1e3, includeHidden = false }) {
+  try {
+    const searchDir = cwd ? path5.isAbsolute(cwd) ? cwd : path5.resolve(process.cwd(), cwd) : process.cwd();
+    if (!fs5.existsSync(searchDir)) {
+      return {
+        success: false,
+        error: `Directory not found: ${searchDir}`
+      };
+    }
+    const allFiles = walkDir(searchDir);
+    const regex = globToRegex(pattern);
+    const matches = [];
+    for (const file of allFiles) {
+      const relativePath = path5.relative(searchDir, file).replace(/\\/g, "/");
+      if (!includeHidden && relativePath.split("/").some((part) => part.startsWith("."))) {
+        continue;
+      }
+      if (regex.test(relativePath)) {
+        matches.push({
+          path: file,
+          relativePath
+        });
+        if (matches.length >= maxResults) {
+          break;
+        }
+      }
+    }
+    matches.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+    return {
+      success: true,
+      pattern,
+      cwd: searchDir,
+      matches: matches.map((m) => m.relativePath),
+      absolutePaths: matches.map((m) => m.path),
+      count: matches.length,
+      truncated: matches.length >= maxResults
+    };
+  } catch (err) {
+    return {
+      success: false,
+      error: `Glob search failed: ${err.message}`
+    };
+  }
+}
+
+// ../packages/engine/src/tools/grep.js
+import fs6 from "fs";
+import path6 from "path";
+function walkDir2(dir, files = [], maxDepth = 20, currentDepth = 0) {
+  if (currentDepth > maxDepth)
+    return files;
+  try {
+    const entries = fs6.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name === "node_modules")
+        continue;
+      if (entry.name === "__pycache__")
+        continue;
+      if (entry.name === ".git")
+        continue;
+      if (entry.name === "dist")
+        continue;
+      if (entry.name === "build")
+        continue;
+      if (entry.name === ".next")
+        continue;
+      const fullPath = path6.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!entry.name.startsWith(".")) {
+          walkDir2(fullPath, files, maxDepth, currentDepth + 1);
+        }
+      } else if (entry.isFile()) {
+        const ext = path6.extname(entry.name).toLowerCase();
+        const binaryExts = [
+          ".png",
+          ".jpg",
+          ".jpeg",
+          ".gif",
+          ".ico",
+          ".pdf",
+          ".zip",
+          ".tar",
+          ".gz",
+          ".exe",
+          ".dll",
+          ".so",
+          ".dylib",
+          ".woff",
+          ".woff2",
+          ".ttf",
+          ".eot"
+        ];
+        if (!binaryExts.includes(ext)) {
+          files.push(fullPath);
+        }
+      }
+    }
+  } catch (_err) {
+  }
+  return files;
+}
+function searchFile(filePath, regex, contextLines = 0) {
+  try {
+    const content = fs6.readFileSync(filePath, "utf8");
+    const lines = content.split("\n");
+    const matches = [];
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (regex.test(line)) {
+        const match = {
+          line: i + 1,
+          content: line.trim(),
+          fullLine: line
+        };
+        if (contextLines > 0) {
+          const beforeStart = Math.max(0, i - contextLines);
+          const afterEnd = Math.min(lines.length - 1, i + contextLines);
+          match.before = lines.slice(beforeStart, i).map((l, idx) => ({
+            line: beforeStart + idx + 1,
+            content: l
+          }));
+          match.after = lines.slice(i + 1, afterEnd + 1).map((l, idx) => ({
+            line: i + 2 + idx,
+            content: l
+          }));
+        }
+        matches.push(match);
+      }
+    }
+    return matches;
+  } catch (_err) {
+    return [];
+  }
+}
+var description6 = "Search for a pattern in files. Uses regex pattern matching. Returns matching lines with file paths and line numbers.";
+async function execute6({ pattern, path: searchPath, filePattern, ignoreCase = false, contextLines = 0, maxResults = 100 }) {
+  try {
+    let regex;
+    try {
+      regex = new RegExp(pattern, ignoreCase ? "gi" : "g");
+    } catch (err) {
+      return {
+        success: false,
+        error: `Invalid regex pattern: ${err.message}`
+      };
+    }
+    const targetPath = searchPath ? path6.isAbsolute(searchPath) ? searchPath : path6.resolve(process.cwd(), searchPath) : process.cwd();
+    if (!fs6.existsSync(targetPath)) {
+      return {
+        success: false,
+        error: `Path not found: ${targetPath}`
+      };
+    }
+    const stats = fs6.statSync(targetPath);
+    let filesToSearch = [];
+    if (stats.isFile()) {
+      filesToSearch = [targetPath];
+    } else if (stats.isDirectory()) {
+      filesToSearch = walkDir2(targetPath);
+    }
+    if (filePattern) {
+      const ext = filePattern.replace("*", "");
+      filesToSearch = filesToSearch.filter((f) => f.endsWith(ext));
+    }
+    const results = [];
+    let totalMatches = 0;
+    for (const file of filesToSearch) {
+      if (totalMatches >= maxResults)
+        break;
+      const matches = searchFile(file, regex, contextLines);
+      if (matches.length > 0) {
+        const relativePath = path6.relative(targetPath, file).replace(/\\/g, "/") || path6.basename(file);
+        for (const match of matches) {
+          if (totalMatches >= maxResults)
+            break;
+          results.push({
+            file: relativePath,
+            absolutePath: file,
+            line: match.line,
+            content: match.content,
+            ...contextLines > 0 ? { before: match.before, after: match.after } : {}
+          });
+          totalMatches++;
+        }
+      }
+    }
+    const byFile = {};
+    for (const result of results) {
+      if (!byFile[result.file]) {
+        byFile[result.file] = [];
+      }
+      byFile[result.file].push({
+        line: result.line,
+        content: result.content,
+        ...result.before ? { before: result.before } : {},
+        ...result.after ? { after: result.after } : {}
+      });
+    }
+    return {
+      success: true,
+      pattern,
+      searchPath: targetPath,
+      matchCount: totalMatches,
+      fileCount: Object.keys(byFile).length,
+      truncated: totalMatches >= maxResults,
+      results: byFile
+    };
+  } catch (err) {
+    return {
+      success: false,
+      error: `Grep search failed: ${err.message}`
+    };
+  }
+}
+
+// ../packages/engine/src/tools/ls.js
+import fs7 from "fs";
+import path7 from "path";
+var description7 = "List directory contents in a tree format. Shows file names, types, and sizes. More efficient than bash ls \u2014 no subprocess needed, returns structured output.";
+var DEFAULT_IGNORE = ["node_modules", ".git", "__pycache__", ".next", ".nuxt"];
+function shouldIgnore(name, ignorePatterns) {
+  return ignorePatterns.some((pattern) => {
+    if (pattern.startsWith("*.")) {
+      return name.endsWith(pattern.slice(1));
+    }
+    return name === pattern;
+  });
+}
+function buildTree(dirPath, prefix, depth, maxDepth, ignorePatterns, state) {
+  if (depth > maxDepth || state.files + state.dirs >= state.maxFiles) {
+    if (depth > maxDepth) {
+      state.lines.push(`${prefix}... (max depth reached)`);
+    }
+    return;
+  }
+  let entries;
+  try {
+    entries = fs7.readdirSync(dirPath, { withFileTypes: true });
+  } catch {
+    state.lines.push(`${prefix}[permission denied]`);
+    return;
+  }
+  entries.sort((a, b) => {
+    if (a.isDirectory() && !b.isDirectory())
+      return -1;
+    if (!a.isDirectory() && b.isDirectory())
+      return 1;
+    return a.name.localeCompare(b.name);
+  });
+  entries = entries.filter((e) => !shouldIgnore(e.name, ignorePatterns));
+  for (let i = 0; i < entries.length; i++) {
+    if (state.files + state.dirs >= state.maxFiles) {
+      state.lines.push(`${prefix}... (${state.maxFiles} entries limit reached)`);
+      return;
+    }
+    const entry = entries[i];
+    const isLast = i === entries.length - 1;
+    const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    const childPrefix = isLast ? "    " : "\u2502   ";
+    const fullPath = path7.join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      state.dirs++;
+      state.lines.push(`${prefix}${connector}${entry.name}/`);
+      buildTree(fullPath, prefix + childPrefix, depth + 1, maxDepth, ignorePatterns, state);
+    } else {
+      state.files++;
+      let size = "";
+      try {
+        const stat = fs7.statSync(fullPath);
+        if (stat.size < 1024)
+          size = ` (${stat.size}B)`;
+        else if (stat.size < 1024 * 1024)
+          size = ` (${(stat.size / 1024).toFixed(1)}KB)`;
+        else
+          size = ` (${(stat.size / (1024 * 1024)).toFixed(1)}MB)`;
+      } catch {
+      }
+      state.lines.push(`${prefix}${connector}${entry.name}${size}`);
+    }
+  }
+}
+async function execute7({ path: dirPath, ignore, maxDepth = 3, maxFiles = 1e3 }) {
+  try {
+    if (!fs7.existsSync(dirPath)) {
+      return { success: false, tree: "", totalFiles: 0, totalDirs: 0, truncated: false, error: `Directory not found: ${dirPath}` };
+    }
+    const stat = fs7.statSync(dirPath);
+    if (!stat.isDirectory()) {
+      return { success: false, tree: "", totalFiles: 0, totalDirs: 0, truncated: false, error: `Not a directory: ${dirPath}` };
+    }
+    const ignorePatterns = ignore ? [...DEFAULT_IGNORE, ...ignore] : DEFAULT_IGNORE;
+    const state = { files: 0, dirs: 0, lines: [], maxFiles };
+    state.lines.push(dirPath);
+    buildTree(dirPath, "", 0, maxDepth, ignorePatterns, state);
+    const truncated = state.files + state.dirs >= maxFiles;
+    return { success: true, tree: state.lines.join("\n"), totalFiles: state.files, totalDirs: state.dirs, truncated };
+  } catch (err) {
+    return { success: false, tree: "", totalFiles: 0, totalDirs: 0, truncated: false, error: `Failed to list directory: ${err instanceof Error ? err.message : String(err)}` };
+  }
+}
+
+// ../packages/engine/src/tools/fetch.js
+var description8 = "Fetch content from a URL and return it as text or markdown. Useful for reading documentation, API references, error pages, and other web content.";
+function htmlToText(html) {
+  return html.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "").replace(/<\/?(p|div|br|h[1-6]|li|tr|blockquote|pre|hr)[^>]*>/gi, "\n").replace(/<[^>]+>/g, "").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&nbsp;/g, " ").replace(/\n{3,}/g, "\n\n").trim();
+}
+function htmlToMarkdown(html) {
+  return html.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "").replace(/<h1[^>]*>([\s\S]*?)<\/h1>/gi, "# $1\n\n").replace(/<h2[^>]*>([\s\S]*?)<\/h2>/gi, "## $1\n\n").replace(/<h3[^>]*>([\s\S]*?)<\/h3>/gi, "### $1\n\n").replace(/<h4[^>]*>([\s\S]*?)<\/h4>/gi, "#### $1\n\n").replace(/<h5[^>]*>([\s\S]*?)<\/h5>/gi, "##### $1\n\n").replace(/<h6[^>]*>([\s\S]*?)<\/h6>/gi, "###### $1\n\n").replace(/<(strong|b)[^>]*>([\s\S]*?)<\/(strong|b)>/gi, "**$2**").replace(/<(em|i)[^>]*>([\s\S]*?)<\/(em|i)>/gi, "*$2*").replace(/<code[^>]*>([\s\S]*?)<\/code>/gi, "`$1`").replace(/<pre[^>]*>([\s\S]*?)<\/pre>/gi, "```\n$1\n```\n\n").replace(/<a[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/gi, "[$2]($1)").replace(/<li[^>]*>([\s\S]*?)<\/li>/gi, "- $1\n").replace(/<\/p>/gi, "\n\n").replace(/<br\s*\/?>/gi, "\n").replace(/<hr\s*\/?>/gi, "\n---\n\n").replace(/<[^>]+>/g, "").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&nbsp;/g, " ").replace(/\n{3,}/g, "\n\n").trim();
+}
+var MAX_CONTENT_SIZE = 512 * 1024;
+async function execute8({ url, format = "markdown", timeout = 3e4 }) {
+  try {
+    let parsedUrl;
+    try {
+      parsedUrl = new URL(url);
+    } catch {
+      return { success: false, content: "", url, error: `Invalid URL: ${url}` };
+    }
+    if (!["http:", "https:"].includes(parsedUrl.protocol)) {
+      return { success: false, content: "", url, error: `Unsupported protocol: ${parsedUrl.protocol}. Only http and https are allowed.` };
+    }
+    const clampedTimeout = Math.min(timeout, 12e4);
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), clampedTimeout);
+    try {
+      const response = await globalThis.fetch(url, {
+        signal: controller.signal,
+        headers: {
+          "User-Agent": "WorkerMill/1.0",
+          Accept: "text/html,application/xhtml+xml,text/plain,*/*"
+        }
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        return { success: false, content: "", url, statusCode: response.status, error: `HTTP ${response.status}: ${response.statusText}` };
+      }
+      const contentType = response.headers.get("content-type") || "";
+      let body = await response.text();
+      if (body.length > MAX_CONTENT_SIZE) {
+        body = body.slice(0, MAX_CONTENT_SIZE) + "\n\n... [content truncated at 512KB]";
+      }
+      let content;
+      if (contentType.includes("text/html") || contentType.includes("xhtml")) {
+        if (format === "text") {
+          content = htmlToText(body);
+        } else if (format === "markdown") {
+          content = htmlToMarkdown(body);
+        } else {
+          content = body;
+        }
+      } else {
+        content = body;
+      }
+      return { success: true, content, url, statusCode: response.status, contentType };
+    } catch (err) {
+      clearTimeout(timeoutId);
+      if (err instanceof Error && err.name === "AbortError") {
+        return { success: false, content: "", url, error: `Request timed out after ${clampedTimeout}ms` };
+      }
+      throw err;
+    }
+  } catch (err) {
+    return { success: false, content: "", url, error: `Fetch failed: ${err instanceof Error ? err.message : String(err)}` };
+  }
+}
+
+// ../packages/engine/src/tools/patch.js
+import fs8 from "fs";
+import path8 from "path";
+var description9 = "Apply a unified diff patch to one or more files atomically. All hunks are validated before any changes are written. If any hunk fails to apply, no files are modified. Use standard unified diff format (output of `git diff` or `diff -u`).";
+function parsePatch(patchText) {
+  const patches = [];
+  const lines = patchText.split("\n");
+  let i = 0;
+  while (i < lines.length) {
+    if (!lines[i].startsWith("--- ")) {
+      i++;
+      continue;
+    }
+    const oldFile = lines[i].replace(/^--- (a\/)?/, "").replace(/\t.*$/, "");
+    i++;
+    if (i >= lines.length || !lines[i].startsWith("+++ ")) {
+      continue;
+    }
+    const newFile = lines[i].replace(/^\+\+\+ (b\/)?/, "").replace(/\t.*$/, "");
+    i++;
+    const isNew = oldFile === "/dev/null";
+    const isDelete = newFile === "/dev/null";
+    const filePatch = {
+      oldFile: isNew ? newFile : oldFile,
+      newFile: isDelete ? oldFile : newFile,
+      hunks: [],
+      isNew,
+      isDelete
+    };
+    while (i < lines.length && lines[i].startsWith("@@")) {
+      const match = lines[i].match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+      if (!match) {
+        i++;
+        continue;
+      }
+      const hunk = {
+        oldStart: parseInt(match[1], 10),
+        oldCount: match[2] !== void 0 ? parseInt(match[2], 10) : 1,
+        newStart: parseInt(match[3], 10),
+        newCount: match[4] !== void 0 ? parseInt(match[4], 10) : 1,
+        lines: []
+      };
+      i++;
+      while (i < lines.length) {
+        const line = lines[i];
+        if (line.startsWith("@@") || line.startsWith("--- ") || line.startsWith("diff ")) {
+          break;
+        }
+        if (line.startsWith("+")) {
+          hunk.lines.push({ type: "add", content: line.slice(1) });
+        } else if (line.startsWith("-")) {
+          hunk.lines.push({ type: "remove", content: line.slice(1) });
+        } else if (line.startsWith(" ") || line === "") {
+          hunk.lines.push({
+            type: "context",
+            content: line.startsWith(" ") ? line.slice(1) : line
+          });
+        }
+        i++;
+      }
+      filePatch.hunks.push(hunk);
+    }
+    if (filePatch.hunks.length > 0) {
+      patches.push(filePatch);
+    }
+  }
+  return patches;
+}
+function applyHunks(originalContent, hunks) {
+  const originalLines = originalContent.split("\n");
+  if (originalLines[originalLines.length - 1] === "" && originalContent.endsWith("\n")) {
+    originalLines.pop();
+  }
+  let offset = 0;
+  const resultLines = [...originalLines];
+  for (const hunk of hunks) {
+    const startLine = hunk.oldStart - 1 + offset;
+    let lineIdx = startLine;
+    for (const hunkLine of hunk.lines) {
+      if (hunkLine.type === "context" || hunkLine.type === "remove") {
+        if (lineIdx >= resultLines.length || resultLines[lineIdx] !== hunkLine.content) {
+          return null;
+        }
+        lineIdx++;
+      }
+    }
+    const newLines = [];
+    for (const hunkLine of hunk.lines) {
+      if (hunkLine.type === "context") {
+        newLines.push(hunkLine.content);
+      } else if (hunkLine.type === "add") {
+        newLines.push(hunkLine.content);
+      }
+    }
+    resultLines.splice(startLine, hunk.oldCount, ...newLines);
+    offset += newLines.length - hunk.oldCount;
+  }
+  return resultLines.join("\n") + "\n";
+}
+async function execute9({ patch_text }) {
+  try {
+    const patches = parsePatch(patch_text);
+    if (patches.length === 0) {
+      return {
+        success: false,
+        filesModified: [],
+        filesCreated: [],
+        filesDeleted: [],
+        error: "No valid patches found in input",
+        hint: "Ensure the patch uses unified diff format with --- and +++ headers and @@ hunk markers."
+      };
+    }
+    const pendingWrites = /* @__PURE__ */ new Map();
+    const pendingDeletes = [];
+    const errors = [];
+    for (const filePatch of patches) {
+      const targetFile = filePatch.newFile;
+      if (filePatch.isNew) {
+        const content = filePatch.hunks.flatMap((h) => h.lines.filter((l) => l.type === "add").map((l) => l.content)).join("\n") + "\n";
+        pendingWrites.set(targetFile, content);
+        continue;
+      }
+      if (filePatch.isDelete) {
+        if (!fs8.existsSync(filePatch.oldFile)) {
+          errors.push(`Cannot delete ${filePatch.oldFile}: file not found`);
+          continue;
+        }
+        pendingDeletes.push(filePatch.oldFile);
+        continue;
+      }
+      if (!fs8.existsSync(targetFile)) {
+        errors.push(`Cannot patch ${targetFile}: file not found`);
+        continue;
+      }
+      const originalContent = fs8.readFileSync(targetFile, "utf-8");
+      const result = applyHunks(originalContent, filePatch.hunks);
+      if (result === null) {
+        errors.push(`Patch for ${targetFile} failed: context lines do not match. The file may have been modified since the diff was generated.`);
+        continue;
+      }
+      pendingWrites.set(targetFile, result);
+    }
+    if (errors.length > 0) {
+      return {
+        success: false,
+        filesModified: [],
+        filesCreated: [],
+        filesDeleted: [],
+        error: `Patch validation failed:
+${errors.join("\n")}`,
+        hint: "All hunks must match the current file contents exactly. Regenerate the diff against the current file state."
+      };
+    }
+    const filesModified = [];
+    const filesCreated = [];
+    const filesDeleted = [];
+    for (const [filePath, content] of pendingWrites) {
+      const dir = path8.dirname(filePath);
+      if (!fs8.existsSync(dir)) {
+        fs8.mkdirSync(dir, { recursive: true });
+      }
+      const isNew = !fs8.existsSync(filePath);
+      fs8.writeFileSync(filePath, content, "utf-8");
+      if (isNew) {
+        filesCreated.push(filePath);
+      } else {
+        filesModified.push(filePath);
+      }
+    }
+    for (const filePath of pendingDeletes) {
+      fs8.unlinkSync(filePath);
+      filesDeleted.push(filePath);
+    }
+    return { success: true, filesModified, filesCreated, filesDeleted };
+  } catch (err) {
+    return {
+      success: false,
+      filesModified: [],
+      filesCreated: [],
+      filesDeleted: [],
+      error: `Patch failed: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
+
+// ../packages/engine/src/tools/sub-agent.js
+import { streamText, stepCountIs } from "ai";
+var description10 = "Spawn a read-only sub-agent to explore the codebase. The sub-agent can read files, search with glob/grep, and list directories, but cannot write files, edit, or run commands. Use this for parallel codebase exploration \u2014 understanding architecture, finding patterns, or researching how something works before making changes.";
+function createSubAgentExecutor(model, workingDir, readOnlyTools) {
+  return async function execute11({ prompt, maxTurns = 20 }) {
+    try {
+      let turnsUsed = 0;
+      const stream = streamText({
+        model,
+        system: "You are a codebase exploration agent. You can read files, search for patterns, and list directories to understand the codebase. You CANNOT modify any files. Provide a thorough, detailed answer to the task you are given. Include specific file paths, line numbers, and code snippets in your findings.",
+        prompt,
+        tools: readOnlyTools,
+        stopWhen: stepCountIs(maxTurns),
+        abortSignal: AbortSignal.timeout(5 * 60 * 1e3),
+        onStepFinish() {
+          turnsUsed++;
+        }
+      });
+      for await (const _chunk of stream.textStream) {
+      }
+      const text = await stream.text;
+      return {
+        success: true,
+        content: text,
+        turnsUsed
+      };
+    } catch (err) {
+      return {
+        success: false,
+        content: "",
+        turnsUsed: 0,
+        error: `Sub-agent failed: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+  };
+}
+
+// ../packages/engine/src/tools/git.js
+import { execSync } from "child_process";
+var description11 = "Execute git operations. Supports: status, diff, log, add, commit, branch, checkout, stash. Blocks destructive operations like force-push or reset --hard.";
+var BLOCKED_PATTERNS = [
+  /--force/,
+  /--hard/,
+  /push.*-f\b/,
+  /reset.*--hard/,
+  /clean\s+-[a-z]*f/,
+  /branch\s+-D\b/
+];
+async function execute10({ action, args, cwd }) {
+  const workDir = cwd || process.cwd();
+  const fullCmd = `${action} ${args || ""}`;
+  for (const pattern of BLOCKED_PATTERNS) {
+    if (pattern.test(fullCmd)) {
+      return { success: false, output: "", error: `Blocked: destructive git operation "${fullCmd}"` };
+    }
+  }
+  const cmdMap = {
+    status: `git status${args ? " " + args : " --short"}`,
+    diff: `git diff${args ? " " + args : ""}`,
+    log: `git log${args ? " " + args : " --oneline -20"}`,
+    add: `git add ${args || "."}`,
+    commit: `git commit -m "${(args || "").replace(/"/g, '\\"')}"`,
+    branch: `git branch${args ? " " + args : ""}`,
+    checkout: `git checkout ${args || ""}`,
+    stash: `git stash${args ? " " + args : ""}`
+  };
+  const cmd = cmdMap[action];
+  if (!cmd) {
+    return { success: false, output: "", error: `Unknown git action: ${action}` };
+  }
+  try {
+    const output = execSync(cmd, {
+      cwd: workDir,
+      encoding: "utf-8",
+      timeout: 3e4
+    });
+    return { success: true, output: output.trim() };
+  } catch (err) {
+    return {
+      success: false,
+      output: err.stdout?.trim() || "",
+      error: err.stderr?.trim() || err.message
+    };
+  }
+}
+
+// ../packages/engine/src/tools/index.js
+function assertPathInBounds(resolvedPath, workingDir, sandboxed) {
+  if (!sandboxed)
+    return resolvedPath;
+  const normalized = path9.resolve(resolvedPath);
+  const normalizedWorkDir = path9.resolve(workingDir);
+  if (!normalized.startsWith(normalizedWorkDir + path9.sep) && normalized !== normalizedWorkDir) {
+    throw new Error(`Path "${resolvedPath}" is outside the working directory. Use --full-disk to allow access outside ${workingDir}`);
+  }
+  return normalized;
+}
+function createToolDefinitions(workingDir, model, sandboxed = true) {
+  return {
+    bash: tool({
+      description,
+      inputSchema: z.object({
+        command: z.string().describe("The bash command to execute"),
+        cwd: z.string().optional().describe("Working directory for the command (optional)"),
+        timeout: z.number().optional().describe("Timeout in milliseconds (default: 120000 = 2 minutes)")
+      }),
+      execute: async ({ command, cwd, timeout }) => {
+        const resolvedCwd = cwd ? path9.isAbsolute(cwd) ? cwd : path9.resolve(workingDir, cwd) : workingDir;
+        assertPathInBounds(resolvedCwd, workingDir, sandboxed);
+        const result = await execute({
+          command,
+          cwd: resolvedCwd,
+          timeout
+        });
+        if (result.success) {
+          return result.stdout || "(no output)";
+        }
+        return `Error: ${result.error || result.stderr}
+${result.stdout || ""}`.trim();
+      }
+    }),
+    read_file: tool({
+      description: description2,
+      inputSchema: z.object({
+        path: z.string().describe("Path to the file to read (absolute or relative to cwd)"),
+        encoding: z.string().optional().describe("File encoding (default: utf8)"),
+        maxLines: z.number().optional().describe("Maximum number of lines to read (optional, reads entire file if not specified)"),
+        startLine: z.number().optional().describe("Line number to start reading from (1-indexed, optional)")
+      }),
+      execute: async ({ path: filePath, encoding, maxLines, startLine }) => {
+        const resolvedPath = path9.isAbsolute(filePath) ? filePath : path9.resolve(workingDir, filePath);
+        assertPathInBounds(resolvedPath, workingDir, sandboxed);
+        const result = await execute2({
+          path: resolvedPath,
+          encoding,
+          maxLines,
+          startLine
+        });
+        if (result.success) {
+          return result.content || "";
+        }
+        return `Error: ${result.error}`;
+      }
+    }),
+    write_file: tool({
+      description: description3,
+      inputSchema: z.object({
+        path: z.string().describe("Path to the file to write (absolute or relative to cwd)"),
+        content: z.string().describe("Content to write to the file"),
+        encoding: z.string().optional().describe("File encoding (default: utf8)"),
+        append: z.boolean().optional().describe("Append to file instead of overwriting (default: false)")
+      }),
+      execute: async ({ path: filePath, content, encoding, append }) => {
+        const resolvedPath = path9.isAbsolute(filePath) ? filePath : path9.resolve(workingDir, filePath);
+        assertPathInBounds(resolvedPath, workingDir, sandboxed);
+        const result = await execute3({
+          path: resolvedPath,
+          content,
+          encoding,
+          append
+        });
+        if (result.success) {
+          return `File ${result.action} successfully: ${result.path} (${result.linesWritten} lines, ${result.size} bytes)`;
+        }
+        return `Error: ${result.error}`;
+      }
+    }),
+    edit_file: tool({
+      description: description4,
+      inputSchema: z.object({
+        path: z.string().describe("Path to the file to edit (absolute or relative to cwd)"),
+        old_string: z.string().describe("The exact text to find and replace. Must match exactly including whitespace and indentation."),
+        new_string: z.string().describe("The text to replace old_string with. Can be empty string to delete."),
+        replaceAll: z.boolean().optional().describe("Replace all occurrences instead of requiring unique match (default: false)")
+      }),
+      execute: async ({ path: filePath, old_string, new_string, replaceAll }) => {
+        const resolvedPath = path9.isAbsolute(filePath) ? filePath : path9.resolve(workingDir, filePath);
+        assertPathInBounds(resolvedPath, workingDir, sandboxed);
+        const result = await execute4({
+          path: resolvedPath,
+          old_string,
+          new_string,
+          replaceAll
+        });
+        if (result.success) {
+          return `File edited: ${result.path} (${result.replacements} replacement(s), ${result.linesDiff} lines)`;
+        }
+        return `Error: ${result.error}${result.hint ? `
+Hint: ${result.hint}` : ""}`;
+      }
+    }),
+    glob: tool({
+      description: description5,
+      inputSchema: z.object({
+        pattern: z.string().describe('Glob pattern to match files (e.g., "**/*.ts", "src/**/*.js")'),
+        cwd: z.string().optional().describe("Directory to search in (default: current working directory)"),
+        maxResults: z.number().optional().describe("Maximum number of results to return (default: 1000)"),
+        includeHidden: z.boolean().optional().describe("Include hidden files (starting with .) (default: false)")
+      }),
+      execute: async ({ pattern, cwd, maxResults, includeHidden }) => {
+        const resolvedCwd = cwd ? path9.isAbsolute(cwd) ? cwd : path9.resolve(workingDir, cwd) : workingDir;
+        assertPathInBounds(resolvedCwd, workingDir, sandboxed);
+        const result = await execute5({
+          pattern,
+          cwd: resolvedCwd,
+          maxResults,
+          includeHidden
+        });
+        if (result.success) {
+          if (result.count === 0) {
+            return `No files found matching pattern: ${pattern}`;
+          }
+          return `Found ${result.count} file(s)${result.truncated ? " (truncated)" : ""}:
+${result.matches.join("\n")}`;
+        }
+        return `Error: ${result.error}`;
+      }
+    }),
+    grep: tool({
+      description: description6,
+      inputSchema: z.object({
+        pattern: z.string().describe("Regex pattern to search for"),
+        path: z.string().optional().describe("File or directory to search in (default: current directory)"),
+        filePattern: z.string().optional().describe('Glob pattern to filter files (e.g., "*.ts", "*.js")'),
+        ignoreCase: z.boolean().optional().describe("Case-insensitive search (default: false)"),
+        contextLines: z.number().optional().describe("Number of context lines before and after match (default: 0)"),
+        maxResults: z.number().optional().describe("Maximum number of total matches to return (default: 100)")
+      }),
+      execute: async ({ pattern, path: searchPath, filePattern, ignoreCase, contextLines, maxResults }) => {
+        const resolvedPath = searchPath ? path9.isAbsolute(searchPath) ? searchPath : path9.resolve(workingDir, searchPath) : workingDir;
+        assertPathInBounds(resolvedPath, workingDir, sandboxed);
+        const result = await execute6({
+          pattern,
+          path: resolvedPath,
+          filePattern,
+          ignoreCase,
+          contextLines,
+          maxResults
+        });
+        if (result.success) {
+          if (result.matchCount === 0) {
+            return `No matches found for pattern: ${pattern}`;
+          }
+          const lines = [
+            `Found ${result.matchCount} match(es) in ${result.fileCount} file(s)${result.truncated ? " (truncated)" : ""}:`
+          ];
+          for (const [file, matches] of Object.entries(result.results)) {
+            for (const match of matches) {
+              lines.push(`${file}:${match.line}: ${match.content}`);
+            }
+          }
+          return lines.join("\n");
+        }
+        return `Error: ${result.error}`;
+      }
+    }),
+    ls: tool({
+      description: description7,
+      inputSchema: z.object({
+        path: z.string().describe("Directory path to list (absolute or relative to cwd)"),
+        ignore: z.array(z.string()).optional().describe('Glob patterns to exclude (e.g., ["node_modules", "dist"])'),
+        maxDepth: z.number().optional().describe("Maximum directory depth to traverse (default: 3)"),
+        maxFiles: z.number().optional().describe("Maximum number of entries to return (default: 1000)")
+      }),
+      execute: async ({ path: dirPath, ignore, maxDepth, maxFiles }) => {
+        const resolvedPath = path9.isAbsolute(dirPath) ? dirPath : path9.resolve(workingDir, dirPath);
+        assertPathInBounds(resolvedPath, workingDir, sandboxed);
+        const result = await execute7({ path: resolvedPath, ignore, maxDepth, maxFiles });
+        if (result.success) {
+          return `${result.tree}
+
+${result.totalFiles} files, ${result.totalDirs} directories${result.truncated ? " (truncated)" : ""}`;
+        }
+        return `Error: ${result.error}`;
+      }
+    }),
+    fetch: tool({
+      description: description8,
+      inputSchema: z.object({
+        url: z.string().describe("The URL to fetch"),
+        format: z.enum(["text", "markdown", "html"]).optional().describe("Output format (default: markdown)"),
+        timeout: z.number().optional().describe("Timeout in milliseconds (default: 30000, max: 120000)")
+      }),
+      execute: async ({ url, format, timeout }) => {
+        const result = await execute8({ url, format, timeout });
+        if (result.success) {
+          return `Content from ${result.url} (${result.contentType || "unknown"}):
+
+${result.content}`;
+        }
+        return `Error: ${result.error}`;
+      }
+    }),
+    patch: tool({
+      description: description9,
+      inputSchema: z.object({
+        patch_text: z.string().describe("Unified diff patch text with --- and +++ headers and @@ hunk markers")
+      }),
+      execute: async ({ patch_text }) => {
+        const result = await execute9({ patch_text });
+        if (result.success) {
+          const parts = ["Patch applied successfully:"];
+          if (result.filesCreated.length > 0)
+            parts.push(`  Created: ${result.filesCreated.join(", ")}`);
+          if (result.filesModified.length > 0)
+            parts.push(`  Modified: ${result.filesModified.join(", ")}`);
+          if (result.filesDeleted.length > 0)
+            parts.push(`  Deleted: ${result.filesDeleted.join(", ")}`);
+          return parts.join("\n");
+        }
+        return `Error: ${result.error}${result.hint ? `
+Hint: ${result.hint}` : ""}`;
+      }
+    }),
+    git: tool({
+      description: description11,
+      inputSchema: z.object({
+        action: z.enum(["status", "diff", "log", "add", "commit", "branch", "checkout", "stash"]).describe("The git action to perform"),
+        args: z.string().optional().describe("Additional arguments (file paths, branch name, commit message)")
+      }),
+      execute: async ({ action, args }) => {
+        const result = await execute10({ action, args, cwd: workingDir });
+        if (result.success) {
+          return result.output || "(no output)";
+        }
+        return `Error: ${result.error}`;
+      }
+    }),
+    ...model ? {
+      sub_agent: tool({
+        description: description10,
+        inputSchema: z.object({
+          prompt: z.string().describe("Detailed task description for the sub-agent. Be specific about what to look for."),
+          maxTurns: z.number().optional().describe("Maximum tool-use turns (default: 20)")
+        }),
+        execute: async ({ prompt, maxTurns }) => {
+          const readOnlyTools = {
+            read_file: tool({
+              description: description2,
+              inputSchema: z.object({
+                path: z.string().describe("Path to the file to read"),
+                maxLines: z.number().optional().describe("Max lines to read"),
+                startLine: z.number().optional().describe("Start line (1-indexed)")
+              }),
+              execute: async ({ path: filePath, maxLines, startLine }) => {
+                const resolvedPath = path9.isAbsolute(filePath) ? filePath : path9.resolve(workingDir, filePath);
+                assertPathInBounds(resolvedPath, workingDir, sandboxed);
+                const result2 = await execute2({ path: resolvedPath, maxLines, startLine });
+                return result2.success ? result2.content || "" : `Error: ${result2.error}`;
+              }
+            }),
+            glob: tool({
+              description: description5,
+              inputSchema: z.object({
+                pattern: z.string().describe("Glob pattern to match files"),
+                cwd: z.string().optional().describe("Directory to search in")
+              }),
+              execute: async ({ pattern, cwd }) => {
+                const resolvedCwd = cwd ? path9.isAbsolute(cwd) ? cwd : path9.resolve(workingDir, cwd) : workingDir;
+                assertPathInBounds(resolvedCwd, workingDir, sandboxed);
+                const result2 = await execute5({ pattern, cwd: resolvedCwd });
+                return result2.success ? result2.count === 0 ? `No files found matching: ${pattern}` : `Found ${result2.count} file(s):
+${result2.matches.join("\n")}` : `Error: ${result2.error}`;
+              }
+            }),
+            grep: tool({
+              description: description6,
+              inputSchema: z.object({
+                pattern: z.string().describe("Regex pattern to search for"),
+                path: z.string().optional().describe("File or directory to search in"),
+                filePattern: z.string().optional().describe("Glob to filter files")
+              }),
+              execute: async ({ pattern, path: searchPath, filePattern }) => {
+                const resolvedPath = searchPath ? path9.isAbsolute(searchPath) ? searchPath : path9.resolve(workingDir, searchPath) : workingDir;
+                assertPathInBounds(resolvedPath, workingDir, sandboxed);
+                const result2 = await execute6({ pattern, path: resolvedPath, filePattern });
+                if (!result2.success)
+                  return `Error: ${result2.error}`;
+                if (result2.matchCount === 0)
+                  return `No matches for: ${pattern}`;
+                const lines = [`Found ${result2.matchCount} match(es):`];
+                for (const [file, matches] of Object.entries(result2.results)) {
+                  for (const match of matches) {
+                    lines.push(`${file}:${match.line}: ${match.content}`);
+                  }
+                }
+                return lines.join("\n");
+              }
+            }),
+            ls: tool({
+              description: description7,
+              inputSchema: z.object({
+                path: z.string().describe("Directory path to list"),
+                maxDepth: z.number().optional().describe("Max depth (default: 3)")
+              }),
+              execute: async ({ path: dirPath, maxDepth }) => {
+                const resolvedPath = path9.isAbsolute(dirPath) ? dirPath : path9.resolve(workingDir, dirPath);
+                assertPathInBounds(resolvedPath, workingDir, sandboxed);
+                const result2 = await execute7({ path: resolvedPath, maxDepth });
+                return result2.success ? result2.tree : `Error: ${result2.error}`;
+              }
+            })
+          };
+          const executor = createSubAgentExecutor(model, workingDir, readOnlyTools);
+          const result = await executor({ prompt, maxTurns });
+          if (result.success) {
+            return `Sub-agent findings (${result.turnsUsed} turns):
+
+${result.content}`;
+          }
+          return `Error: ${result.error}`;
+        }
+      })
+    } : {}
+  };
+}
+
+// src/permissions.js
+import readline from "readline";
+import chalk from "chalk";
+var READ_TOOLS = /* @__PURE__ */ new Set(["read_file", "glob", "grep", "ls", "sub_agent"]);
+var DANGEROUS_PATTERNS = [
+  { pattern: /rm\s+(-[a-z]*f|-[a-z]*r|--force|--recursive)/i, label: "recursive/forced delete" },
+  { pattern: /git\s+reset\s+--hard/i, label: "hard reset" },
+  { pattern: /git\s+push\s+.*--force/i, label: "force push" },
+  { pattern: /git\s+clean\s+-[a-z]*f/i, label: "git clean" },
+  { pattern: /drop\s+table/i, label: "drop table" },
+  { pattern: /truncate\s+/i, label: "truncate" },
+  { pattern: /DELETE\s+FROM\s+\w+\s*;/i, label: "DELETE without WHERE" },
+  { pattern: /chmod\s+777/i, label: "chmod 777" },
+  { pattern: />(\/dev\/sda|\/dev\/disk)/i, label: "write to disk device" }
+];
+function isDangerous(command) {
+  for (const { pattern, label } of DANGEROUS_PATTERNS) {
+    if (pattern.test(command))
+      return label;
+  }
+  return null;
+}
+var PermissionManager = class {
+  sessionAllow = /* @__PURE__ */ new Set();
+  trustAll;
+  configTrust;
+  rl = null;
+  cancelCurrentPrompt = null;
+  /** True while rl.question() is active — external line handlers must ignore input */
+  questionActive = false;
+  constructor(trustAll = false, configTrust = []) {
+    this.trustAll = trustAll;
+    this.configTrust = new Set(configTrust);
+  }
+  /** Bind to the agent's readline instance so we reuse it for prompts */
+  setReadline(rl) {
+    this.rl = rl;
+  }
+  cancelPrompt() {
+    if (this.cancelCurrentPrompt) {
+      this.cancelCurrentPrompt();
+      this.cancelCurrentPrompt = null;
+    }
+  }
+  async checkPermission(toolName, toolInput) {
+    if (toolName === "bash") {
+      const cmd = String(toolInput.command || "");
+      const danger = isDangerous(cmd);
+      if (danger) {
+        console.log();
+        console.log(chalk.red.bold(`  \u26A0 DANGEROUS: ${danger}`));
+        console.log(chalk.red(`  Command: ${cmd}`));
+        if (this.trustAll) {
+          console.log(chalk.yellow("  (allowed by --trust mode)"));
+          return true;
+        }
+        const answer = await this.askUser(chalk.red("  Are you sure? (yes to confirm): "));
+        if (answer.trim().toLowerCase() !== "yes")
+          return false;
+        return true;
+      }
+    }
+    if (this.trustAll)
+      return true;
+    if (READ_TOOLS.has(toolName))
+      return true;
+    if (this.sessionAllow.has(toolName))
+      return true;
+    if (this.configTrust.has(toolName))
+      return true;
+    return this.promptUser(toolName, toolInput);
+  }
+  async promptUser(toolName, toolInput) {
+    const display = this.formatToolCall(toolName, toolInput);
+    console.log();
+    console.log(chalk.cyan(`  \u250C\u2500 ${toolName} ${"\u2500".repeat(Math.max(0, 40 - toolName.length))}\u2510`));
+    for (const line of display.split("\n")) {
+      console.log(chalk.cyan("  \u2502 ") + chalk.white(line));
+    }
+    console.log(chalk.cyan(`  \u2514${"\u2500".repeat(43)}\u2518`));
+    const answer = await this.askUser(chalk.dim("  Allow? ") + chalk.white("(y)es / (n)o / (a)lways this tool / (t)rust all: "));
+    const choice = answer.trim().toLowerCase();
+    if (choice === "t" || choice === "trust") {
+      this.trustAll = true;
+      return true;
+    }
+    if (choice === "a" || choice === "always") {
+      this.sessionAllow.add(toolName);
+      return true;
+    }
+    return choice === "y" || choice === "yes";
+  }
+  /**
+   * Prompt the user with a question. Sets questionActive flag so the
+   * agent's line handler knows to ignore this input.
+   */
+  askUser(prompt) {
+    return new Promise((resolve, reject) => {
+      this.cancelCurrentPrompt = () => {
+        this.questionActive = false;
+        reject(new Error("cancelled"));
+      };
+      if (this.rl) {
+        this.questionActive = true;
+        this.rl.resume();
+        this.rl.question(prompt, (answer) => {
+          this.questionActive = false;
+          this.cancelCurrentPrompt = null;
+          this.rl.pause();
+          resolve(answer);
+        });
+      } else {
+        const questionRl = readline.createInterface({
+          input: process.stdin,
+          output: process.stdout
+        });
+        this.questionActive = true;
+        questionRl.question(prompt, (answer) => {
+          this.questionActive = false;
+          this.cancelCurrentPrompt = null;
+          questionRl.close();
+          resolve(answer);
+        });
+      }
+    });
+  }
+  formatToolCall(toolName, input) {
+    switch (toolName) {
+      case "bash":
+        return String(input.command || "");
+      case "write_file":
+      case "edit_file":
+        return `${input.path || ""}`;
+      case "patch":
+        return String(input.patch_text || "").slice(0, 200) + "...";
+      case "fetch":
+        return String(input.url || "");
+      default:
+        return JSON.stringify(input, null, 2).slice(0, 200);
+    }
+  }
+};
+
+// src/tui.js
+import chalk2 from "chalk";
+import { execSync as execSync2 } from "child_process";
+var toolCounts = {};
+var cachedGitBranch = "";
+var lastBranchCheck = 0;
+function getGitBranch() {
+  const now = Date.now();
+  if (now - lastBranchCheck > 1e4) {
+    lastBranchCheck = now;
+    try {
+      cachedGitBranch = execSync2("git rev-parse --abbrev-ref HEAD 2>/dev/null", { encoding: "utf-8", timeout: 2e3 }).trim();
+    } catch {
+      cachedGitBranch = "";
+    }
+  }
+  return cachedGitBranch;
+}
+function incrementToolCount(toolName) {
+  toolCounts[toolName] = (toolCounts[toolName] || 0) + 1;
+}
+function printHeader(version, provider, model, cwd) {
+  console.log();
+  console.log(chalk2.bold.white(`  WorkerMill`) + chalk2.dim(` v${version}`));
+  if (provider && model) {
+    console.log(chalk2.dim(`  ${provider}/`) + chalk2.white(model));
+  }
+  if (cwd) {
+    console.log(chalk2.dim(`  cwd: `) + chalk2.white(cwd));
+  }
+  console.log(chalk2.dim(`  /help`) + chalk2.dim(` for commands, `) + chalk2.dim(`Ctrl+C`) + chalk2.dim(` to cancel`));
+  console.log();
+}
+function printToolCall(toolName, toolInput) {
+  incrementToolCount(toolName);
+  const arrow = chalk2.dim("  \u2193 ");
+  const label = chalk2.cyan;
+  switch (toolName) {
+    case "bash": {
+      let cmd = String(toolInput.command || "");
+      const heredocIdx = cmd.indexOf("<<");
+      if (heredocIdx > 0)
+        cmd = cmd.slice(0, heredocIdx).trim() + " << ...";
+      if (cmd.length > 120)
+        cmd = cmd.slice(0, 117) + "...";
+      console.log(arrow + label("Bash ") + chalk2.yellow(cmd));
+      break;
+    }
+    case "read_file":
+      console.log(arrow + label("Read ") + chalk2.white(String(toolInput.path || "")));
+      break;
+    case "write_file":
+      console.log(arrow + label("Write ") + chalk2.white(String(toolInput.path || "")));
+      break;
+    case "edit_file":
+      console.log(arrow + label("Edit ") + chalk2.white(String(toolInput.path || "")));
+      break;
+    case "patch":
+      console.log(arrow + label("Patch ") + chalk2.white("(multi-file)"));
+      break;
+    case "glob":
+      console.log(arrow + label("Glob ") + chalk2.white(String(toolInput.pattern || "")));
+      break;
+    case "grep":
+      console.log(arrow + label("Grep ") + chalk2.white(String(toolInput.pattern || "")));
+      break;
+    case "ls":
+      console.log(arrow + label("List ") + chalk2.white(String(toolInput.path || ".")));
+      break;
+    case "fetch":
+      console.log(arrow + label("Fetch ") + chalk2.white(String(toolInput.url || "")));
+      break;
+    case "sub_agent":
+      console.log(arrow + label("Agent ") + chalk2.white(String(toolInput.prompt || "").slice(0, 80)));
+      break;
+    case "git":
+      console.log(arrow + label("Git ") + chalk2.white(`${toolInput.action}${toolInput.args ? " " + toolInput.args : ""}`));
+      break;
+    default:
+      console.log(arrow + label(toolName));
+  }
+}
+var PERSONA_EMOJIS = {
+  frontend_developer: "\u{1F3A8}",
+  // 🎨
+  backend_developer: "\u{1F4BB}",
+  // 💻
+  fullstack_developer: "\u{1F4BB}",
+  // 💻 (same as backend)
+  devops_engineer: "\u{1F527}",
+  // 🔧
+  security_engineer: "\u{1F512}",
+  // 🔐
+  qa_engineer: "\u{1F9EA}",
+  // 🧪
+  tech_writer: "\u{1F4DD}",
+  // 📝
+  project_manager: "\u{1F4CB}",
+  // 📋
+  architect: "\u{1F3D7}\uFE0F",
+  // 🏗️
+  database_engineer: "\u{1F4CA}",
+  // 📊
+  data_engineer: "\u{1F4CA}",
+  // 📊
+  data_ml_engineer: "\u{1F4CA}",
+  // 📊
+  ml_engineer: "\u{1F4CA}",
+  // 📊
+  mobile_developer: "\u{1F4F1}",
+  // 📱
+  tech_lead: "\u{1F451}",
+  // 👑
+  manager: "\u{1F454}",
+  // 👔
+  support_agent: "\u{1F4AC}",
+  // 💬
+  planner: "\u{1F4A1}",
+  // 💡 (planning_agent)
+  coordinator: "\u{1F3AF}",
+  // 🎯
+  critic: "\u{1F50D}",
+  // 🔍
+  reviewer: "\u{1F50D}"
+  // 🔍
+};
+function getPersonaEmoji(persona) {
+  return PERSONA_EMOJIS[persona] || "\u{1F916}";
+}
+function printToolResult(toolName, result) {
+  const isError = result.startsWith("Error:") || result.startsWith("error:");
+  const lines = result.split("\n").filter((l) => l.trim());
+  if (isError) {
+    const errLines = lines.slice(0, 5);
+    for (const line of errLines) {
+      console.log(chalk2.red(`    ${line}`));
+    }
+    if (lines.length > 5)
+      console.log(chalk2.red(`    ... ${lines.length - 5} more lines`));
+    return;
+  }
+  switch (toolName) {
+    case "read_file":
+      console.log(chalk2.dim(`    (${lines.length} lines)`));
+      break;
+    case "write_file":
+    case "edit_file":
+    case "patch":
+      if (lines.length === 1) {
+        console.log(chalk2.dim(`    ${lines[0]}`));
+      } else {
+        console.log(chalk2.dim(`    (${lines.length} lines changed)`));
+      }
+      break;
+    case "bash": {
+      if (lines.length === 0)
+        break;
+      const shown = lines.slice(0, 5);
+      for (const line of shown) {
+        console.log(chalk2.dim(`    ${line}`));
+      }
+      if (lines.length > 5)
+        console.log(chalk2.dim(`    ... ${lines.length - 5} more lines`));
+      break;
+    }
+    case "glob":
+    case "grep":
+    case "ls":
+      const searchShown = lines.slice(0, 8);
+      for (const line of searchShown) {
+        console.log(chalk2.dim(`    ${line}`));
+      }
+      if (lines.length > 8)
+        console.log(chalk2.dim(`    ... ${lines.length - 8} more`));
+      break;
+    default:
+      if (lines.length <= 3) {
+        for (const line of lines)
+          console.log(chalk2.dim(`    ${line}`));
+      } else {
+        console.log(chalk2.dim(`    (${lines.length} lines)`));
+      }
+  }
+}
+function wmLog(persona, message) {
+  const emoji = getPersonaEmoji(persona);
+  console.log(chalk2.cyan(`[${emoji} ${persona} \u{1F3E0}] `) + chalk2.white(message));
+}
+function wmLogPrefix(persona) {
+  const emoji = getPersonaEmoji(persona);
+  return chalk2.cyan(`[${emoji} ${persona} \u{1F3E0}] `);
+}
+function wmCoordinatorLog(message) {
+  console.log(chalk2.cyan("[coordinator] ") + chalk2.white(message));
+}
+function printError(message) {
+  console.log(chalk2.red(`
+  \u2717 ${message}
+`));
+}
+var sessionStartTime = Date.now();
+function formatTokens(n) {
+  if (n >= 1e6)
+    return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3)
+    return `${(n / 1e3).toFixed(n >= 1e4 ? 0 : 1)}k`;
+  return String(n);
+}
+function formatElapsed() {
+  const mins = Math.floor((Date.now() - sessionStartTime) / 6e4);
+  if (mins < 1)
+    return "<1m";
+  return `>${mins}m`;
+}
+function contextBar(tokens, maxContext) {
+  const barLen = 8;
+  const usage = Math.min(1, tokens / maxContext);
+  const filled = Math.round(usage * barLen);
+  const empty = barLen - filled;
+  const color = usage < 0.5 ? chalk2.green : usage < 0.8 ? chalk2.yellow : chalk2.red;
+  return color("\u2588".repeat(filled)) + chalk2.dim("\u2591".repeat(empty));
+}
+function printStatusBar(provider, model, tokens, permissionMode, cost) {
+  const width = process.stdout.columns || 80;
+  const bg = chalk2.bgRgb(30, 30, 30);
+  const modelDisplay = ` ${model} `;
+  const maxCtx = 128e3;
+  const bar = contextBar(tokens, maxCtx);
+  const tokStr = formatTokens(tokens);
+  const shortNames = {
+    bash: "Bash",
+    read_file: "Read",
+    write_file: "Write",
+    edit_file: "Edit",
+    glob: "Glob",
+    grep: "Grep",
+    ls: "List",
+    fetch: "Fetch",
+    patch: "Patch",
+    sub_agent: "Agent",
+    git: "Git"
+  };
+  const countParts = Object.entries(toolCounts).filter(([_, count]) => count > 0).map(([name, count]) => `${shortNames[name] || name} x${count}`);
+  const toolStr = countParts.length > 0 ? countParts.join(" | ") : "";
+  const gitBranch = getGitBranch();
+  const cwd = process.cwd().split("/").pop() || "";
+  const costStr = cost !== void 0 && cost > 0 ? `$${cost.toFixed(4)} | ` : "";
+  const elapsed = formatElapsed();
+  const modeStr = permissionMode || "ask";
+  const left = bg.white(modelDisplay) + " " + bar + " " + bg.white(tokStr);
+  const middle = gitBranch ? bg.dim(" | ") + bg.white(cwd) + bg.dim(" git:(") + bg.green(gitBranch) + bg.dim(")") : bg.dim(" | ") + bg.white(cwd);
+  const tools = toolStr ? bg.dim(" | ") + bg.dim(toolStr) : "";
+  const right = bg.dim(" | ") + bg.dim(costStr) + bg.white(elapsed) + bg.dim("  ") + bg.green(modeStr) + " ";
+  const stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*m/g, "");
+  const contentLen = stripAnsi(left).length + stripAnsi(middle).length + stripAnsi(tools).length + stripAnsi(right).length;
+  const pad = Math.max(0, width - contentLen);
+  return left + middle + tools + bg(" ".repeat(pad)) + right;
+}
+
+// src/cost-tracker.js
+var PRICING = {
+  // Anthropic
+  "claude-opus-4-6": { input: 15, output: 75 },
+  "claude-sonnet-4-6": { input: 3, output: 15 },
+  "claude-haiku-4-5": { input: 0.8, output: 4 },
+  // OpenAI
+  "gpt-4o": { input: 2.5, output: 10 },
+  "gpt-4o-mini": { input: 0.15, output: 0.6 },
+  "o3": { input: 10, output: 40 },
+  "o3-mini": { input: 1.1, output: 4.4 },
+  // Google
+  "gemini-2.5-pro": { input: 1.25, output: 10 },
+  "gemini-2.5-flash": { input: 0.15, output: 0.6 }
+};
+var CostTracker = class {
+  entries = [];
+  addUsage(persona, provider, model, inputTokens, outputTokens) {
+    const pricing = PRICING[model] || { input: 0, output: 0 };
+    const cost = inputTokens / 1e6 * pricing.input + outputTokens / 1e6 * pricing.output;
+    this.entries.push({
+      persona,
+      provider,
+      model,
+      inputTokens,
+      outputTokens,
+      cost
+    });
+  }
+  getTotalCost() {
+    return this.entries.reduce((sum, e) => sum + e.cost, 0);
+  }
+  getTotalTokens() {
+    return this.entries.reduce((sum, e) => sum + e.inputTokens + e.outputTokens, 0);
+  }
+  getBreakdown() {
+    return [...this.entries];
+  }
+  getSummary() {
+    const total = this.getTotalCost();
+    const totalIn = this.entries.reduce((s, e) => s + e.inputTokens, 0);
+    const totalOut = this.entries.reduce((s, e) => s + e.outputTokens, 0);
+    const lines = [
+      `Session cost: $${total.toFixed(4)} (${totalIn.toLocaleString()} in / ${totalOut.toLocaleString()} out)`
+    ];
+    for (const entry of this.entries) {
+      lines.push(`  * ${entry.persona}: $${entry.cost.toFixed(4)} (${entry.provider}/${entry.model})`);
+    }
+    return lines.join("\n");
+  }
+};
+
+export {
+  loadConfig,
+  saveConfig,
+  getProviderForPersona,
+  createModel,
+  killActiveProcess,
+  createToolDefinitions,
+  PermissionManager,
+  printHeader,
+  printToolCall,
+  getPersonaEmoji,
+  printToolResult,
+  wmLog,
+  wmLogPrefix,
+  wmCoordinatorLog,
+  printError,
+  printStatusBar,
+  CostTracker
+};