darkfoo-code 0.1.3 → 0.2.0

package/dist/chunk-4KTJEE4A.js

@@ -1,1023 +0,0 @@
-import {
-  getProvider
-} from "./chunk-OBL22IIN.js";
-import {
-  buildSystemPrompt
-} from "./chunk-VSJKCANO.js";
-
-// src/tools/bash.ts
-import { spawn } from "child_process";
-import { writeFile, mkdir, readFile } from "fs/promises";
-import { join } from "path";
-import { nanoid } from "nanoid";
-import { z } from "zod";
-
-// src/tools/types.ts
-import { zodToJsonSchema } from "zod-to-json-schema";
-function buildOllamaToolDef(tool) {
-  const raw = zodToJsonSchema(tool.inputSchema);
-  delete raw.$schema;
-  delete raw.additionalProperties;
-  return {
-    type: "function",
-    function: {
-      name: tool.name,
-      description: tool.description,
-      parameters: raw
-    }
-  };
-}
-
-// src/tools/bash.ts
-var INPUT_SCHEMA = z.object({
-  command: z.string().describe("The bash command to execute"),
-  description: z.string().optional().describe("Short description of what this command does"),
-  timeout: z.number().optional().describe("Timeout in milliseconds (default 120000, max 600000)"),
-  run_in_background: z.boolean().optional().describe("Run in background, returning a task ID for later retrieval")
-});
-var MAX_OUTPUT = 1e5;
-var BG_OUTPUT_DIR = join(process.env.HOME || "~", ".darkfoo", "bg-tasks");
-var backgroundTasks = /* @__PURE__ */ new Map();
-var BashTool = {
-  name: "Bash",
-  description: "Execute a bash command and return its output. Use for system commands, git operations, running scripts, installing packages. Set run_in_background for long-running commands.",
-  inputSchema: INPUT_SCHEMA,
-  isReadOnly: false,
-  async call(input, context) {
-    const parsed = INPUT_SCHEMA.parse(input);
-    const timeout = Math.min(parsed.timeout ?? 12e4, 6e5);
-    if (parsed.run_in_background) {
-      return runInBackground(parsed.command, context.cwd);
-    }
-    return new Promise((resolve7) => {
-      const proc = spawn(parsed.command, {
-        shell: true,
-        cwd: context.cwd,
-        env: { ...process.env, TERM: "dumb" },
-        signal: context.abortSignal,
-        timeout
-      });
-      let stdout = "";
-      let stderr = "";
-      proc.stdout?.on("data", (data) => {
-        const chunk = data.toString();
-        if (stdout.length < MAX_OUTPUT) {
-          stdout += chunk.slice(0, MAX_OUTPUT - stdout.length);
-        }
-      });
-      proc.stderr?.on("data", (data) => {
-        const chunk = data.toString();
-        if (stderr.length < MAX_OUTPUT) {
-          stderr += chunk.slice(0, MAX_OUTPUT - stderr.length);
-        }
-      });
-      proc.on("error", (err) => {
-        resolve7({ output: `Error: ${err.message}`, isError: true });
-      });
-      proc.on("close", (code) => {
-        let output = stdout;
-        if (stdout.length >= MAX_OUTPUT) {
-          output += "\n... (output truncated)";
-        }
-        if (stderr) {
-          output += (output ? "\n" : "") + `stderr: ${stderr}`;
-        }
-        if (!output) {
-          output = code === 0 ? "(no output)" : `Command failed with exit code ${code}`;
-        }
-        resolve7({ output, isError: code !== 0 });
-      });
-    });
-  },
-  toOllamaToolDef() {
-    return buildOllamaToolDef(this);
-  }
-};
-async function runInBackground(command, cwd) {
-  const taskId = nanoid(8);
-  await mkdir(BG_OUTPUT_DIR, { recursive: true });
-  const outputPath = join(BG_OUTPUT_DIR, `${taskId}.output`);
-  backgroundTasks.set(taskId, { command, status: "running", outputPath });
-  const proc = spawn(command, {
-    shell: true,
-    cwd,
-    env: { ...process.env, TERM: "dumb" },
-    detached: false
-  });
-  let stdout = "";
-  let stderr = "";
-  proc.stdout?.on("data", (data) => {
-    stdout += data.toString();
-  });
-  proc.stderr?.on("data", (data) => {
-    stderr += data.toString();
-  });
-  proc.on("close", async (code) => {
-    const output = stdout + (stderr ? `
-stderr: ${stderr}` : "");
-    await writeFile(outputPath, output || `(exit code ${code})`, "utf-8").catch(() => {
-    });
-    const task = backgroundTasks.get(taskId);
-    if (task) {
-      task.status = code === 0 ? "completed" : "failed";
-    }
-  });
-  proc.on("error", async (err) => {
-    await writeFile(outputPath, `Error: ${err.message}`, "utf-8").catch(() => {
-    });
-    const task = backgroundTasks.get(taskId);
-    if (task) {
-      task.status = "failed";
-    }
-  });
-  return {
-    output: `Background task started with ID: ${taskId}
-Command: ${command}
-Use Bash to run: cat ${outputPath}  (to check output later)`
-  };
-}
-
-// src/tools/read.ts
-import { readFile as readFile2, stat } from "fs/promises";
-import { extname, resolve } from "path";
-import { z as z2 } from "zod";
-
-// src/file-tracker.ts
-var readFiles = /* @__PURE__ */ new Map();
-function simpleHash(str) {
-  let hash = 0;
-  for (let i = 0; i < str.length; i++) {
-    const char = str.charCodeAt(i);
-    hash = (hash << 5) - hash + char;
-    hash |= 0;
-  }
-  return hash;
-}
-function markFileRead(path, content) {
-  readFiles.set(path, { readAt: Date.now(), contentHash: simpleHash(content) });
-}
-function hasFileBeenRead(path) {
-  return readFiles.has(path);
-}
-function trackedFileCount() {
-  return readFiles.size;
-}
-
-// src/utils/format.ts
-function addLineNumbers(lines, startLine = 1) {
-  const maxNum = startLine + lines.length - 1;
-  const width = String(maxNum).length;
-  return lines.map((line, i) => `${String(startLine + i).padStart(width)}	${line}`).join("\n");
-}
-function truncate(text, maxLen) {
-  if (text.length <= maxLen) return text;
-  return text.slice(0, maxLen - 3) + "...";
-}
-
-// src/tools/read.ts
-var INPUT_SCHEMA2 = z2.object({
-  file_path: z2.string().describe("Absolute path to the file to read"),
-  offset: z2.number().optional().describe("Line number to start from (0-based). Only provide for large files"),
-  limit: z2.number().optional().describe("Number of lines to read (default 2000)")
-});
-var DEFAULT_LIMIT = 2e3;
-var IMAGE_EXTS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp", ".svg", ".ico"]);
-var PDF_EXT = ".pdf";
-var ReadTool = {
-  name: "Read",
-  description: "Read a file from the filesystem. Returns content with line numbers. Supports text files, images (returns base64 metadata), and basic PDF text extraction. Use offset and limit for large files.",
-  inputSchema: INPUT_SCHEMA2,
-  isReadOnly: true,
-  async call(input, context) {
-    const parsed = INPUT_SCHEMA2.parse(input);
-    const filePath = resolve(context.cwd, parsed.file_path);
-    try {
-      const info = await stat(filePath);
-      if (info.isDirectory()) {
-        return { output: `Error: ${filePath} is a directory, not a file. Use Bash with 'ls' to list directory contents.`, isError: true };
-      }
-      const ext = extname(filePath).toLowerCase();
-      if (IMAGE_EXTS.has(ext)) {
-        return readImage(filePath, info.size);
-      }
-      if (ext === PDF_EXT) {
-        return readPdf(filePath);
-      }
-      const raw = await readFile2(filePath, "utf-8");
-      markFileRead(filePath, raw);
-      const lines = raw.split("\n");
-      const offset = parsed.offset ?? 0;
-      const limit = parsed.limit ?? DEFAULT_LIMIT;
-      const sliced = lines.slice(offset, offset + limit);
-      const numbered = addLineNumbers(sliced, offset + 1);
-      let output = numbered;
-      if (offset + limit < lines.length) {
-        output += `
-... (${lines.length - offset - limit} more lines)`;
-      }
-      return { output };
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return { output: `Error reading file: ${msg}`, isError: true };
-    }
-  },
-  toOllamaToolDef() {
-    return buildOllamaToolDef(this);
-  }
-};
-async function readImage(filePath, size) {
-  const ext = extname(filePath).toLowerCase();
-  if (ext === ".svg") {
-    const content = await readFile2(filePath, "utf-8");
-    return { output: `SVG image (${size} bytes):
-${content.slice(0, 5e3)}` };
-  }
-  const buffer = await readFile2(filePath);
-  const base64 = buffer.toString("base64");
-  const sizeKB = (size / 1024).toFixed(1);
-  const dims = detectImageDimensions(buffer, ext);
-  const dimStr = dims ? ` ${dims.width}x${dims.height}` : "";
-  return {
-    output: `Image: ${filePath}
-Format: ${ext.slice(1).toUpperCase()}${dimStr}, ${sizeKB} KB
-Base64 length: ${base64.length} chars
-(Image content available as binary \u2014 use Bash tools for processing if needed)`
-  };
-}
-async function readPdf(filePath) {
-  const { execFile: execFile3 } = await import("child_process");
-  return new Promise((resolve7) => {
-    execFile3("pdftotext", [filePath, "-"], { timeout: 15e3, maxBuffer: 5 * 1024 * 1024 }, (err, stdout) => {
-      if (err) {
-        resolve7({
-          output: `PDF file: ${filePath}
-(Install poppler-utils for text extraction: sudo dnf install poppler-utils)`
-        });
-        return;
-      }
-      const text = stdout.trim();
-      if (!text) {
-        resolve7({ output: `PDF file: ${filePath}
-(No extractable text \u2014 may be image-based)` });
-        return;
-      }
-      const lines = text.split("\n");
-      const preview = lines.length > 200 ? lines.slice(0, 200).join("\n") + `
-... (${lines.length - 200} more lines)` : text;
-      resolve7({ output: `PDF: ${filePath} (${lines.length} lines extracted)
-
-${preview}` });
-    });
-  });
-}
-function detectImageDimensions(buffer, ext) {
-  try {
-    if (ext === ".png" && buffer.length >= 24) {
-      return { width: buffer.readUInt32BE(16), height: buffer.readUInt32BE(20) };
-    }
-    if ((ext === ".jpg" || ext === ".jpeg") && buffer.length >= 2) {
-      for (let i = 0; i < buffer.length - 8; i++) {
-        if (buffer[i] === 255 && buffer[i + 1] === 192) {
-          return { height: buffer.readUInt16BE(i + 5), width: buffer.readUInt16BE(i + 7) };
-        }
-      }
-    }
-    if (ext === ".gif" && buffer.length >= 10) {
-      return { width: buffer.readUInt16LE(6), height: buffer.readUInt16LE(8) };
-    }
-  } catch {
-  }
-  return null;
-}
-
-// src/tools/write.ts
-import { access, mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
-import { dirname, resolve as resolve2 } from "path";
-import { z as z3 } from "zod";
-var INPUT_SCHEMA3 = z3.object({
-  file_path: z3.string().describe("Absolute path to the file to write"),
-  content: z3.string().describe("The content to write to the file")
-});
-var WriteTool = {
-  name: "Write",
-  description: "Write content to a file. Creates the file if it does not exist, or overwrites it if it does. Creates parent directories as needed.",
-  inputSchema: INPUT_SCHEMA3,
-  isReadOnly: false,
-  async call(input, context) {
-    const parsed = INPUT_SCHEMA3.parse(input);
-    const filePath = resolve2(context.cwd, parsed.file_path);
-    try {
-      let existed = false;
-      try {
-        await access(filePath);
-        existed = true;
-      } catch {
-      }
-      await mkdir2(dirname(filePath), { recursive: true });
-      await writeFile2(filePath, parsed.content, "utf-8");
-      const action = existed ? "Updated" : "Created";
-      const lines = parsed.content.split("\n").length;
-      return { output: `${action} ${filePath} (${lines} lines)` };
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return { output: `Error writing file: ${msg}`, isError: true };
-    }
-  },
-  toOllamaToolDef() {
-    return buildOllamaToolDef(this);
-  }
-};
-
-// src/tools/edit.ts
-import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
-import { resolve as resolve3 } from "path";
-import { createPatch } from "diff";
-import { z as z4 } from "zod";
-var INPUT_SCHEMA4 = z4.object({
-  file_path: z4.string().describe("Absolute path to the file to edit"),
-  old_string: z4.string().describe("The exact string to find and replace"),
-  new_string: z4.string().describe("The replacement string"),
-  replace_all: z4.boolean().optional().describe("Replace all occurrences (default false)")
-});
-function normalizeQuotes(s) {
-  return s.replace(/[\u2018\u2019\u201A\u201B]/g, "'").replace(/[\u201C\u201D\u201E\u201F]/g, '"');
-}
-function findActualString(fileContent, searchString) {
-  if (fileContent.includes(searchString)) {
-    return searchString;
-  }
-  const normalizedSearch = normalizeQuotes(searchString);
-  const normalizedFile = normalizeQuotes(fileContent);
-  const idx = normalizedFile.indexOf(normalizedSearch);
-  if (idx !== -1) {
-    return fileContent.substring(idx, idx + normalizedSearch.length);
-  }
-  return null;
-}
-var EditTool = {
-  name: "Edit",
-  description: "Edit a file by finding an exact string and replacing it. The old_string must be unique in the file unless replace_all is true.",
-  inputSchema: INPUT_SCHEMA4,
-  isReadOnly: false,
-  async call(input, context) {
-    const parsed = INPUT_SCHEMA4.parse(input);
-    const filePath = resolve3(context.cwd, parsed.file_path);
-    try {
-      if (!hasFileBeenRead(filePath)) {
-        return {
-          output: `Warning: ${filePath} has not been read yet. Use the Read tool first to avoid overwriting unexpected content.`,
-          isError: true
-        };
-      }
-      const content = await readFile3(filePath, "utf-8");
-      const actualOld = findActualString(content, parsed.old_string);
-      if (!actualOld) {
-        return {
-          output: `Error: old_string not found in ${filePath}. Make sure you have the exact text including whitespace and indentation.`,
-          isError: true
-        };
-      }
-      const occurrences = content.split(actualOld).length - 1;
-      if (occurrences > 1 && !parsed.replace_all) {
-        return {
-          output: `Error: old_string appears ${occurrences} times in ${filePath}. Use replace_all: true to replace all, or provide more context to make it unique.`,
-          isError: true
-        };
-      }
-      const newContent = parsed.replace_all ? content.replaceAll(actualOld, parsed.new_string) : content.replace(actualOld, parsed.new_string);
-      await writeFile3(filePath, newContent, "utf-8");
-      const diff = createPatch(filePath, content, newContent, "", "", { context: 3 });
-      return { output: diff };
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return { output: `Error editing file: ${msg}`, isError: true };
-    }
-  },
-  toOllamaToolDef() {
-    return buildOllamaToolDef(this);
-  }
-};
-
-// src/tools/grep.ts
-import { execFile } from "child_process";
-import { resolve as resolve4 } from "path";
-import { z as z5 } from "zod";
-var INPUT_SCHEMA5 = z5.object({
-  pattern: z5.string().describe("Regex pattern to search for"),
-  path: z5.string().optional().describe("Directory or file to search in (default: cwd)"),
-  glob: z5.string().optional().describe('Glob pattern to filter files (e.g. "*.ts")'),
-  type: z5.string().optional().describe('File type filter (e.g. "js", "py", "rust") \u2014 more efficient than glob'),
-  output_mode: z5.enum(["content", "files_with_matches", "count"]).optional().describe("Output mode (default: files_with_matches)"),
-  case_insensitive: z5.boolean().optional().describe("Case insensitive search"),
-  multiline: z5.boolean().optional().describe("Enable multiline mode where . matches newlines"),
-  context: z5.number().optional().describe("Lines of context before and after each match"),
-  head_limit: z5.number().optional().describe("Max results to return (default 250, 0 for unlimited)")
-});
-var DEFAULT_HEAD_LIMIT = 250;
-var GrepTool = {
-  name: "Grep",
-  description: "Search file contents using ripgrep. Supports regex, glob/type filtering, context lines, multiline mode, and multiple output modes.",
-  inputSchema: INPUT_SCHEMA5,
-  isReadOnly: true,
-  async call(input, context) {
-    const parsed = INPUT_SCHEMA5.parse(input);
-    const searchPath = parsed.path ? resolve4(context.cwd, parsed.path) : context.cwd;
-    const mode = parsed.output_mode ?? "files_with_matches";
-    const headLimit = parsed.head_limit ?? DEFAULT_HEAD_LIMIT;
-    const args = [
-      "--hidden",
-      "--glob",
-      "!.git",
-      "--glob",
-      "!.svn",
-      "--glob",
-      "!node_modules",
-      "--max-columns",
-      "500"
-    ];
-    if (mode === "files_with_matches") args.push("-l");
-    else if (mode === "count") args.push("-c");
-    else args.push("-n");
-    if (parsed.case_insensitive) args.push("-i");
-    if (parsed.glob) args.push("--glob", parsed.glob);
-    if (parsed.type) args.push("--type", parsed.type);
-    if (parsed.multiline) {
-      args.push("-U", "--multiline-dotall");
-    }
-    if (parsed.context && parsed.context > 0 && mode === "content") {
-      args.push("-C", String(parsed.context));
-    }
-    if (parsed.pattern.startsWith("-")) {
-      args.push("-e", parsed.pattern);
-    } else {
-      args.push(parsed.pattern);
-    }
-    args.push(searchPath);
-    return new Promise((resolve7) => {
-      execFile("rg", args, { maxBuffer: 10 * 1024 * 1024, timeout: 3e4 }, (err, stdout, stderr) => {
-        if (err && !stdout) {
-          if (err.code === 1 || err.code === "1") {
-            resolve7({ output: "No matches found." });
-            return;
-          }
-          resolve7({ output: `Grep error: ${stderr || err.message}`, isError: true });
-          return;
-        }
-        const lines = stdout.trim().split("\n").filter(Boolean);
-        const limited = headLimit > 0 ? lines.slice(0, headLimit) : lines;
-        let output = limited.join("\n");
-        if (headLimit > 0 && lines.length > headLimit) {
-          output += `
-... (${lines.length - headLimit} more results)`;
-        }
-        if (mode === "count") {
-          const total = lines.reduce((sum, line) => {
-            const count = parseInt(line.split(":").pop() || "0", 10);
-            return sum + (isNaN(count) ? 0 : count);
-          }, 0);
-          output = `${total} matches across ${lines.length} files
-${output}`;
-        }
-        resolve7({ output: output || "No matches found." });
-      });
-    });
-  },
-  toOllamaToolDef() {
-    return buildOllamaToolDef(this);
-  }
-};
-
-// src/tools/glob.ts
-import { execFile as execFile2 } from "child_process";
-import { resolve as resolve5 } from "path";
-import { z as z6 } from "zod";
-var INPUT_SCHEMA6 = z6.object({
-  pattern: z6.string().describe('Glob pattern to match files (e.g. "**/*.ts", "src/**/*.tsx")'),
-  path: z6.string().optional().describe("Directory to search in (default: cwd)")
-});
-var MAX_RESULTS = 100;
-var GlobTool = {
-  name: "Glob",
-  description: "Find files by glob pattern. Returns matching file paths sorted by modification time. Use for locating files by name or extension.",
-  inputSchema: INPUT_SCHEMA6,
-  isReadOnly: true,
-  async call(input, context) {
-    const parsed = INPUT_SCHEMA6.parse(input);
-    const searchPath = parsed.path ? resolve5(context.cwd, parsed.path) : context.cwd;
-    const args = [
-      "--files",
-      "--hidden",
-      "--glob",
-      parsed.pattern,
-      "--glob",
-      "!.git",
-      "--glob",
-      "!node_modules",
-      "--sort=modified",
-      searchPath
-    ];
-    return new Promise((resolve7) => {
-      execFile2("rg", args, { maxBuffer: 10 * 1024 * 1024, timeout: 3e4 }, (err, stdout, stderr) => {
-        if (err && !stdout) {
-          if (err.code === 1 || err.code === "1") {
-            resolve7({ output: "No files matched." });
-            return;
-          }
-          resolve7({ output: `Glob error: ${stderr || err.message}`, isError: true });
-          return;
-        }
-        const files = stdout.trim().split("\n").filter(Boolean);
-        const limited = files.slice(0, MAX_RESULTS);
-        let output = limited.join("\n");
-        if (files.length > MAX_RESULTS) {
-          output += `
-... (${files.length - MAX_RESULTS} more files)`;
-        }
-        if (!output) {
-          output = "No files matched.";
-        }
-        resolve7({ output });
-      });
-    });
-  },
-  toOllamaToolDef() {
-    return buildOllamaToolDef(this);
-  }
-};
-
-// src/tools/web-fetch.ts
-import { z as z7 } from "zod";
-var INPUT_SCHEMA7 = z7.object({
-  url: z7.string().describe("The URL to fetch"),
-  max_length: z7.number().optional().describe("Maximum response length in characters (default 10000)")
-});
-var DEFAULT_MAX_LENGTH = 1e4;
-var WebFetchTool = {
-  name: "WebFetch",
-  description: "Fetch a URL and return its text content. Useful for reading documentation, APIs, or web pages.",
-  inputSchema: INPUT_SCHEMA7,
-  isReadOnly: true,
-  async call(input, _context) {
-    const parsed = INPUT_SCHEMA7.parse(input);
-    const maxLen = parsed.max_length ?? DEFAULT_MAX_LENGTH;
-    try {
-      const controller = new AbortController();
-      const timeout = setTimeout(() => controller.abort(), 3e4);
-      const response = await fetch(parsed.url, {
-        headers: {
-          "User-Agent": "Darkfoo-Code/0.1 (Local AI Assistant)",
-          "Accept": "text/html,text/plain,application/json,*/*"
-        },
-        signal: controller.signal
-      });
-      clearTimeout(timeout);
-      if (!response.ok) {
-        return { output: `HTTP ${response.status}: ${response.statusText}`, isError: true };
-      }
-      const contentType = response.headers.get("content-type") || "";
-      let text = await response.text();
-      if (contentType.includes("html")) {
-        text = stripHtml(text);
-      }
-      if (text.length > maxLen) {
-        text = text.slice(0, maxLen) + `
-... (truncated, ${text.length} total chars)`;
-      }
-      return { output: text || "(empty response)" };
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return { output: `Fetch error: ${msg}`, isError: true };
-    }
-  },
-  toOllamaToolDef() {
-    return buildOllamaToolDef(this);
-  }
-};
-function stripHtml(html) {
-  return html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&nbsp;/g, " ").replace(/\s+/g, " ").replace(/\n\s*\n/g, "\n\n").trim();
-}
-
-// src/tools/web-search.ts
-import { z as z8 } from "zod";
-var INPUT_SCHEMA8 = z8.object({
-  query: z8.string().describe("The search query"),
-  max_results: z8.number().optional().describe("Maximum number of results (default 5)")
-});
-var WebSearchTool = {
-  name: "WebSearch",
-  description: "Search the web using DuckDuckGo. Returns titles, URLs, and snippets for the top results.",
-  inputSchema: INPUT_SCHEMA8,
-  isReadOnly: true,
-  async call(input, _context) {
-    const parsed = INPUT_SCHEMA8.parse(input);
-    const maxResults = parsed.max_results ?? 5;
-    try {
-      const encoded = encodeURIComponent(parsed.query);
-      const url = `https://html.duckduckgo.com/html/?q=${encoded}`;
-      const response = await fetch(url, {
-        headers: {
-          "User-Agent": "Darkfoo-Code/0.1 (Local AI Assistant)"
-        },
-        signal: AbortSignal.timeout(15e3)
-      });
-      if (!response.ok) {
-        return { output: `Search failed: HTTP ${response.status}`, isError: true };
-      }
-      const html = await response.text();
-      const results = parseSearchResults(html, maxResults);
-      if (results.length === 0) {
-        return { output: `No results found for: ${parsed.query}` };
-      }
-      const output = results.map((r, i) => `${i + 1}. ${r.title}
-   ${r.url}
-   ${r.snippet}`).join("\n\n");
-      return { output };
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return { output: `Search error: ${msg}`, isError: true };
-    }
-  },
-  toOllamaToolDef() {
-    return buildOllamaToolDef(this);
-  }
-};
-function parseSearchResults(html, max) {
-  const results = [];
-  const resultBlocks = html.split('class="result__a"');
-  for (let i = 1; i < resultBlocks.length && results.length < max; i++) {
-    const block = resultBlocks[i];
-    const hrefMatch = block.match(/href="([^"]+)"/);
-    let url = hrefMatch?.[1] || "";
-    const uddgMatch = url.match(/uddg=([^&]+)/);
-    if (uddgMatch) {
-      url = decodeURIComponent(uddgMatch[1]);
-    }
-    const titleMatch = block.match(/>([^<]+)<\/a>/);
-    const title = titleMatch?.[1]?.trim() || "Untitled";
-    const snippetSection = resultBlocks[i + 1] || block;
-    const snippetMatch = snippetSection.match(/class="result__snippet"[^>]*>([^<]+)/);
-    const snippet = snippetMatch?.[1]?.trim() || "";
-    if (url && !url.startsWith("/")) {
-      results.push({ title: stripTags(title), url, snippet: stripTags(snippet) });
-    }
-  }
-  return results;
-}
-function stripTags(text) {
-  return text.replace(/<[^>]+>/g, "").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').trim();
-}
-
-// src/tools/agent.ts
-import { z as z9 } from "zod";
-var INPUT_SCHEMA9 = z9.object({
-  prompt: z9.string().describe("The task for the sub-agent to perform"),
-  description: z9.string().optional().describe("Short description of what the agent will do")
-});
-var MAX_TURNS = 15;
-var AgentTool = {
-  name: "Agent",
-  description: "Launch a sub-agent to handle a complex task autonomously with its own isolated context. Use for research, multi-step exploration, or parallel work that should not pollute the main conversation.",
-  inputSchema: INPUT_SCHEMA9,
-  isReadOnly: false,
-  async call(input, context) {
-    const parsed = INPUT_SCHEMA9.parse(input);
-    const tools = getTools().filter((t) => t.name !== "Agent");
-    const ollamaTools = tools.map((t) => t.toOllamaToolDef());
-    const model = process.env.DARKFOO_MODEL || "llama3.1:8b";
-    const systemPrompt = await buildSystemPrompt(tools, context.cwd);
-    const messages = [
-      { role: "system", content: systemPrompt },
-      { role: "user", content: parsed.prompt }
-    ];
-    let turns = 0;
-    let finalContent = "";
-    while (turns < MAX_TURNS) {
-      turns++;
-      let assistantContent = "";
-      const toolCalls = [];
-      const provider = getProvider();
-      for await (const event of provider.chatStream({
-        model,
-        messages,
-        tools: ollamaTools,
-        signal: context.abortSignal
-      })) {
-        if (event.type === "text_delta") assistantContent += event.text;
-        if (event.type === "tool_call") toolCalls.push(event.toolCall);
-        if (event.type === "error") return { output: `Agent error: ${event.error}`, isError: true };
-      }
-      messages.push({
-        role: "assistant",
-        content: assistantContent,
-        ...toolCalls.length > 0 ? { tool_calls: toolCalls } : {}
-      });
-      if (toolCalls.length === 0) {
-        finalContent = assistantContent;
-        break;
-      }
-      for (const tc of toolCalls) {
-        const tool = tools.find((t) => t.name.toLowerCase() === tc.function.name.toLowerCase());
-        if (!tool) {
-          messages.push({ role: "tool", content: `Unknown tool: ${tc.function.name}` });
-          continue;
-        }
-        let result;
-        try {
-          result = await tool.call(tc.function.arguments, context);
-        } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          result = { output: `Error: ${msg}`, isError: true };
-        }
-        messages.push({ role: "tool", content: result.output });
-      }
-    }
-    if (!finalContent && turns >= MAX_TURNS) {
-      finalContent = "(Agent reached max turns without final response)";
-    }
-    return { output: finalContent };
-  },
-  toOllamaToolDef() {
-    return buildOllamaToolDef(this);
-  }
-};
-
-// src/tools/notebook-edit.ts
-import { readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
-import { resolve as resolve6 } from "path";
-import { z as z10 } from "zod";
-var INPUT_SCHEMA10 = z10.object({
-  file_path: z10.string().describe("Path to the .ipynb notebook file"),
-  cell_index: z10.number().describe("Index of the cell to edit (0-based)"),
-  new_source: z10.string().describe("New source content for the cell"),
-  cell_type: z10.enum(["code", "markdown"]).optional().describe("Change cell type")
-});
-var NotebookEditTool = {
-  name: "NotebookEdit",
-  description: "Edit a Jupyter notebook (.ipynb) cell by index. Reads the notebook, modifies the specified cell, and writes it back.",
-  inputSchema: INPUT_SCHEMA10,
-  isReadOnly: false,
-  async call(input, context) {
-    const parsed = INPUT_SCHEMA10.parse(input);
-    const filePath = resolve6(context.cwd, parsed.file_path);
-    try {
-      const raw = await readFile4(filePath, "utf-8");
-      const notebook = JSON.parse(raw);
-      if (parsed.cell_index < 0 || parsed.cell_index >= notebook.cells.length) {
-        return {
-          output: `Cell index ${parsed.cell_index} out of range (notebook has ${notebook.cells.length} cells).`,
-          isError: true
-        };
-      }
-      const cell = notebook.cells[parsed.cell_index];
-      const oldSource = cell.source.join("");
-      cell.source = parsed.new_source.split("\n").map(
-        (line, i, arr) => i < arr.length - 1 ? line + "\n" : line
-      );
-      if (parsed.cell_type) {
-        cell.cell_type = parsed.cell_type;
-      }
-      if (cell.cell_type === "code") {
-        cell.outputs = [];
-        cell.execution_count = null;
-      }
-      await writeFile4(filePath, JSON.stringify(notebook, null, 1) + "\n", "utf-8");
-      return {
-        output: `Updated cell ${parsed.cell_index} in ${filePath} (${cell.cell_type}). Old length: ${oldSource.length}, new length: ${parsed.new_source.length}.`
-      };
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return { output: `NotebookEdit error: ${msg}`, isError: true };
-    }
-  },
-  toOllamaToolDef() {
-    return buildOllamaToolDef(this);
-  }
-};
-
-// src/tools/plan.ts
-import { z as z11 } from "zod";
-
-// src/state.ts
-var state = {
-  planMode: false,
-  tasks: [],
-  pendingQuestion: null
-};
-function getAppState() {
-  return state;
-}
-function updateAppState(updater) {
-  state = updater(state);
-}
-
-// src/tools/plan.ts
-var ENTER_SCHEMA = z11.object({});
-var EnterPlanModeTool = {
-  name: "EnterPlanMode",
-  description: "Enter plan mode for designing an implementation approach before writing code. In plan mode you should explore the codebase with read-only tools (Read, Grep, Glob) and design a plan. Do NOT edit files in plan mode.",
-  inputSchema: ENTER_SCHEMA,
-  isReadOnly: true,
-  async call(_input, _context) {
-    updateAppState((s) => ({ ...s, planMode: true }));
-    return {
-      output: "Entered plan mode. Explore the codebase and design your approach. Use ExitPlanMode when your plan is ready for user approval. Do NOT edit files while in plan mode."
-    };
-  },
-  toOllamaToolDef() {
-    return buildOllamaToolDef(this);
-  }
-};
-var EXIT_SCHEMA = z11.object({
-  plan: z11.string().describe("The implementation plan to present to the user for approval")
-});
-var ExitPlanModeTool = {
-  name: "ExitPlanMode",
-  description: "Exit plan mode and present your implementation plan to the user for approval. Include the plan summary as the argument.",
-  inputSchema: EXIT_SCHEMA,
-  isReadOnly: true,
-  async call(input, _context) {
-    const parsed = EXIT_SCHEMA.parse(input);
-    updateAppState((s) => ({ ...s, planMode: false }));
-    return {
-      output: `Plan submitted for user approval:
-
-${parsed.plan}
-
-Plan mode exited. Waiting for user to approve or provide feedback.`
-    };
-  },
-  toOllamaToolDef() {
-    return buildOllamaToolDef(this);
-  }
-};
-
-// src/tools/tasks.ts
-import { nanoid as nanoid2 } from "nanoid";
-import { z as z12 } from "zod";
-var CREATE_SCHEMA = z12.object({
-  subject: z12.string().describe("Brief title for the task"),
-  description: z12.string().describe("What needs to be done")
-});
-var TaskCreateTool = {
-  name: "TaskCreate",
-  description: "Create a new task to track work progress. Use for multi-step tasks.",
-  inputSchema: CREATE_SCHEMA,
-  isReadOnly: false,
-  async call(input, _context) {
-    const parsed = CREATE_SCHEMA.parse(input);
-    const task = {
-      id: nanoid2(8),
-      subject: parsed.subject,
-      description: parsed.description,
-      status: "pending",
-      createdAt: Date.now()
-    };
-    updateAppState((s) => ({ ...s, tasks: [...s.tasks, task] }));
-    return { output: `Task #${task.id} created: ${task.subject}` };
-  },
-  toOllamaToolDef() {
-    return buildOllamaToolDef(this);
-  }
-};
-var UPDATE_SCHEMA = z12.object({
-  taskId: z12.string().describe("The task ID to update"),
-  status: z12.enum(["pending", "in_progress", "completed"]).optional().describe("New status"),
-  subject: z12.string().optional().describe("Updated subject"),
-  description: z12.string().optional().describe("Updated description")
-});
-var TaskUpdateTool = {
-  name: "TaskUpdate",
-  description: "Update a task status or details. Mark as in_progress when starting, completed when done.",
-  inputSchema: UPDATE_SCHEMA,
-  isReadOnly: false,
-  async call(input, _context) {
-    const parsed = UPDATE_SCHEMA.parse(input);
-    const state2 = getAppState();
-    const task = state2.tasks.find((t) => t.id === parsed.taskId);
-    if (!task) return { output: `Task ${parsed.taskId} not found.`, isError: true };
-    updateAppState((s) => ({
-      ...s,
-      tasks: s.tasks.map((t) => {
-        if (t.id !== parsed.taskId) return t;
-        return {
-          ...t,
-          ...parsed.status && { status: parsed.status },
-          ...parsed.subject && { subject: parsed.subject },
-          ...parsed.description && { description: parsed.description }
-        };
-      })
-    }));
-    return { output: `Task #${parsed.taskId} updated${parsed.status ? ` \u2192 ${parsed.status}` : ""}.` };
-  },
-  toOllamaToolDef() {
-    return buildOllamaToolDef(this);
-  }
-};
-var LIST_SCHEMA = z12.object({});
-var TaskListTool = {
-  name: "TaskList",
-  description: "List all tasks with their status.",
-  inputSchema: LIST_SCHEMA,
-  isReadOnly: true,
-  async call(_input, _context) {
-    const { tasks } = getAppState();
-    if (tasks.length === 0) return { output: "No tasks." };
-    const statusIcon = { pending: "\u25CB", in_progress: "\u25D1", completed: "\u25CF" };
-    const lines = tasks.map(
-      (t) => `${statusIcon[t.status]} #${t.id} [${t.status}] ${t.subject}`
-    );
-    return { output: lines.join("\n") };
-  },
-  toOllamaToolDef() {
-    return buildOllamaToolDef(this);
-  }
-};
-var GET_SCHEMA = z12.object({
-  taskId: z12.string().describe("The task ID to retrieve")
-});
-var TaskGetTool = {
-  name: "TaskGet",
-  description: "Get details of a specific task by ID.",
-  inputSchema: GET_SCHEMA,
-  isReadOnly: true,
-  async call(input, _context) {
-    const parsed = GET_SCHEMA.parse(input);
-    const { tasks } = getAppState();
-    const task = tasks.find((t) => t.id === parsed.taskId);
-    if (!task) return { output: `Task ${parsed.taskId} not found.`, isError: true };
-    return {
-      output: [
-        `Task #${task.id}`,
-        `Subject: ${task.subject}`,
-        `Status: ${task.status}`,
-        `Description: ${task.description}`
-      ].join("\n")
-    };
-  },
-  toOllamaToolDef() {
-    return buildOllamaToolDef(this);
-  }
-};
-
-// src/tools/ask.ts
-import { z as z13 } from "zod";
-var INPUT_SCHEMA11 = z13.object({
-  question: z13.string().describe("The question to ask the user")
-});
-var AskUserQuestionTool = {
-  name: "AskUserQuestion",
-  description: "Ask the user a question when you need clarification or input before proceeding. The query loop will pause until the user responds.",
-  inputSchema: INPUT_SCHEMA11,
-  isReadOnly: true,
-  async call(input, _context) {
-    const parsed = INPUT_SCHEMA11.parse(input);
-    updateAppState((s) => ({ ...s, pendingQuestion: parsed.question }));
-    return {
-      output: `Question posed to user: ${parsed.question}
-Waiting for user response...`
-    };
-  },
-  toOllamaToolDef() {
-    return buildOllamaToolDef(this);
-  }
-};
-
-// src/tools/index.ts
-function getTools() {
-  return [
-    BashTool,
-    ReadTool,
-    WriteTool,
-    EditTool,
-    GrepTool,
-    GlobTool,
-    WebFetchTool,
-    WebSearchTool,
-    AgentTool,
-    NotebookEditTool,
-    EnterPlanModeTool,
-    ExitPlanModeTool,
-    TaskCreateTool,
-    TaskUpdateTool,
-    TaskListTool,
-    TaskGetTool,
-    AskUserQuestionTool
-  ];
-}
-function getToolByName(name) {
-  return getTools().find((t) => t.name.toLowerCase() === name.toLowerCase());
-}
-
-export {
-  truncate,
-  getAppState,
-  trackedFileCount,
-  BashTool,
-  ReadTool,
-  WriteTool,
-  EditTool,
-  GrepTool,
-  GlobTool,
-  getTools,
-  getToolByName
-};