darkfoo-code 0.1.2 → 0.1.4

package/dist/main.js

@@ -1,29 +1,1914 @@
-import {
-  theme
-} from "./chunk-BT7IPQDS.js";
-import {
-  query
-} from "./chunk-GQXUHUV4.js";
-import {
-  BashTool,
-  getAppState,
-  getTools,
-  trackedFileCount,
-  truncate
-} from "./chunk-4KTJEE4A.js";
-import {
-  discoverProviders,
-  getActiveProviderName,
-  getProvider,
-  getProviderConfigs,
-  loadProviderSettings,
-  saveProviderSettings,
-  setActiveProvider,
-  upsertProviderConfig
-} from "./chunk-OBL22IIN.js";
-import {
-  buildSystemPrompt
-} from "./chunk-VSJKCANO.js";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/utils/theme.ts
+var theme_exports = {};
+__export(theme_exports, {
+  theme: () => theme
+});
+var theme;
+var init_theme = __esm({
+  "src/utils/theme.ts"() {
+    "use strict";
+    theme = {
+      cyan: "#5eead4",
+      cyanDim: "#3ab5a0",
+      pink: "#f472b6",
+      pinkDim: "#c2588e",
+      purple: "#a78bfa",
+      green: "#4ade80",
+      yellow: "#fbbf24",
+      red: "#ef4444",
+      text: "#e2e8f0",
+      dim: "#7e8ea6",
+      surface: "#111827",
+      bg: "#0c1021"
+    };
+  }
+});
+
+// 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) + "...";
+}
+var init_format = __esm({
+  "src/utils/format.ts"() {
+    "use strict";
+  }
+});
+
+// src/state.ts
+function getAppState() {
+  return state;
+}
+function updateAppState(updater) {
+  state = updater(state);
+}
+var state;
+var init_state = __esm({
+  "src/state.ts"() {
+    "use strict";
+    state = {
+      planMode: false,
+      tasks: [],
+      pendingQuestion: null
+    };
+  }
+});
+
+// src/providers/ollama.ts
+function normalizeToolCall(tc) {
+  let args = tc.function.arguments;
+  if (typeof args === "string") {
+    try {
+      args = JSON.parse(args);
+    } catch {
+      args = {};
+    }
+  }
+  return { function: { name: tc.function.name, arguments: args } };
+}
+var OllamaProvider;
+var init_ollama = __esm({
+  "src/providers/ollama.ts"() {
+    "use strict";
+    OllamaProvider = class {
+      name = "ollama";
+      label;
+      baseUrl;
+      constructor(baseUrl = "http://localhost:11434", label = "Ollama") {
+        this.baseUrl = baseUrl.replace(/\/$/, "");
+        this.label = label;
+      }
+      async *chatStream(params) {
+        const body = {
+          model: params.model,
+          messages: params.messages,
+          stream: true
+        };
+        if (params.tools && params.tools.length > 0) {
+          body.tools = params.tools;
+        }
+        let response;
+        try {
+          response = await fetch(`${this.baseUrl}/api/chat`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+            signal: params.signal
+          });
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          yield { type: "error", error: `Failed to connect to Ollama at ${this.baseUrl}: ${msg}` };
+          return;
+        }
+        if (!response.ok) {
+          const text = await response.text().catch(() => "unknown error");
+          yield { type: "error", error: `Ollama error ${response.status}: ${text}` };
+          return;
+        }
+        if (!response.body) {
+          yield { type: "error", error: "No response body from Ollama" };
+          return;
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            buffer += decoder.decode(value, { stream: true });
+            let newlineIdx;
+            while ((newlineIdx = buffer.indexOf("\n")) !== -1) {
+              const line = buffer.slice(0, newlineIdx).trim();
+              buffer = buffer.slice(newlineIdx + 1);
+              if (!line) continue;
+              let chunk;
+              try {
+                chunk = JSON.parse(line);
+              } catch {
+                continue;
+              }
+              if (chunk.message.content) {
+                yield { type: "text_delta", text: chunk.message.content };
+              }
+              if (chunk.message.tool_calls) {
+                for (const tc of chunk.message.tool_calls) {
+                  yield { type: "tool_call", toolCall: normalizeToolCall(tc) };
+                }
+              }
+            }
+          }
+        } finally {
+          reader.releaseLock();
+        }
+      }
+      async chat(params) {
+        let content = "";
+        const toolCalls = [];
+        for await (const event of this.chatStream(params)) {
+          if (event.type === "text_delta") content += event.text;
+          if (event.type === "tool_call") toolCalls.push(event.toolCall);
+        }
+        return { content, toolCalls };
+      }
+      async listModels() {
+        try {
+          const res = await fetch(`${this.baseUrl}/api/tags`);
+          const data = await res.json();
+          return data.models.map((m) => ({ name: m.name, size: m.details.parameter_size, family: m.details.family }));
+        } catch {
+          return [];
+        }
+      }
+      async healthCheck() {
+        try {
+          const res = await fetch(`${this.baseUrl}/api/tags`, { signal: AbortSignal.timeout(5e3) });
+          return res.ok;
+        } catch {
+          return false;
+        }
+      }
+    };
+  }
+});
+
+// src/providers/openai-compat.ts
+var OpenAICompatProvider;
+var init_openai_compat = __esm({
+  "src/providers/openai-compat.ts"() {
+    "use strict";
+    OpenAICompatProvider = class {
+      name;
+      label;
+      baseUrl;
+      apiKey;
+      constructor(baseUrl, label, name = "openai", apiKey = "") {
+        this.baseUrl = baseUrl.replace(/\/$/, "");
+        this.label = label;
+        this.name = name;
+        this.apiKey = apiKey;
+      }
+      async *chatStream(params) {
+        const headers = { "Content-Type": "application/json" };
+        if (this.apiKey) headers["Authorization"] = `Bearer ${this.apiKey}`;
+        const messages = params.messages.map((m) => {
+          const msg = { role: m.role, content: m.content };
+          if (m.tool_calls) msg.tool_calls = m.tool_calls;
+          return msg;
+        });
+        const body = {
+          model: params.model,
+          messages,
+          stream: true
+        };
+        if (params.tools && params.tools.length > 0) {
+          body.tools = params.tools.map((t) => ({
+            type: "function",
+            function: {
+              name: t.function.name,
+              description: t.function.description,
+              parameters: t.function.parameters
+            }
+          }));
+        }
+        let response;
+        try {
+          response = await fetch(`${this.baseUrl}/v1/chat/completions`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+            signal: params.signal
+          });
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          yield { type: "error", error: `Failed to connect to ${this.label} at ${this.baseUrl}: ${msg}` };
+          return;
+        }
+        if (!response.ok) {
+          const text = await response.text().catch(() => "unknown error");
+          yield { type: "error", error: `${this.label} error ${response.status}: ${text}` };
+          return;
+        }
+        if (!response.body) {
+          yield { type: "error", error: `No response body from ${this.label}` };
+          return;
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        const pendingToolCalls = /* @__PURE__ */ new Map();
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            buffer += decoder.decode(value, { stream: true });
+            let newlineIdx;
+            while ((newlineIdx = buffer.indexOf("\n")) !== -1) {
+              const line = buffer.slice(0, newlineIdx).trim();
+              buffer = buffer.slice(newlineIdx + 1);
+              if (!line || line === "data: [DONE]") continue;
+              if (!line.startsWith("data: ")) continue;
+              const jsonStr = line.slice(6);
+              let chunk;
+              try {
+                chunk = JSON.parse(jsonStr);
+              } catch {
+                continue;
+              }
+              const delta = chunk.choices?.[0]?.delta;
+              if (!delta) continue;
+              if (delta.content) {
+                yield { type: "text_delta", text: delta.content };
+              }
+              if (delta.tool_calls) {
+                for (const tc of delta.tool_calls) {
+                  const idx = tc.index ?? 0;
+                  if (!pendingToolCalls.has(idx)) {
+                    pendingToolCalls.set(idx, { name: "", arguments: "" });
+                  }
+                  const pending = pendingToolCalls.get(idx);
+                  if (tc.function?.name) pending.name = tc.function.name;
+                  if (tc.function?.arguments) pending.arguments += tc.function.arguments;
+                }
+              }
+              const finishReason = chunk.choices?.[0]?.finish_reason;
+              if (finishReason === "tool_calls" || finishReason === "stop") {
+                for (const [, tc] of pendingToolCalls) {
+                  if (tc.name) {
+                    let args = {};
+                    try {
+                      args = JSON.parse(tc.arguments);
+                    } catch {
+                    }
+                    yield { type: "tool_call", toolCall: { function: { name: tc.name, arguments: args } } };
+                  }
+                }
+                pendingToolCalls.clear();
+              }
+            }
+          }
+          for (const [, tc] of pendingToolCalls) {
+            if (tc.name) {
+              let args = {};
+              try {
+                args = JSON.parse(tc.arguments);
+              } catch {
+              }
+              yield { type: "tool_call", toolCall: { function: { name: tc.name, arguments: args } } };
+            }
+          }
+        } finally {
+          reader.releaseLock();
+        }
+      }
+      async chat(params) {
+        let content = "";
+        const toolCalls = [];
+        for await (const event of this.chatStream(params)) {
+          if (event.type === "text_delta") content += event.text;
+          if (event.type === "tool_call") toolCalls.push(event.toolCall);
+        }
+        return { content, toolCalls };
+      }
+      async listModels() {
+        const headers = {};
+        if (this.apiKey) headers["Authorization"] = `Bearer ${this.apiKey}`;
+        try {
+          const res = await fetch(`${this.baseUrl}/v1/models`, { headers, signal: AbortSignal.timeout(5e3) });
+          const data = await res.json();
+          if (data.data) {
+            return data.data.map((m) => ({ name: m.id }));
+          }
+          if (data.models) {
+            return data.models.map((m) => ({ name: m.name || m.model || m.id || "unknown" }));
+          }
+          return [];
+        } catch {
+          return [];
+        }
+      }
+      async healthCheck() {
+        try {
+          const res = await fetch(`${this.baseUrl}/health`, { signal: AbortSignal.timeout(5e3) });
+          if (res.ok) return true;
+          const res2 = await fetch(`${this.baseUrl}/v1/models`, { signal: AbortSignal.timeout(5e3) });
+          return res2.ok;
+        } catch {
+          return false;
+        }
+      }
+    };
+  }
+});
+
+// src/providers/index.ts
+var providers_exports = {};
+__export(providers_exports, {
+  discoverProviders: () => discoverProviders,
+  getActiveProviderName: () => getActiveProviderName,
+  getProvider: () => getProvider,
+  getProviderByName: () => getProviderByName,
+  getProviderConfigs: () => getProviderConfigs,
+  loadProviderSettings: () => loadProviderSettings,
+  removeProviderConfig: () => removeProviderConfig,
+  saveProviderSettings: () => saveProviderSettings,
+  setActiveProvider: () => setActiveProvider,
+  upsertProviderConfig: () => upsertProviderConfig
+});
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { join } from "path";
+function createProvider(config) {
+  switch (config.type) {
+    case "ollama":
+      return new OllamaProvider(config.baseUrl, config.label);
+    case "openai":
+      return new OpenAICompatProvider(config.baseUrl, config.label, config.name, config.apiKey);
+    default:
+      throw new Error(`Unknown provider type: ${config.type}`);
+  }
+}
+function ensureProvider(name) {
+  if (providerInstances.has(name)) return providerInstances.get(name);
+  const config = providerConfigs.find((c) => c.name === name);
+  if (!config) throw new Error(`Unknown provider: ${name}`);
+  const provider = createProvider(config);
+  providerInstances.set(name, provider);
+  return provider;
+}
+function getProvider() {
+  return ensureProvider(activeProviderName);
+}
+function getProviderByName(name) {
+  const config = providerConfigs.find((c) => c.name === name);
+  if (!config) return null;
+  return ensureProvider(name);
+}
+function getActiveProviderName() {
+  return activeProviderName;
+}
+function setActiveProvider(name) {
+  const config = providerConfigs.find((c) => c.name === name);
+  if (!config) throw new Error(`Unknown provider: ${name}. Available: ${providerConfigs.map((c) => c.name).join(", ")}`);
+  activeProviderName = name;
+}
+function getProviderConfigs() {
+  return providerConfigs;
+}
+function upsertProviderConfig(config) {
+  const idx = providerConfigs.findIndex((c) => c.name === config.name);
+  if (idx >= 0) {
+    providerConfigs[idx] = config;
+  } else {
+    providerConfigs.push(config);
+  }
+  providerInstances.delete(config.name);
+}
+function removeProviderConfig(name) {
+  const idx = providerConfigs.findIndex((c) => c.name === name);
+  if (idx < 0) return false;
+  providerConfigs.splice(idx, 1);
+  providerInstances.delete(name);
+  if (activeProviderName === name) activeProviderName = "ollama";
+  return true;
+}
+async function loadProviderSettings() {
+  try {
+    const raw = await readFile(SETTINGS_PATH, "utf-8");
+    const settings = JSON.parse(raw);
+    if (settings.providers) {
+      for (const custom of settings.providers) {
+        upsertProviderConfig(custom);
+      }
+    }
+    if (settings.activeProvider) {
+      const config = providerConfigs.find((c) => c.name === settings.activeProvider);
+      if (config) activeProviderName = settings.activeProvider;
+    }
+  } catch {
+  }
+}
+async function saveProviderSettings() {
+  let settings = {};
+  try {
+    const raw = await readFile(SETTINGS_PATH, "utf-8");
+    settings = JSON.parse(raw);
+  } catch {
+  }
+  const customProviders = providerConfigs.filter(
+    (c) => !DEFAULT_PROVIDERS.some((d) => d.name === c.name && d.baseUrl === c.baseUrl)
+  );
+  settings.providers = customProviders;
+  settings.activeProvider = activeProviderName;
+  await mkdir(join(process.env.HOME || "~", ".darkfoo"), { recursive: true });
+  await writeFile(SETTINGS_PATH, JSON.stringify(settings, null, 2), "utf-8");
+}
+async function discoverProviders() {
+  const results = await Promise.all(
+    providerConfigs.map(async (config) => {
+      const provider = ensureProvider(config.name);
+      const online = await provider.healthCheck();
+      return { config, online };
+    })
+  );
+  return results;
+}
+var SETTINGS_PATH, DEFAULT_PROVIDERS, activeProviderName, providerConfigs, providerInstances;
+var init_providers = __esm({
+  "src/providers/index.ts"() {
+    "use strict";
+    init_ollama();
+    init_openai_compat();
+    SETTINGS_PATH = join(process.env.HOME || "~", ".darkfoo", "settings.json");
+    DEFAULT_PROVIDERS = [
+      { type: "ollama", name: "ollama", label: "Ollama", baseUrl: process.env.OLLAMA_HOST || "http://localhost:11434" },
+      { type: "openai", name: "llama-cpp", label: "llama.cpp", baseUrl: "http://localhost:8081" },
+      { type: "openai", name: "vllm", label: "vLLM", baseUrl: "http://localhost:8000" },
+      { type: "openai", name: "tgi", label: "TGI", baseUrl: "http://localhost:8090" },
+      { type: "openai", name: "lm-studio", label: "LM Studio", baseUrl: "http://localhost:1234" },
+      { type: "openai", name: "localai", label: "LocalAI", baseUrl: "http://localhost:8080" }
+    ];
+    activeProviderName = "ollama";
+    providerConfigs = [...DEFAULT_PROVIDERS];
+    providerInstances = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/file-tracker.ts
+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;
+}
+var readFiles;
+var init_file_tracker = __esm({
+  "src/file-tracker.ts"() {
+    "use strict";
+    readFiles = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/permissions.ts
+import { readFile as readFile4, writeFile as writeFile5, mkdir as mkdir5 } from "fs/promises";
+import { join as join5 } from "path";
+async function loadSettings() {
+  if (cachedSettings) return cachedSettings;
+  try {
+    const raw = await readFile4(SETTINGS_PATH3, "utf-8");
+    cachedSettings = JSON.parse(raw);
+    return cachedSettings;
+  } catch {
+    cachedSettings = { permissionMode: "default", alwaysAllow: [] };
+    return cachedSettings;
+  }
+}
+async function checkPermission(tool, args) {
+  const settings = await loadSettings();
+  if (settings.permissionMode === "auto") return "allow";
+  if (tool.isReadOnly) return "allow";
+  const argStr = JSON.stringify(args);
+  const matched = settings.alwaysAllow.find(
+    (r) => r.tool === tool.name && (!r.pattern || argStr.includes(r.pattern))
+  );
+  if (matched) return matched.decision;
+  return "ask";
+}
+var SETTINGS_PATH3, cachedSettings;
+var init_permissions = __esm({
+  "src/permissions.ts"() {
+    "use strict";
+    SETTINGS_PATH3 = join5(process.env.HOME || "~", ".darkfoo", "settings.json");
+    cachedSettings = null;
+  }
+});
+
+// src/query.ts
+var query_exports = {};
+__export(query_exports, {
+  query: () => query
+});
+import { nanoid as nanoid3 } from "nanoid";
+async function* query(params) {
+  const { model, tools, systemPrompt, signal } = params;
+  const messages = [...params.messages];
+  const maxTurns = params.maxTurns ?? 30;
+  let turns = 0;
+  const ollamaTools = tools.map((t) => t.toOllamaToolDef());
+  while (turns < maxTurns) {
+    turns++;
+    const ollamaMessages = toOllamaMessages(messages, systemPrompt);
+    let assistantContent = "";
+    const toolCalls = [];
+    const provider = getProvider();
+    for await (const event of provider.chatStream({ model, messages: ollamaMessages, tools: ollamaTools, signal })) {
+      yield event;
+      if (event.type === "text_delta") {
+        assistantContent += event.text;
+      }
+      if (event.type === "tool_call") {
+        toolCalls.push(event.toolCall);
+      }
+      if (event.type === "error") {
+        return;
+      }
+    }
+    const assistantMsg = {
+      id: nanoid3(),
+      role: "assistant",
+      content: assistantContent,
+      toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+      timestamp: Date.now()
+    };
+    messages.push(assistantMsg);
+    yield { type: "assistant_message", message: assistantMsg };
+    if (toolCalls.length === 0) return;
+    const readOnlyCalls = [];
+    const writeCalls = [];
+    const unknownCalls = [];
+    for (const tc of toolCalls) {
+      const tool = tools.find((t) => t.name.toLowerCase() === tc.function.name.toLowerCase());
+      if (!tool) {
+        unknownCalls.push(tc);
+      } else if (tool.isReadOnly) {
+        readOnlyCalls.push({ tc, tool });
+      } else {
+        writeCalls.push({ tc, tool });
+      }
+    }
+    for (const tc of unknownCalls) {
+      const errOutput = `Unknown tool: ${tc.function.name}`;
+      yield { type: "tool_result", toolName: tc.function.name, output: errOutput, isError: true };
+      messages.push({ id: nanoid3(), role: "tool", content: errOutput, toolName: tc.function.name, timestamp: Date.now() });
+    }
+    if (readOnlyCalls.length > 0) {
+      const results = await Promise.all(
+        readOnlyCalls.map(async ({ tc, tool }) => {
+          const coercedArgs = coerceToolArgs(tc.function.arguments, tool);
+          try {
+            return { tool, result: await tool.call(coercedArgs, { cwd: process.cwd(), abortSignal: signal }) };
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return { tool, result: { output: `Tool execution error: ${msg}`, isError: true } };
+          }
+        })
+      );
+      for (const { tool, result } of results) {
+        yield { type: "tool_result", toolName: tool.name, output: result.output, isError: result.isError ?? false };
+        messages.push({ id: nanoid3(), role: "tool", content: result.output, toolName: tool.name, timestamp: Date.now() });
+      }
+    }
+    for (const { tc, tool } of writeCalls) {
+      const coercedArgs = coerceToolArgs(tc.function.arguments, tool);
+      const permission = await checkPermission(tool, coercedArgs);
+      if (permission === "deny") {
+        const denied = "Tool blocked by permission rules.";
+        yield { type: "tool_result", toolName: tool.name, output: denied, isError: true };
+        messages.push({ id: nanoid3(), role: "tool", content: denied, toolName: tool.name, timestamp: Date.now() });
+        continue;
+      }
+      let result;
+      try {
+        result = await tool.call(coercedArgs, { cwd: process.cwd(), abortSignal: signal });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        result = { output: `Tool execution error: ${msg}`, isError: true };
+      }
+      yield { type: "tool_result", toolName: tool.name, output: result.output, isError: result.isError ?? false };
+      messages.push({ id: nanoid3(), role: "tool", content: result.output, toolName: tool.name, timestamp: Date.now() });
+    }
+  }
+  yield { type: "error", error: `Reached maximum of ${maxTurns} tool-use turns.` };
+}
+function toOllamaMessages(messages, systemPrompt) {
+  const result = [
+    { role: "system", content: systemPrompt }
+  ];
+  for (const msg of messages) {
+    if (msg.role === "assistant") {
+      const ollamaMsg = {
+        role: "assistant",
+        content: msg.content
+      };
+      if (msg.toolCalls) {
+        ollamaMsg.tool_calls = msg.toolCalls;
+      }
+      result.push(ollamaMsg);
+    } else if (msg.role === "tool") {
+      result.push({ role: "tool", content: msg.content });
+    } else if (msg.role === "user") {
+      result.push({ role: "user", content: msg.content });
+    }
+  }
+  return result;
+}
+function coerceToolArgs(args, tool) {
+  const shape = tool.inputSchema.shape;
+  if (!shape) return args;
+  const coerced = { ...args };
+  for (const [key, val] of Object.entries(coerced)) {
+    if (typeof val !== "string") continue;
+    const fieldDef = shape[key];
+    if (!fieldDef) continue;
+    const typeName = fieldDef._def?.typeName === "ZodOptional" ? fieldDef._def?.innerType?._def?.typeName : fieldDef._def?.typeName;
+    if (typeName === "ZodBoolean") {
+      coerced[key] = val === "true";
+    } else if (typeName === "ZodNumber") {
+      const num = Number(val);
+      if (!isNaN(num)) coerced[key] = num;
+    }
+  }
+  return coerced;
+}
+var init_query = __esm({
+  "src/query.ts"() {
+    "use strict";
+    init_providers();
+    init_permissions();
+  }
+});
+
+// src/context-loader.ts
+import { readFile as readFile5, readdir as readdir2, access } from "fs/promises";
+import { join as join6, dirname, resolve } from "path";
+async function loadProjectContext(cwd) {
+  const parts = [];
+  const globalContent = await tryRead(HOME_CONTEXT);
+  if (globalContent) {
+    parts.push(`# Global instructions (~/.darkfoo/DARKFOO.md)
+
+${globalContent}`);
+  }
+  const visited = /* @__PURE__ */ new Set();
+  let dir = resolve(cwd);
+  while (dir && !visited.has(dir)) {
+    visited.add(dir);
+    for (const file of CONTEXT_FILES) {
+      const filePath = join6(dir, file);
+      const content = await tryRead(filePath);
+      if (content) {
+        const rel = filePath.replace(cwd + "/", "");
+        parts.push(`# Project instructions (${rel})
+
+${content}`);
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  const rulesDir = join6(cwd, RULES_DIR);
+  try {
+    await access(rulesDir);
+    const files = await readdir2(rulesDir);
+    for (const file of files.filter((f) => f.endsWith(".md")).sort()) {
+      const content = await tryRead(join6(rulesDir, file));
+      if (content) {
+        parts.push(`# Rule: ${file}
+
+${content}`);
+      }
+    }
+  } catch {
+  }
+  return parts.join("\n\n---\n\n");
+}
+async function tryRead(path) {
+  try {
+    return await readFile5(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+var CONTEXT_FILES, RULES_DIR, HOME_CONTEXT;
+var init_context_loader = __esm({
+  "src/context-loader.ts"() {
+    "use strict";
+    CONTEXT_FILES = ["DARKFOO.md", ".darkfoo/DARKFOO.md"];
+    RULES_DIR = ".darkfoo/rules";
+    HOME_CONTEXT = join6(process.env.HOME || "~", ".darkfoo", "DARKFOO.md");
+  }
+});
+
+// src/system-prompt.ts
+var system_prompt_exports = {};
+__export(system_prompt_exports, {
+  buildSystemPrompt: () => buildSystemPrompt
+});
+async function buildSystemPrompt(tools, cwd) {
+  const toolDescriptions = tools.map((t) => {
+    const params = Object.keys(
+      t.inputSchema.shape ?? {}
+    );
+    return `### ${t.name}
+${t.description}
+Parameters: ${params.join(", ")}`;
+  }).join("\n\n");
+  const projectContext = await loadProjectContext(cwd);
+  let prompt = `You are Darkfoo Code, a local AI coding assistant.
+
+All text you output outside of tool use is displayed directly to the user. Use this to communicate, explain, and answer questions. You do NOT need to use a tool for every message.
+
+IMPORTANT: Only use tools when the task genuinely requires them \u2014 reading files, writing code, running commands, searching the codebase. For conversation, greetings, explanations, opinions, or questions that don't need filesystem or shell access, just respond with text. Never call a tool with empty or meaningless arguments.
+
+# Tools
+
+You have access to the following tools. Call them ONLY when needed:
+
+${toolDescriptions}
+
+# Tool usage guidelines
+
+- Read files before modifying them.
+- Use absolute file paths when calling tools.
+- Prefer Edit for targeted changes. Use Write only for new files or complete rewrites.
+- Prefer Grep over Bash with grep. Prefer Glob over Bash with find.
+- If a command fails, diagnose before retrying.
+- Do not make changes beyond what was asked.
+- When running shell commands, quote paths with spaces.
+- Use TaskCreate/TaskUpdate to track multi-step work.
+- Use EnterPlanMode before non-trivial implementation tasks.
+
+# Context
+
+- Working directory: ${cwd}
+- Date: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}
+- Platform: ${process.platform}
+- You are running locally with full filesystem access.
+
+# Style
+
+- Be concise and direct. Lead with the answer or action.
+- Use markdown formatting for code blocks, lists, and emphasis.
+- When referencing code, include the file path.
+`;
+  if (projectContext) {
+    prompt += `
+# Project Instructions
+
+${projectContext}
+`;
+  }
+  return prompt;
+}
+var init_system_prompt = __esm({
+  "src/system-prompt.ts"() {
+    "use strict";
+    init_context_loader();
+  }
+});
+
+// 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
+    }
+  };
+}
+var init_types = __esm({
+  "src/tools/types.ts"() {
+    "use strict";
+  }
+});
+
+// src/tools/bash.ts
+import { spawn } from "child_process";
+import { writeFile as writeFile6, mkdir as mkdir6, readFile as readFile6 } from "fs/promises";
+import { join as join7 } from "path";
+import { nanoid as nanoid4 } from "nanoid";
+import { z } from "zod";
+async function runInBackground(command, cwd) {
+  const taskId = nanoid4(8);
+  await mkdir6(BG_OUTPUT_DIR, { recursive: true });
+  const outputPath = join7(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 writeFile6(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 writeFile6(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)`
+  };
+}
+var INPUT_SCHEMA, MAX_OUTPUT, BG_OUTPUT_DIR, backgroundTasks, BashTool;
+var init_bash = __esm({
+  "src/tools/bash.ts"() {
+    "use strict";
+    init_types();
+    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")
+    });
+    MAX_OUTPUT = 1e5;
+    BG_OUTPUT_DIR = join7(process.env.HOME || "~", ".darkfoo", "bg-tasks");
+    backgroundTasks = /* @__PURE__ */ new Map();
+    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((resolve8) => {
+          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) => {
+            resolve8({ 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}`;
+            }
+            resolve8({ output, isError: code !== 0 });
+          });
+        });
+      },
+      toOllamaToolDef() {
+        return buildOllamaToolDef(this);
+      }
+    };
+  }
+});
+
+// src/tools/read.ts
+import { readFile as readFile7, stat } from "fs/promises";
+import { extname, resolve as resolve2 } from "path";
+import { z as z2 } from "zod";
+async function readImage(filePath, size) {
+  const ext = extname(filePath).toLowerCase();
+  if (ext === ".svg") {
+    const content = await readFile7(filePath, "utf-8");
+    return { output: `SVG image (${size} bytes):
+${content.slice(0, 5e3)}` };
+  }
+  const buffer = await readFile7(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: execFile6 } = await import("child_process");
+  return new Promise((resolve8) => {
+    execFile6("pdftotext", [filePath, "-"], { timeout: 15e3, maxBuffer: 5 * 1024 * 1024 }, (err, stdout) => {
+      if (err) {
+        resolve8({
+          output: `PDF file: ${filePath}
+(Install poppler-utils for text extraction: sudo dnf install poppler-utils)`
+        });
+        return;
+      }
+      const text = stdout.trim();
+      if (!text) {
+        resolve8({ 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;
+      resolve8({ 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;
+}
+var INPUT_SCHEMA2, DEFAULT_LIMIT, IMAGE_EXTS, PDF_EXT, ReadTool;
+var init_read = __esm({
+  "src/tools/read.ts"() {
+    "use strict";
+    init_file_tracker();
+    init_format();
+    init_types();
+    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)")
+    });
+    DEFAULT_LIMIT = 2e3;
+    IMAGE_EXTS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp", ".svg", ".ico"]);
+    PDF_EXT = ".pdf";
+    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 = resolve2(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 readFile7(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);
+      }
+    };
+  }
+});
+
+// src/tools/write.ts
+import { access as access2, mkdir as mkdir7, writeFile as writeFile7 } from "fs/promises";
+import { dirname as dirname2, resolve as resolve3 } from "path";
+import { z as z3 } from "zod";
+var INPUT_SCHEMA3, WriteTool;
+var init_write = __esm({
+  "src/tools/write.ts"() {
+    "use strict";
+    init_types();
+    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")
+    });
+    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 = resolve3(context.cwd, parsed.file_path);
+        try {
+          let existed = false;
+          try {
+            await access2(filePath);
+            existed = true;
+          } catch {
+          }
+          await mkdir7(dirname2(filePath), { recursive: true });
+          await writeFile7(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 readFile8, writeFile as writeFile8 } from "fs/promises";
+import { resolve as resolve4 } from "path";
+import { createPatch } from "diff";
+import { z as z4 } from "zod";
+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 INPUT_SCHEMA4, EditTool;
+var init_edit = __esm({
+  "src/tools/edit.ts"() {
+    "use strict";
+    init_file_tracker();
+    init_types();
+    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)")
+    });
+    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 = resolve4(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 readFile8(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 writeFile8(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 as execFile4 } from "child_process";
+import { resolve as resolve5 } from "path";
+import { z as z5 } from "zod";
+var INPUT_SCHEMA5, DEFAULT_HEAD_LIMIT, GrepTool;
+var init_grep = __esm({
+  "src/tools/grep.ts"() {
+    "use strict";
+    init_types();
+    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)")
+    });
+    DEFAULT_HEAD_LIMIT = 250;
+    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 ? resolve5(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((resolve8) => {
+          execFile4("rg", args, { maxBuffer: 10 * 1024 * 1024, timeout: 3e4 }, (err, stdout, stderr) => {
+            if (err && !stdout) {
+              if (err.code === 1 || err.code === "1") {
+                resolve8({ output: "No matches found." });
+                return;
+              }
+              resolve8({ 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}`;
+            }
+            resolve8({ output: output || "No matches found." });
+          });
+        });
+      },
+      toOllamaToolDef() {
+        return buildOllamaToolDef(this);
+      }
+    };
+  }
+});
+
+// src/tools/glob.ts
+import { execFile as execFile5 } from "child_process";
+import { resolve as resolve6 } from "path";
+import { z as z6 } from "zod";
+var INPUT_SCHEMA6, MAX_RESULTS, GlobTool;
+var init_glob = __esm({
+  "src/tools/glob.ts"() {
+    "use strict";
+    init_types();
+    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)")
+    });
+    MAX_RESULTS = 100;
+    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 ? resolve6(context.cwd, parsed.path) : context.cwd;
+        const args = [
+          "--files",
+          "--hidden",
+          "--glob",
+          parsed.pattern,
+          "--glob",
+          "!.git",
+          "--glob",
+          "!node_modules",
+          "--sort=modified",
+          searchPath
+        ];
+        return new Promise((resolve8) => {
+          execFile5("rg", args, { maxBuffer: 10 * 1024 * 1024, timeout: 3e4 }, (err, stdout, stderr) => {
+            if (err && !stdout) {
+              if (err.code === 1 || err.code === "1") {
+                resolve8({ output: "No files matched." });
+                return;
+              }
+              resolve8({ 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.";
+            }
+            resolve8({ output });
+          });
+        });
+      },
+      toOllamaToolDef() {
+        return buildOllamaToolDef(this);
+      }
+    };
+  }
+});
+
+// src/tools/web-fetch.ts
+import { z as z7 } from "zod";
+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();
+}
+var INPUT_SCHEMA7, DEFAULT_MAX_LENGTH, WebFetchTool;
+var init_web_fetch = __esm({
+  "src/tools/web-fetch.ts"() {
+    "use strict";
+    init_types();
+    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)")
+    });
+    DEFAULT_MAX_LENGTH = 1e4;
+    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);
+      }
+    };
+  }
+});
+
+// src/tools/web-search.ts
+import { z as z8 } from "zod";
+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();
+}
+var INPUT_SCHEMA8, WebSearchTool;
+var init_web_search = __esm({
+  "src/tools/web-search.ts"() {
+    "use strict";
+    init_types();
+    INPUT_SCHEMA8 = z8.object({
+      query: z8.string().describe("The search query"),
+      max_results: z8.number().optional().describe("Maximum number of results (default 5)")
+    });
+    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);
+      }
+    };
+  }
+});
+
+// src/tools/agent.ts
+import { z as z9 } from "zod";
+var INPUT_SCHEMA9, MAX_TURNS, AgentTool;
+var init_agent = __esm({
+  "src/tools/agent.ts"() {
+    "use strict";
+    init_providers();
+    init_system_prompt();
+    init_tools();
+    init_types();
+    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")
+    });
+    MAX_TURNS = 15;
+    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 readFile9, writeFile as writeFile9 } from "fs/promises";
+import { resolve as resolve7 } from "path";
+import { z as z10 } from "zod";
+var INPUT_SCHEMA10, NotebookEditTool;
+var init_notebook_edit = __esm({
+  "src/tools/notebook-edit.ts"() {
+    "use strict";
+    init_types();
+    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")
+    });
+    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 = resolve7(context.cwd, parsed.file_path);
+        try {
+          const raw = await readFile9(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 writeFile9(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";
+var ENTER_SCHEMA, EnterPlanModeTool, EXIT_SCHEMA, ExitPlanModeTool;
+var init_plan = __esm({
+  "src/tools/plan.ts"() {
+    "use strict";
+    init_state();
+    init_types();
+    ENTER_SCHEMA = z11.object({});
+    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);
+      }
+    };
+    EXIT_SCHEMA = z11.object({
+      plan: z11.string().describe("The implementation plan to present to the user for approval")
+    });
+    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 nanoid5 } from "nanoid";
+import { z as z12 } from "zod";
+var CREATE_SCHEMA, TaskCreateTool, UPDATE_SCHEMA, TaskUpdateTool, LIST_SCHEMA, TaskListTool, GET_SCHEMA, TaskGetTool;
+var init_tasks = __esm({
+  "src/tools/tasks.ts"() {
+    "use strict";
+    init_state();
+    init_types();
+    CREATE_SCHEMA = z12.object({
+      subject: z12.string().describe("Brief title for the task"),
+      description: z12.string().describe("What needs to be done")
+    });
+    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: nanoid5(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);
+      }
+    };
+    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")
+    });
+    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);
+      }
+    };
+    LIST_SCHEMA = z12.object({});
+    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);
+      }
+    };
+    GET_SCHEMA = z12.object({
+      taskId: z12.string().describe("The task ID to retrieve")
+    });
+    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, AskUserQuestionTool;
+var init_ask = __esm({
+  "src/tools/ask.ts"() {
+    "use strict";
+    init_state();
+    init_types();
+    INPUT_SCHEMA11 = z13.object({
+      question: z13.string().describe("The question to ask the user")
+    });
+    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
+var tools_exports = {};
+__export(tools_exports, {
+  BashTool: () => BashTool,
+  EditTool: () => EditTool,
+  GlobTool: () => GlobTool,
+  GrepTool: () => GrepTool,
+  ReadTool: () => ReadTool,
+  WriteTool: () => WriteTool,
+  getToolByName: () => getToolByName,
+  getTools: () => getTools
+});
+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());
+}
+var init_tools = __esm({
+  "src/tools/index.ts"() {
+    "use strict";
+    init_bash();
+    init_read();
+    init_write();
+    init_edit();
+    init_grep();
+    init_glob();
+    init_web_fetch();
+    init_web_search();
+    init_agent();
+    init_notebook_edit();
+    init_plan();
+    init_tasks();
+    init_ask();
+  }
+});
 
 // src/main.tsx
 import { Command } from "commander";
@@ -44,9 +1929,10 @@ function App({ model, systemPromptOverride, children }) {
 import { useState as useState2, useCallback as useCallback2, useEffect, useRef } from "react";
 import { Box as Box6, Text as Text6, useApp, useInput as useInput2 } from "ink";
 import Spinner2 from "ink-spinner";
-import { nanoid as nanoid3 } from "nanoid";
+import { nanoid as nanoid6 } from "nanoid";
 
 // src/components/Banner.tsx
+init_theme();
 import { Box, Text } from "ink";
 import { jsx as jsx2, jsxs } from "react/jsx-runtime";
 var LOGO_LINES = [
@@ -117,6 +2003,8 @@ function Banner({ model, cwd }) {
 }
 
 // src/components/Messages.tsx
+init_theme();
+init_format();
 import { Box as Box2, Text as Text2 } from "ink";
 
 // src/utils/markdown.ts
@@ -216,6 +2104,8 @@ function MessageRow({ message }) {
 }
 
 // src/components/ToolCall.tsx
+init_theme();
+init_format();
 import { Box as Box3, Text as Text3 } from "ink";
 import Spinner from "ink-spinner";
 import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
@@ -265,6 +2155,8 @@ function formatToolArgs(args) {
 }
 
 // src/components/StatusLine.tsx
+init_theme();
+init_state();
 import { Box as Box4, Text as Text4 } from "ink";
 import { Fragment, jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
 function getContextLimit(model) {
@@ -278,12 +2170,12 @@ function getContextLimit(model) {
   return 8192;
 }
 function StatusLine({ model, messageCount, tokenEstimate, isStreaming }) {
-  const state = getAppState();
+  const state2 = getAppState();
   const contextLimit = getContextLimit(model);
   const usage = Math.min(tokenEstimate / contextLimit, 1);
   const pct = (usage * 100).toFixed(0);
   const usageColor = usage > 0.8 ? theme.pink : usage > 0.5 ? theme.yellow : theme.cyan;
-  const activeTasks = state.tasks.filter((t) => t.status === "in_progress").length;
+  const activeTasks = state2.tasks.filter((t) => t.status === "in_progress").length;
   return /* @__PURE__ */ jsxs4(Box4, { marginTop: 1, children: [
     /* @__PURE__ */ jsxs4(Text4, { color: theme.dim, children: [
       "\u2500".repeat(2),
@@ -301,7 +2193,7 @@ function StatusLine({ model, messageCount, tokenEstimate, isStreaming }) {
       pct,
       "%"
     ] }),
-    state.planMode ? /* @__PURE__ */ jsxs4(Fragment, { children: [
+    state2.planMode ? /* @__PURE__ */ jsxs4(Fragment, { children: [
       /* @__PURE__ */ jsx5(Text4, { color: theme.dim, children: " \u2502 " }),
       /* @__PURE__ */ jsx5(Text4, { color: theme.yellow, bold: true, children: "PLAN" })
     ] }) : null,
@@ -325,6 +2217,7 @@ function StatusLine({ model, messageCount, tokenEstimate, isStreaming }) {
 }
 
 // src/components/UserInput.tsx
+init_theme();
 import { useState, useCallback } from "react";
 import { Box as Box5, Text as Text5, useInput } from "ink";
 import TextInput from "ink-text-input";
@@ -409,6 +2302,7 @@ var modelCommand = {
 };
 
 // src/commands/compact.ts
+init_providers();
 import { nanoid } from "nanoid";
 var compactCommand = {
   name: "compact",
@@ -536,19 +2430,19 @@ var diffCommand = {
   name: "diff",
   description: "Show uncommitted git changes",
   async execute(_args, context) {
-    return new Promise((resolve) => {
+    return new Promise((resolve8) => {
       execFile("git", ["diff", "--stat"], { cwd: context.cwd, timeout: 1e4 }, (err, stdout, stderr) => {
         if (err) {
-          resolve({ output: `Not a git repository or git error: ${stderr || err.message}`, silent: true });
+          resolve8({ output: `Not a git repository or git error: ${stderr || err.message}`, silent: true });
           return;
         }
         if (!stdout.trim()) {
           execFile("git", ["diff", "--cached", "--stat"], { cwd: context.cwd, timeout: 1e4 }, (err2, staged) => {
             if (err2 || !staged.trim()) {
-              resolve({ output: "No uncommitted changes.", silent: true });
+              resolve8({ output: "No uncommitted changes.", silent: true });
               return;
             }
-            resolve({ output: `\x1B[1m\x1B[36mStaged changes:\x1B[0m
+            resolve8({ output: `\x1B[1m\x1B[36mStaged changes:\x1B[0m
 ${staged}`, silent: true });
           });
           return;
@@ -562,7 +2456,7 @@ ${staged}`, silent: true });
             fullDiff ? fullDiff.slice(0, 3e3) : "",
             fullDiff && fullDiff.length > 3e3 ? "\n... (truncated)" : ""
           ].join("\n");
-          resolve({ output, silent: true });
+          resolve8({ output, silent: true });
         });
       });
     });
@@ -570,12 +2464,12 @@ ${staged}`, silent: true });
 };
 
 // src/session.ts
-import { mkdir, readdir, readFile, writeFile } from "fs/promises";
-import { join } from "path";
+import { mkdir as mkdir2, readdir, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { join as join2 } from "path";
 import { nanoid as nanoid2 } from "nanoid";
-var SESSIONS_DIR = join(process.env.HOME || "~", ".darkfoo", "sessions");
+var SESSIONS_DIR = join2(process.env.HOME || "~", ".darkfoo", "sessions");
 async function ensureDir() {
-  await mkdir(SESSIONS_DIR, { recursive: true });
+  await mkdir2(SESSIONS_DIR, { recursive: true });
 }
 function createSessionId() {
   return nanoid2(12);
@@ -594,11 +2488,11 @@ async function saveSession(id, messages, model, cwd) {
     messageCount: messages.length,
     messages
   };
-  await writeFile(join(SESSIONS_DIR, `${id}.json`), JSON.stringify(data, null, 2), "utf-8");
+  await writeFile2(join2(SESSIONS_DIR, `${id}.json`), JSON.stringify(data, null, 2), "utf-8");
 }
 async function loadSession(id) {
   try {
-    const raw = await readFile(join(SESSIONS_DIR, `${id}.json`), "utf-8");
+    const raw = await readFile2(join2(SESSIONS_DIR, `${id}.json`), "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -611,7 +2505,7 @@ async function listSessions() {
   for (const file of files) {
     if (!file.endsWith(".json")) continue;
     try {
-      const raw = await readFile(join(SESSIONS_DIR, file), "utf-8");
+      const raw = await readFile2(join2(SESSIONS_DIR, file), "utf-8");
       const data = JSON.parse(raw);
       sessions.push({
         id: data.id,
@@ -676,6 +2570,7 @@ var resumeCommand = {
 };
 
 // src/commands/commit.ts
+init_providers();
 import { execFile as execFile2 } from "child_process";
 var commitCommand = {
   name: "commit",
@@ -732,12 +2627,12 @@ ${truncatedDiff}`
   }
 };
 function gitExec(args, cwd) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve8, reject) => {
     execFile2("git", args, { cwd, timeout: 15e3, maxBuffer: 1024 * 1024 }, (err, stdout, stderr) => {
       if (err && !stdout) {
         reject(new Error(stderr || err.message));
       } else {
-        resolve(stdout);
+        resolve8(stdout);
       }
     });
   });
@@ -763,7 +2658,7 @@ var copyCommand = {
   }
 };
 function copyToClipboard(text) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve8, reject) => {
     const tools = [
       { cmd: "xclip", args: ["-selection", "clipboard"] },
       { cmd: "xsel", args: ["--clipboard", "--input"] },
@@ -781,7 +2676,7 @@ function copyToClipboard(text) {
         if (err) {
           tryNext();
         } else {
-          resolve();
+          resolve8();
         }
       });
       if (proc.stdin) {
@@ -834,9 +2729,9 @@ var reviewCommand = {
 };
 
 // src/commands/config.ts
-import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { join as join2 } from "path";
-var SETTINGS_PATH = join2(process.env.HOME || "~", ".darkfoo", "settings.json");
+import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
+import { join as join3 } from "path";
+var SETTINGS_PATH2 = join3(process.env.HOME || "~", ".darkfoo", "settings.json");
 var configCommand = {
   name: "config",
   aliases: ["settings"],
@@ -845,12 +2740,12 @@ var configCommand = {
     const parts = args.trim().split(/\s+/);
     if (!args.trim() || parts[0] === "show") {
       try {
-        const raw = await readFile2(SETTINGS_PATH, "utf-8");
+        const raw = await readFile3(SETTINGS_PATH2, "utf-8");
         const config = JSON.parse(raw);
         return {
           output: [
             "\x1B[1m\x1B[36mSettings\x1B[0m",
-            `\x1B[2m${SETTINGS_PATH}\x1B[0m`,
+            `\x1B[2m${SETTINGS_PATH2}\x1B[0m`,
             "",
             JSON.stringify(config, null, 2)
           ].join("\n"),
@@ -862,7 +2757,7 @@ var configCommand = {
             "\x1B[1m\x1B[36mSettings\x1B[0m",
             "",
             "No settings file found. Default settings in use.",
-            `\x1B[2mSettings will be created at: ${SETTINGS_PATH}\x1B[0m`
+            `\x1B[2mSettings will be created at: ${SETTINGS_PATH2}\x1B[0m`
           ].join("\n"),
           silent: true
         };
@@ -873,7 +2768,7 @@ var configCommand = {
       const value = parts.slice(2).join(" ");
       let config;
       try {
-        const raw = await readFile2(SETTINGS_PATH, "utf-8");
+        const raw = await readFile3(SETTINGS_PATH2, "utf-8");
         config = JSON.parse(raw);
       } catch {
         config = {};
@@ -883,21 +2778,21 @@ var configCommand = {
       else if (value === "false") parsed = false;
       else if (!isNaN(Number(value))) parsed = Number(value);
       config[key] = parsed;
-      await mkdir2(join2(process.env.HOME || "~", ".darkfoo"), { recursive: true });
-      await writeFile2(SETTINGS_PATH, JSON.stringify(config, null, 2), "utf-8");
+      await mkdir3(join3(process.env.HOME || "~", ".darkfoo"), { recursive: true });
+      await writeFile3(SETTINGS_PATH2, JSON.stringify(config, null, 2), "utf-8");
       return { output: `Set ${key} = ${JSON.stringify(parsed)}`, silent: true };
     }
     if (parts[0] === "delete" && parts[1]) {
       const key = parts[1];
       let config;
       try {
-        const raw = await readFile2(SETTINGS_PATH, "utf-8");
+        const raw = await readFile3(SETTINGS_PATH2, "utf-8");
         config = JSON.parse(raw);
       } catch {
         return { output: "No settings to delete from.", silent: true };
       }
       delete config[key];
-      await writeFile2(SETTINGS_PATH, JSON.stringify(config, null, 2), "utf-8");
+      await writeFile3(SETTINGS_PATH2, JSON.stringify(config, null, 2), "utf-8");
       return { output: `Deleted ${key}`, silent: true };
     }
     return {
@@ -975,7 +2870,7 @@ var themeCommand = {
     if (!THEMES[name]) {
       return { output: `Unknown theme: ${name}. Available: ${Object.keys(THEMES).join(", ")}`, silent: true };
     }
-    const { theme: theme2 } = await import("./theme-BQAEFGVB.js");
+    const { theme: theme2 } = await Promise.resolve().then(() => (init_theme(), theme_exports));
     const newTheme = THEMES[name];
     Object.assign(theme2, newTheme);
     return { output: `Theme switched to: ${name}`, silent: true };
@@ -989,8 +2884,8 @@ function hexToRgb(hex) {
 }
 
 // src/commands/export.ts
-import { writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
-import { join as join3 } from "path";
+import { writeFile as writeFile4, mkdir as mkdir4 } from "fs/promises";
+import { join as join4 } from "path";
 var exportCommand = {
   name: "export",
   description: "Export conversation to markdown file (usage: /export [filename])",
@@ -1000,9 +2895,9 @@ var exportCommand = {
     }
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
     const filename = args.trim() || `darkfoo-session-${timestamp}.md`;
-    const exportDir = join3(process.env.HOME || "~", ".darkfoo", "exports");
-    await mkdir3(exportDir, { recursive: true });
-    const filePath = join3(exportDir, filename);
+    const exportDir = join4(process.env.HOME || "~", ".darkfoo", "exports");
+    await mkdir4(exportDir, { recursive: true });
+    const filePath = join4(exportDir, filename);
     const lines = [
       `# Darkfoo Code Session`,
       ``,
@@ -1034,23 +2929,25 @@ var exportCommand = {
           break;
       }
     }
-    await writeFile3(filePath, lines.join("\n"), "utf-8");
+    await writeFile4(filePath, lines.join("\n"), "utf-8");
     return { output: `Exported to ${filePath}`, silent: true };
   }
 };
 
 // src/commands/status.ts
+init_file_tracker();
+init_state();
 var statusCommand = {
   name: "status",
   description: "Show session status overview",
   async execute(_args, context) {
-    const state = getAppState();
+    const state2 = getAppState();
     const userMsgs = context.messages.filter((m) => m.role === "user").length;
     const assistantMsgs = context.messages.filter((m) => m.role === "assistant").length;
     const toolMsgs = context.messages.filter((m) => m.role === "tool").length;
     const totalChars = context.messages.reduce((sum, m) => sum + m.content.length, 0);
     const estTokens = Math.ceil(totalChars / 4);
-    const tasks = state.tasks;
+    const tasks = state2.tasks;
     const pending = tasks.filter((t) => t.status === "pending").length;
     const inProgress = tasks.filter((t) => t.status === "in_progress").length;
     const completed = tasks.filter((t) => t.status === "completed").length;
@@ -1059,7 +2956,7 @@ var statusCommand = {
       "",
       `  Model:            \x1B[36m${context.model}\x1B[0m`,
       `  Working Dir:      ${context.cwd}`,
-      `  Plan Mode:        ${state.planMode ? "\x1B[33mActive\x1B[0m" : "Off"}`,
+      `  Plan Mode:        ${state2.planMode ? "\x1B[33mActive\x1B[0m" : "Off"}`,
       "",
       "  \x1B[1mMessages\x1B[0m",
       `    User:           ${userMsgs}`,
@@ -1083,7 +2980,7 @@ var filesCommand = {
   name: "files",
   description: "List files modified or referenced in this session",
   async execute(_args, context) {
-    const readFiles = /* @__PURE__ */ new Set();
+    const readFiles2 = /* @__PURE__ */ new Set();
     const writtenFiles = /* @__PURE__ */ new Set();
     const editedFiles = /* @__PURE__ */ new Set();
     for (const msg of context.messages) {
@@ -1094,7 +2991,7 @@ var filesCommand = {
           if (!path) continue;
           switch (tc.function.name) {
             case "Read":
-              readFiles.add(path);
+              readFiles2.add(path);
               break;
             case "Write":
               writtenFiles.add(path);
@@ -1106,13 +3003,13 @@ var filesCommand = {
         }
       }
     }
-    if (readFiles.size === 0 && writtenFiles.size === 0 && editedFiles.size === 0) {
+    if (readFiles2.size === 0 && writtenFiles.size === 0 && editedFiles.size === 0) {
       return { output: "No files referenced in this session.", silent: true };
     }
     const lines = ["\x1B[1m\x1B[36mSession Files\x1B[0m", ""];
-    if (readFiles.size > 0) {
+    if (readFiles2.size > 0) {
       lines.push("  \x1B[1mRead:\x1B[0m");
-      for (const f of readFiles) lines.push(`    \x1B[36m${f}\x1B[0m`);
+      for (const f of readFiles2) lines.push(`    \x1B[36m${f}\x1B[0m`);
       lines.push("");
     }
     if (writtenFiles.size > 0) {
@@ -1170,6 +3067,7 @@ var briefCommand = {
 };
 
 // src/commands/provider.ts
+init_providers();
 var providerCommand = {
   name: "provider",
   aliases: ["backend"],
@@ -1226,15 +3124,15 @@ var providerCommand = {
     if (subcommand === "remove") {
       const name = parts[1];
       if (!name) return { output: "Usage: /provider remove <name>", silent: true };
-      const { removeProviderConfig } = await import("./providers-P7Z3JXQH.js");
-      if (removeProviderConfig(name)) {
+      const { removeProviderConfig: removeProviderConfig2 } = await Promise.resolve().then(() => (init_providers(), providers_exports));
+      if (removeProviderConfig2(name)) {
         await saveProviderSettings();
         return { output: `Removed provider: ${name}`, silent: true };
       }
       return { output: `Provider not found: ${name}`, silent: true };
     }
     if (subcommand === "models") {
-      const { getProvider: getProvider2 } = await import("./providers-P7Z3JXQH.js");
+      const { getProvider: getProvider2 } = await Promise.resolve().then(() => (init_providers(), providers_exports));
       const provider = getProvider2();
       const models = await provider.listModels();
       if (models.length === 0) {
@@ -1396,6 +3294,12 @@ function UserInput({ value, onChange, onSubmit, disabled, history }) {
 }
 
 // src/repl.tsx
+init_query();
+init_system_prompt();
+init_providers();
+init_tools();
+init_bash();
+init_theme();
 import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
 function getContextLimit3(model) {
   const lower = model.toLowerCase();
@@ -1451,7 +3355,7 @@ function REPL({ initialPrompt }) {
   const runQuery = useCallback2(
     async (userMessage) => {
       const userMsg = {
-        id: nanoid3(),
+        id: nanoid6(),
         role: "user",
         content: userMessage,
         timestamp: Date.now()
@@ -1488,7 +3392,7 @@ function REPL({ initialPrompt }) {
               setActiveTool(null);
               setToolResults((prev) => [
                 ...prev,
-                { id: nanoid3(), toolName: event.toolName, output: event.output, isError: event.isError }
+                { id: nanoid6(), toolName: event.toolName, output: event.output, isError: event.isError }
               ]);
               break;
             case "assistant_message":
@@ -1507,7 +3411,7 @@ function REPL({ initialPrompt }) {
             case "error":
               setMessages((prev) => [
                 ...prev,
-                { id: nanoid3(), role: "assistant", content: `Error: ${event.error}`, timestamp: Date.now() }
+                { id: nanoid6(), role: "assistant", content: `Error: ${event.error}`, timestamp: Date.now() }
               ]);
               break;
           }
@@ -1517,7 +3421,7 @@ function REPL({ initialPrompt }) {
           const msg = err instanceof Error ? err.message : String(err);
           setMessages((prev) => [
             ...prev,
-            { id: nanoid3(), role: "assistant", content: `Error: ${msg}`, timestamp: Date.now() }
+            { id: nanoid6(), role: "assistant", content: `Error: ${msg}`, timestamp: Date.now() }
           ]);
         }
       } finally {
@@ -1604,7 +3508,7 @@ function REPL({ initialPrompt }) {
 ${transcript}` }]
       }).then((result) => {
         const summaryMsg = {
-          id: nanoid3(),
+          id: nanoid6(),
           role: "user",
           content: `[Auto-compacted summary]
 ${result.content}
@@ -1671,9 +3575,10 @@ ${result.content}
 }
 
 // src/main.tsx
+init_providers();
 import { jsx as jsx8 } from "react/jsx-runtime";
 var program = new Command();
-program.name("darkfoo").description("Darkfoo Code \u2014 local AI coding assistant powered by local LLM providers").version("0.1.0").option("-m, --model <model>", "Model to use", "llama3.1:8b").option("-p, --prompt <prompt>", "Run a single prompt (non-interactive)").option("--provider <name>", "LLM provider backend (ollama, llama-cpp, vllm, tgi, etc.)").option("--system-prompt <prompt>", "Override the system prompt").action(async (options) => {
+program.name("darkfoo").description("Darkfoo Code \u2014 local AI coding assistant powered by local LLM providers").version("0.1.4").option("-m, --model <model>", "Model to use", "llama3.1:8b").option("-p, --prompt <prompt>", "Run a single prompt (non-interactive)").option("--provider <name>", "LLM provider backend (ollama, llama-cpp, vllm, tgi, etc.)").option("--system-prompt <prompt>", "Override the system prompt").action(async (options) => {
   const { model, prompt, provider, systemPrompt } = options;
   await loadProviderSettings();
   if (provider) {
@@ -1687,14 +3592,14 @@ program.name("darkfoo").description("Darkfoo Code \u2014 local AI coding assista
     }
   }
   if (prompt) {
-    const { buildSystemPrompt: buildSystemPrompt2 } = await import("./system-prompt-YJSDZVOM.js");
-    const { getTools: getTools2 } = await import("./tools-34S775OZ.js");
-    const { query: query2 } = await import("./query-E6NPBSUX.js");
+    const { buildSystemPrompt: buildSystemPrompt2 } = await Promise.resolve().then(() => (init_system_prompt(), system_prompt_exports));
+    const { getTools: getTools2 } = await Promise.resolve().then(() => (init_tools(), tools_exports));
+    const { query: query2 } = await Promise.resolve().then(() => (init_query(), query_exports));
     const tools = getTools2();
     const sysPrompt = systemPrompt ?? await buildSystemPrompt2(tools, process.cwd());
-    const { nanoid: nanoid4 } = await import("nanoid");
+    const { nanoid: nanoid7 } = await import("nanoid");
     const userMsg = {
-      id: nanoid4(),
+      id: nanoid7(),
       role: "user",
       content: prompt,
       timestamp: Date.now()