workermill 0.1.9 → 0.2.0

package/dist/{chunk-3KIFXIBC.js → chunk-VC6VNVEY.js}

@@ -1,9 +1,16 @@
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var getFilename = () => fileURLToPath(import.meta.url);
+var getDirname = () => path.dirname(getFilename());
+var __dirname = /* @__PURE__ */ getDirname();
+
 // src/config.js
 import fs from "fs";
-import path from "path";
+import path2 from "path";
 import os from "os";
-var CONFIG_DIR = path.join(os.homedir(), ".workermill");
-var CONFIG_FILE = path.join(CONFIG_DIR, "cli.json");
+var CONFIG_DIR = path2.join(os.homedir(), ".workermill");
+var CONFIG_FILE = path2.join(CONFIG_DIR, "cli.json");
 function loadConfig() {
   try {
     if (!fs.existsSync(CONFIG_FILE))
@@ -30,7 +37,8 @@ function getProviderForPersona(config, persona) {
     provider: providerName,
     model: providerConfig.model,
     apiKey: providerConfig.apiKey?.startsWith("{env:") ? process.env[providerConfig.apiKey.slice(5, -1)] || void 0 : providerConfig.apiKey,
-    host: providerConfig.host
+    host: providerConfig.host,
+    contextLength: providerConfig.contextLength
   };
 }
 
@@ -39,7 +47,18 @@ 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) {
+function buildOllamaOptions(provider, contextLength) {
+  if (provider !== "ollama" || !contextLength)
+    return {};
+  return {
+    providerOptions: {
+      ollama: {
+        num_ctx: contextLength
+      }
+    }
+  };
+}
+function createModel(provider, modelName, ollamaHost, ollamaContextLength) {
   switch (provider) {
     case "anthropic":
       return anthropic(modelName);
@@ -61,7 +80,7 @@ function createModel(provider, modelName, ollamaHost) {
 // ../packages/engine/src/tools/index.js
 import { tool } from "ai";
 import { z } from "zod";
-import path9 from "path";
+import path10 from "path";
 
 // ../packages/engine/src/tools/bash.js
 import { spawn } from "child_process";
@@ -123,10 +142,7 @@ async function execute({ command, cwd, timeout = 12e4 }) {
     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"
-      },
+      env: process.env,
       stdio: ["pipe", "pipe", "pipe"],
       detached: true
     });
@@ -206,11 +222,11 @@ async function execute({ command, cwd, timeout = 12e4 }) {
 
 // ../packages/engine/src/tools/read-file.js
 import fs2 from "fs";
-import path2 from "path";
+import path3 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);
+    const absolutePath = path3.isAbsolute(filePath) ? filePath : path3.resolve(process.cwd(), filePath);
     if (!fs2.existsSync(absolutePath)) {
       return {
         success: false,
@@ -263,12 +279,12 @@ async function execute2({ path: filePath, encoding = "utf8", maxLines, startLine
 
 // ../packages/engine/src/tools/write-file.js
 import fs3 from "fs";
-import path3 from "path";
+import path4 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);
+    const absolutePath = path4.isAbsolute(filePath) ? filePath : path4.resolve(process.cwd(), filePath);
+    const dirPath = path4.dirname(absolutePath);
     if (!fs3.existsSync(dirPath)) {
       fs3.mkdirSync(dirPath, { recursive: true });
     }
@@ -304,11 +320,11 @@ async function execute3({ path: filePath, content, encoding = "utf8", append = f
 
 // ../packages/engine/src/tools/edit-file.js
 import fs4 from "fs";
-import path4 from "path";
+import path5 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);
+    const absolutePath = path5.isAbsolute(filePath) ? filePath : path5.resolve(process.cwd(), filePath);
     if (!fs4.existsSync(absolutePath)) {
       return {
         success: false,
@@ -375,7 +391,7 @@ async function execute4({ path: filePath, old_string, new_string, replaceAll = f
 
 // ../packages/engine/src/tools/glob.js
 import fs5 from "fs";
-import path5 from "path";
+import path6 from "path";
 function globToRegex(pattern) {
   let regex = "";
   let i = 0;
@@ -451,7 +467,7 @@ function walkDir(dir, files = [], maxDepth = 20, currentDepth = 0) {
         continue;
       if (entry.name === ".git")
         continue;
-      const fullPath = path5.join(dir, entry.name);
+      const fullPath = path6.join(dir, entry.name);
       if (entry.isDirectory()) {
         walkDir(fullPath, files, maxDepth, currentDepth + 1);
       } else if (entry.isFile()) {
@@ -465,7 +481,7 @@ function walkDir(dir, files = [], maxDepth = 20, currentDepth = 0) {
 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();
+    const searchDir = cwd ? path6.isAbsolute(cwd) ? cwd : path6.resolve(process.cwd(), cwd) : process.cwd();
     if (!fs5.existsSync(searchDir)) {
       return {
         success: false,
@@ -476,7 +492,7 @@ async function execute5({ pattern, cwd, maxResults = 1e3, includeHidden = false
     const regex = globToRegex(pattern);
     const matches = [];
     for (const file of allFiles) {
-      const relativePath = path5.relative(searchDir, file).replace(/\\/g, "/");
+      const relativePath = path6.relative(searchDir, file).replace(/\\/g, "/");
       if (!includeHidden && relativePath.split("/").some((part) => part.startsWith("."))) {
         continue;
       }
@@ -510,7 +526,7 @@ async function execute5({ pattern, cwd, maxResults = 1e3, includeHidden = false
 
 // ../packages/engine/src/tools/grep.js
 import fs6 from "fs";
-import path6 from "path";
+import path7 from "path";
 function walkDir2(dir, files = [], maxDepth = 20, currentDepth = 0) {
   if (currentDepth > maxDepth)
     return files;
@@ -529,13 +545,13 @@ function walkDir2(dir, files = [], maxDepth = 20, currentDepth = 0) {
         continue;
       if (entry.name === ".next")
         continue;
-      const fullPath = path6.join(dir, entry.name);
+      const fullPath = path7.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 ext = path7.extname(entry.name).toLowerCase();
         const binaryExts = [
           ".png",
           ".jpg",
@@ -609,7 +625,7 @@ async function execute6({ pattern, path: searchPath, filePattern, ignoreCase = f
         error: `Invalid regex pattern: ${err.message}`
       };
     }
-    const targetPath = searchPath ? path6.isAbsolute(searchPath) ? searchPath : path6.resolve(process.cwd(), searchPath) : process.cwd();
+    const targetPath = searchPath ? path7.isAbsolute(searchPath) ? searchPath : path7.resolve(process.cwd(), searchPath) : process.cwd();
     if (!fs6.existsSync(targetPath)) {
       return {
         success: false,
@@ -634,7 +650,7 @@ async function execute6({ pattern, path: searchPath, filePattern, ignoreCase = f
         break;
       const matches = searchFile(file, regex, contextLines);
       if (matches.length > 0) {
-        const relativePath = path6.relative(targetPath, file).replace(/\\/g, "/") || path6.basename(file);
+        const relativePath = path7.relative(targetPath, file).replace(/\\/g, "/") || path7.basename(file);
         for (const match of matches) {
           if (totalMatches >= maxResults)
             break;
@@ -680,7 +696,7 @@ async function execute6({ pattern, path: searchPath, filePattern, ignoreCase = f
 
 // ../packages/engine/src/tools/ls.js
 import fs7 from "fs";
-import path7 from "path";
+import path8 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) {
@@ -722,7 +738,7 @@ function buildTree(dirPath, prefix, depth, maxDepth, ignorePatterns, state) {
     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);
+    const fullPath = path8.join(dirPath, entry.name);
     if (entry.isDirectory()) {
       state.dirs++;
       state.lines.push(`${prefix}${connector}${entry.name}/`);
@@ -831,7 +847,7 @@ async function execute8({ url, format = "markdown", timeout = 3e4 }) {
 
 // ../packages/engine/src/tools/patch.js
 import fs8 from "fs";
-import path8 from "path";
+import path9 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 = [];
@@ -986,7 +1002,7 @@ ${errors.join("\n")}`,
     const filesCreated = [];
     const filesDeleted = [];
     for (const [filePath, content] of pendingWrites) {
-      const dir = path8.dirname(filePath);
+      const dir = path9.dirname(filePath);
       if (!fs8.existsSync(dir)) {
         fs8.mkdirSync(dir, { recursive: true });
       }
@@ -1018,7 +1034,7 @@ ${errors.join("\n")}`,
 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 }) {
+  return async function execute13({ prompt, maxTurns = 20 }) {
     try {
       let turnsUsed = 0;
       const stream = streamText({
@@ -1100,13 +1116,103 @@ async function execute10({ action, args, cwd }) {
   }
 }
 
+// ../packages/engine/src/tools/web-search.js
+var description12 = "Search the web for documentation, error messages, library usage, or any information. Returns search results with titles, URLs, and snippets. Use this when you need up-to-date information that might not be in your training data.";
+async function execute11(input) {
+  const { query, maxResults = 8 } = input;
+  try {
+    const encoded = encodeURIComponent(query);
+    const response = await globalThis.fetch(`https://html.duckduckgo.com/html/?q=${encoded}`, {
+      headers: {
+        "User-Agent": "WorkerMill/1.0 (AI Coding Agent)"
+      },
+      signal: AbortSignal.timeout(15e3)
+    });
+    if (!response.ok) {
+      return { success: false, error: `Search failed: HTTP ${response.status}` };
+    }
+    const html = await response.text();
+    const results = [];
+    const resultPattern = /<a[^>]*class="result__a"[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>[\s\S]*?<a[^>]*class="result__snippet"[^>]*>([\s\S]*?)<\/a>/g;
+    let match;
+    while ((match = resultPattern.exec(html)) !== null && results.length < maxResults) {
+      const rawUrl = match[1];
+      const title = match[2].replace(/<[^>]+>/g, "").trim();
+      const snippet = match[3].replace(/<[^>]+>/g, "").trim();
+      let url = rawUrl;
+      const uddgMatch = rawUrl.match(/uddg=([^&]+)/);
+      if (uddgMatch) {
+        url = decodeURIComponent(uddgMatch[1]);
+      }
+      if (title && url) {
+        results.push({ title, url, snippet });
+      }
+    }
+    if (results.length === 0) {
+      return { success: true, results: [], error: "No results found" };
+    }
+    return { success: true, results };
+  } catch (err) {
+    return {
+      success: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+
+// ../packages/engine/src/tools/todo.js
+var description13 = "Track your progress within a task. Create todo items, mark them complete, and list status. Use this to stay organized on multi-step work.";
+var todos = /* @__PURE__ */ new Map();
+var nextId = 1;
+async function execute12(input) {
+  const { action, text, id, status } = input;
+  switch (action) {
+    case "add": {
+      if (!text)
+        return { success: false, error: "Text is required for adding a todo" };
+      const todoId = `todo-${nextId++}`;
+      const item = {
+        id: todoId,
+        text,
+        status: "pending",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      todos.set(todoId, item);
+      return { success: true, item };
+    }
+    case "update": {
+      if (!id)
+        return { success: false, error: "ID is required for updating a todo" };
+      const existing = todos.get(id);
+      if (!existing)
+        return { success: false, error: `Todo not found: ${id}` };
+      if (status)
+        existing.status = status;
+      if (text)
+        existing.text = text;
+      return { success: true, item: existing };
+    }
+    case "list": {
+      const items = Array.from(todos.values());
+      return { success: true, items };
+    }
+    case "clear": {
+      todos.clear();
+      nextId = 1;
+      return { success: true, items: [] };
+    }
+    default:
+      return { success: false, error: `Unknown action: ${action}` };
+  }
+}
+
 // ../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) {
+  const normalized = path10.resolve(resolvedPath);
+  const normalizedWorkDir = path10.resolve(workingDir);
+  if (!normalized.startsWith(normalizedWorkDir + path10.sep) && normalized !== normalizedWorkDir) {
     throw new Error(`Path "${resolvedPath}" is outside the working directory. Use --full-disk to allow access outside ${workingDir}`);
   }
   return normalized;
@@ -1121,7 +1227,7 @@ function createToolDefinitions(workingDir, model, sandboxed = true) {
         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;
+        const resolvedCwd = cwd ? path10.isAbsolute(cwd) ? cwd : path10.resolve(workingDir, cwd) : workingDir;
         assertPathInBounds(resolvedCwd, workingDir, sandboxed);
         const result = await execute({
           command,
@@ -1131,8 +1237,14 @@ function createToolDefinitions(workingDir, model, sandboxed = true) {
         if (result.success) {
           return result.stdout || "(no output)";
         }
-        return `Error: ${result.error || result.stderr}
-${result.stdout || ""}`.trim();
+        const parts = [];
+        if (result.stderr)
+          parts.push(result.stderr);
+        if (result.stdout)
+          parts.push(result.stdout);
+        if (result.error)
+          parts.push(result.error);
+        return `Error: ${parts.join("\n")}`.trim();
       }
     }),
     read_file: tool({
@@ -1144,7 +1256,7 @@ ${result.stdout || ""}`.trim();
         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);
+        const resolvedPath = path10.isAbsolute(filePath) ? filePath : path10.resolve(workingDir, filePath);
         assertPathInBounds(resolvedPath, workingDir, sandboxed);
         const result = await execute2({
           path: resolvedPath,
@@ -1167,7 +1279,7 @@ ${result.stdout || ""}`.trim();
         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);
+        const resolvedPath = path10.isAbsolute(filePath) ? filePath : path10.resolve(workingDir, filePath);
         assertPathInBounds(resolvedPath, workingDir, sandboxed);
         const result = await execute3({
           path: resolvedPath,
@@ -1190,7 +1302,7 @@ ${result.stdout || ""}`.trim();
         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);
+        const resolvedPath = path10.isAbsolute(filePath) ? filePath : path10.resolve(workingDir, filePath);
         assertPathInBounds(resolvedPath, workingDir, sandboxed);
         const result = await execute4({
           path: resolvedPath,
@@ -1214,7 +1326,7 @@ Hint: ${result.hint}` : ""}`;
         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;
+        const resolvedCwd = cwd ? path10.isAbsolute(cwd) ? cwd : path10.resolve(workingDir, cwd) : workingDir;
         assertPathInBounds(resolvedCwd, workingDir, sandboxed);
         const result = await execute5({
           pattern,
@@ -1243,7 +1355,7 @@ ${result.matches.join("\n")}`;
         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;
+        const resolvedPath = searchPath ? path10.isAbsolute(searchPath) ? searchPath : path10.resolve(workingDir, searchPath) : workingDir;
         assertPathInBounds(resolvedPath, workingDir, sandboxed);
         const result = await execute6({
           pattern,
@@ -1279,7 +1391,7 @@ ${result.matches.join("\n")}`;
         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);
+        const resolvedPath = path10.isAbsolute(dirPath) ? dirPath : path10.resolve(workingDir, dirPath);
         assertPathInBounds(resolvedPath, workingDir, sandboxed);
         const result = await execute7({ path: resolvedPath, ignore, maxDepth, maxFiles });
         if (result.success) {
@@ -1342,6 +1454,49 @@ Hint: ${result.hint}` : ""}`;
         return `Error: ${result.error}`;
       }
     }),
+    web_search: tool({
+      description: description12,
+      inputSchema: z.object({
+        query: z.string().describe("Search query \u2014 be specific, include library names, error messages, etc."),
+        maxResults: z.number().optional().describe("Maximum results to return (default: 8)")
+      }),
+      execute: async ({ query, maxResults }) => {
+        const result = await execute11({ query, maxResults });
+        if (result.success && result.results && result.results.length > 0) {
+          return result.results.map((r, i) => `${i + 1}. ${r.title}
+   ${r.url}
+   ${r.snippet}`).join("\n\n");
+        }
+        return result.error || "No results found";
+      }
+    }),
+    todo: tool({
+      description: description13,
+      inputSchema: z.object({
+        action: z.enum(["add", "update", "list", "clear"]).describe("Action to perform"),
+        text: z.string().optional().describe("Todo text (for add/update)"),
+        id: z.string().optional().describe("Todo ID (for update)"),
+        status: z.enum(["pending", "in_progress", "completed"]).optional().describe("New status (for update)")
+      }),
+      execute: async ({ action, text, id, status }) => {
+        const result = await execute12({ action, text, id, status });
+        if (result.success) {
+          if (result.item) {
+            return `[${result.item.status}] ${result.item.id}: ${result.item.text}`;
+          }
+          if (result.items) {
+            if (result.items.length === 0)
+              return "No todos";
+            const pending = result.items.filter((t) => t.status !== "completed").length;
+            const done = result.items.filter((t) => t.status === "completed").length;
+            return result.items.map((t) => `[${t.status === "completed" ? "\u2713" : t.status === "in_progress" ? "\u2192" : " "}] ${t.id}: ${t.text}`).join("\n") + `
+
+${done}/${result.items.length} completed, ${pending} remaining`;
+          }
+        }
+        return result.error || "Unknown error";
+      }
+    }),
     ...model ? {
       sub_agent: tool({
         description: description10,
@@ -1359,7 +1514,7 @@ Hint: ${result.hint}` : ""}`;
                 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);
+                const resolvedPath = path10.isAbsolute(filePath) ? filePath : path10.resolve(workingDir, filePath);
                 assertPathInBounds(resolvedPath, workingDir, sandboxed);
                 const result2 = await execute2({ path: resolvedPath, maxLines, startLine });
                 return result2.success ? result2.content || "" : `Error: ${result2.error}`;
@@ -1372,7 +1527,7 @@ Hint: ${result.hint}` : ""}`;
                 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;
+                const resolvedCwd = cwd ? path10.isAbsolute(cwd) ? cwd : path10.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):
@@ -1387,7 +1542,7 @@ ${result2.matches.join("\n")}` : `Error: ${result2.error}`;
                 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;
+                const resolvedPath = searchPath ? path10.isAbsolute(searchPath) ? searchPath : path10.resolve(workingDir, searchPath) : workingDir;
                 assertPathInBounds(resolvedPath, workingDir, sandboxed);
                 const result2 = await execute6({ pattern, path: resolvedPath, filePattern });
                 if (!result2.success)
@@ -1410,7 +1565,7 @@ ${result2.matches.join("\n")}` : `Error: ${result2.error}`;
                 maxDepth: z.number().optional().describe("Max depth (default: 3)")
               }),
               execute: async ({ path: dirPath, maxDepth }) => {
-                const resolvedPath = path9.isAbsolute(dirPath) ? dirPath : path9.resolve(workingDir, dirPath);
+                const resolvedPath = path10.isAbsolute(dirPath) ? dirPath : path10.resolve(workingDir, dirPath);
                 assertPathInBounds(resolvedPath, workingDir, sandboxed);
                 const result2 = await execute7({ path: resolvedPath, maxDepth });
                 return result2.success ? result2.tree : `Error: ${result2.error}`;
@@ -1431,422 +1586,21 @@ ${result.content}`;
   };
 }
 
-// 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
+  // Anthropic (Claude 4.5/4.6)
   "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 }
+  // OpenAI (GPT-5.x)
+  "gpt-5.4": { input: 0.75, output: 4.5 },
+  "gpt-5.4-mini": { input: 0.15, output: 0.6 },
+  "gpt-5.4-pro": { input: 5, output: 20 },
+  "gpt-5.3": { input: 1, output: 5 },
+  // Google (Gemini 3.x)
+  "gemini-3.1-pro": { input: 1.25, output: 10 },
+  "gemini-3.1-flash-lite": { input: 0.15, output: 0.6 }
+  // Ollama (free, local)
 };
 var CostTracker = class {
   entries = [];
@@ -1886,21 +1640,13 @@ var CostTracker = class {
 };
 
 export {
+  __dirname,
   loadConfig,
   saveConfig,
   getProviderForPersona,
+  buildOllamaOptions,
   createModel,
   killActiveProcess,
   createToolDefinitions,
-  PermissionManager,
-  printHeader,
-  printToolCall,
-  getPersonaEmoji,
-  printToolResult,
-  wmLog,
-  wmLogPrefix,
-  wmCoordinatorLog,
-  printError,
-  printStatusBar,
   CostTracker
 };