darkfoo-code 0.1.0

package/dist/main.js

@@ -0,0 +1,1740 @@
+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";
+
+// src/main.tsx
+import { Command } from "commander";
+import { render } from "ink";
+
+// src/app.tsx
+import { createContext, useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+var DarkfooContext = createContext({ model: "qwen2.5-coder:32b" });
+function useDarkfooContext() {
+  return useContext(DarkfooContext);
+}
+function App({ model, systemPromptOverride, children }) {
+  return /* @__PURE__ */ jsx(DarkfooContext.Provider, { value: { model, systemPromptOverride }, children });
+}
+
+// src/repl.tsx
+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";
+
+// src/components/Banner.tsx
+import { Box, Text } from "ink";
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+var LOGO_LINES = [
+  " \u2588\u2588\u2588\u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2557  \u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2588\u2588\u2588\u2557 ",
+  " \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557 \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557 \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557 \u2588\u2588\u2551 \u2588\u2588\u2554\u255D \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D \u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557 \u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557",
+  " \u2588\u2588\u2551  \u2588\u2588\u2551 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551 \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2588\u2588\u2588\u2554\u255D  \u2588\u2588\u2588\u2588\u2588\u2557   \u2588\u2588\u2551   \u2588\u2588\u2551 \u2588\u2588\u2551   \u2588\u2588\u2551",
+  " \u2588\u2588\u2551  \u2588\u2588\u2551 \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551 \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557 \u2588\u2588\u2554\u2550\u2588\u2588\u2557  \u2588\u2588\u2554\u2550\u2550\u255D   \u2588\u2588\u2551   \u2588\u2588\u2551 \u2588\u2588\u2551   \u2588\u2588\u2551",
+  " \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2551  \u2588\u2588\u2551 \u2588\u2588\u2551  \u2588\u2588\u2551 \u2588\u2588\u2551  \u2588\u2588\u2557 \u2588\u2588\u2551      \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D",
+  " \u255A\u2550\u2550\u2550\u2550\u2550\u255D  \u255A\u2550\u255D  \u255A\u2550\u255D \u255A\u2550\u255D  \u255A\u2550\u255D \u255A\u2550\u255D  \u255A\u2550\u255D \u255A\u2550\u255D       \u255A\u2550\u2550\u2550\u2550\u2550\u255D   \u255A\u2550\u2550\u2550\u2550\u2550\u255D "
+];
+var SUBTITLE = "                  \u2584\u2580  C O D E  \u2580\u2584";
+var GRADIENT = [
+  "#5eead4",
+  // cyan
+  "#6ee0c8",
+  // cyan-light
+  "#82c8d0",
+  // cyan-blue
+  "#96b0d8",
+  // blue-ish
+  "#a78bfa",
+  // purple
+  "#c47ee8",
+  // purple-pink
+  "#f472b6"
+  // pink
+];
+function lineColor(index) {
+  const t = index / (LOGO_LINES.length - 1);
+  const gradientIdx = Math.round(t * (GRADIENT.length - 1));
+  return GRADIENT[gradientIdx];
+}
+function gradientDivider(width) {
+  const chars = [];
+  for (let i = 0; i < width; i++) {
+    const t = i / (width - 1);
+    const gradientIdx = Math.round(t * (GRADIENT.length - 1));
+    chars.push({ char: "\u2501", color: GRADIENT[gradientIdx] });
+  }
+  return chars;
+}
+function Banner({ model, cwd }) {
+  const divider = gradientDivider(60);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
+    LOGO_LINES.map((line, i) => /* @__PURE__ */ jsx2(Text, { color: lineColor(i), bold: true, children: line }, i)),
+    /* @__PURE__ */ jsx2(Text, { color: theme.purple, bold: true, children: SUBTITLE }),
+    /* @__PURE__ */ jsx2(Text, { children: " " }),
+    /* @__PURE__ */ jsxs(Text, { children: [
+      "  ",
+      divider.map((d, i) => /* @__PURE__ */ jsx2(Text, { color: d.color, children: d.char }, i))
+    ] }),
+    /* @__PURE__ */ jsxs(Box, { marginTop: 1, marginLeft: 2, children: [
+      /* @__PURE__ */ jsx2(Text, { color: theme.dim, children: "\u26A1 " }),
+      /* @__PURE__ */ jsx2(Text, { color: theme.cyan, bold: true, children: model }),
+      /* @__PURE__ */ jsx2(Text, { color: theme.dim, children: "  \u2502  " }),
+      /* @__PURE__ */ jsx2(Text, { color: theme.text, children: cwd })
+    ] }),
+    /* @__PURE__ */ jsxs(Box, { marginLeft: 2, children: [
+      /* @__PURE__ */ jsx2(Text, { color: theme.dim, children: "  Type a message to begin. " }),
+      /* @__PURE__ */ jsx2(Text, { color: theme.cyanDim, children: "Ctrl+C" }),
+      /* @__PURE__ */ jsx2(Text, { color: theme.dim, children: " to abort or exit." })
+    ] }),
+    /* @__PURE__ */ jsxs(Text, { children: [
+      "  ",
+      divider.map((d, i) => /* @__PURE__ */ jsx2(Text, { color: d.color, children: d.char }, i))
+    ] })
+  ] });
+}
+
+// src/components/Messages.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+
+// src/utils/markdown.ts
+function renderMarkdown(text) {
+  const lines = text.split("\n");
+  const result = [];
+  let inCodeBlock = false;
+  let codeBlockLang = "";
+  for (const line of lines) {
+    if (line.trimStart().startsWith("```")) {
+      if (!inCodeBlock) {
+        codeBlockLang = line.trimStart().slice(3).trim();
+        const label = codeBlockLang ? ` ${codeBlockLang}` : "";
+        result.push(`\x1B[2m\x1B[38;2;94;234;212m\u2500\u2500\u2500 code${label} \u2500\u2500\u2500\x1B[0m`);
+        inCodeBlock = true;
+      } else {
+        result.push(`\x1B[2m\x1B[38;2;94;234;212m\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\x1B[0m`);
+        inCodeBlock = false;
+        codeBlockLang = "";
+      }
+      continue;
+    }
+    if (inCodeBlock) {
+      result.push(`\x1B[38;2;251;191;36m  ${line}\x1B[0m`);
+      continue;
+    }
+    const headerMatch = line.match(/^(#{1,6})\s+(.+)/);
+    if (headerMatch) {
+      const level = headerMatch[1].length;
+      const text2 = headerMatch[2];
+      if (level <= 2) {
+        result.push(`\x1B[1m\x1B[38;2;94;234;212m${text2}\x1B[0m`);
+      } else {
+        result.push(`\x1B[1m${text2}\x1B[0m`);
+      }
+      continue;
+    }
+    const listMatch = line.match(/^(\s*)[*-]\s+(.+)/);
+    if (listMatch) {
+      const indent = listMatch[1] || "";
+      const content = renderInline(listMatch[2]);
+      result.push(`${indent}\x1B[38;2;94;234;212m\u2022\x1B[0m ${content}`);
+      continue;
+    }
+    const orderedMatch = line.match(/^(\s*)\d+\.\s+(.+)/);
+    if (orderedMatch) {
+      const indent = orderedMatch[1] || "";
+      const content = renderInline(orderedMatch[2]);
+      result.push(`${indent}${content}`);
+      continue;
+    }
+    if (/^---+$|^\*\*\*+$|^___+$/.test(line.trim())) {
+      result.push(`\x1B[2m${"\u2500".repeat(40)}\x1B[0m`);
+      continue;
+    }
+    result.push(renderInline(line));
+  }
+  return result.join("\n");
+}
+function renderInline(text) {
+  return text.replace(/`([^`]+)`/g, "\x1B[38;2;251;191;36m$1\x1B[0m").replace(/\*\*\*(.+?)\*\*\*/g, "\x1B[1m\x1B[3m$1\x1B[0m").replace(/\*\*(.+?)\*\*/g, "\x1B[1m$1\x1B[0m").replace(/\*(.+?)\*/g, "\x1B[3m$1\x1B[0m").replace(/\[([^\]]+)\]\(([^)]+)\)/g, "\x1B[4m\x1B[38;2;94;234;212m$1\x1B[0m");
+}
+
+// src/components/Messages.tsx
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+function Messages({ messages }) {
+  return /* @__PURE__ */ jsx3(Box2, { flexDirection: "column", children: messages.map((msg) => /* @__PURE__ */ jsx3(MessageRow, { message: msg }, msg.id)) });
+}
+function MessageRow({ message }) {
+  switch (message.role) {
+    case "user":
+      return /* @__PURE__ */ jsxs2(Box2, { marginTop: 1, marginBottom: 1, children: [
+        /* @__PURE__ */ jsx3(Text2, { color: theme.cyan, bold: true, children: "\u276F " }),
+        /* @__PURE__ */ jsx3(Text2, { bold: true, color: theme.text, children: message.content })
+      ] });
+    case "assistant": {
+      if (!message.content && message.toolCalls) return null;
+      if (!message.content) return null;
+      const rendered = renderMarkdown(message.content);
+      return /* @__PURE__ */ jsx3(Box2, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ jsxs2(Box2, { children: [
+        /* @__PURE__ */ jsx3(Text2, { color: theme.cyan, children: "\u23BF " }),
+        /* @__PURE__ */ jsx3(Text2, { wrap: "wrap", children: rendered })
+      ] }) });
+    }
+    case "tool": {
+      const lines = message.content.split("\n");
+      const preview = lines.length > 8 ? lines.slice(0, 8).join("\n") + `
+... (${lines.length - 8} more lines)` : message.content;
+      return /* @__PURE__ */ jsx3(Box2, { flexDirection: "column", marginLeft: 2, marginBottom: 1, children: /* @__PURE__ */ jsxs2(Text2, { color: theme.dim, children: [
+        "\u23BF ",
+        truncate(preview, 1200)
+      ] }) });
+    }
+    default:
+      return null;
+  }
+}
+
+// src/components/ToolCall.tsx
+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";
+function ActiveToolCall({ toolName, args }) {
+  return /* @__PURE__ */ jsxs3(Box3, { marginLeft: 2, children: [
+    /* @__PURE__ */ jsx4(Text3, { color: theme.cyan, children: /* @__PURE__ */ jsx4(Spinner, { type: "dots" }) }),
+    /* @__PURE__ */ jsxs3(Text3, { bold: true, color: theme.yellow, children: [
+      " ",
+      toolName
+    ] }),
+    args ? /* @__PURE__ */ jsxs3(Text3, { color: theme.dim, children: [
+      " ",
+      formatToolArgs(args)
+    ] }) : null
+  ] });
+}
+function ToolResultDisplay({ toolName, output, isError }) {
+  const icon = isError ? "\u2718" : "\u2714";
+  const iconColor = isError ? theme.pink : theme.green;
+  const lines = output.split("\n");
+  const preview = lines.length > 6 ? lines.slice(0, 6).join("\n") + `
+... (${lines.length - 6} more lines)` : output;
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", marginLeft: 2, marginBottom: 1, children: [
+    /* @__PURE__ */ jsxs3(Box3, { children: [
+      /* @__PURE__ */ jsxs3(Text3, { color: iconColor, children: [
+        icon,
+        " "
+      ] }),
+      /* @__PURE__ */ jsx4(Text3, { bold: true, color: theme.yellow, children: toolName })
+    ] }),
+    /* @__PURE__ */ jsx4(Box3, { marginLeft: 2, children: /* @__PURE__ */ jsxs3(Text3, { color: theme.dim, children: [
+      "\u23BF ",
+      truncate(preview, 1200)
+    ] }) })
+  ] });
+}
+function formatToolArgs(args) {
+  const entries = Object.entries(args);
+  if (entries.length === 0) return "";
+  const parts = [];
+  for (const [key, val] of entries.slice(0, 2)) {
+    const valStr = typeof val === "string" ? truncate(val, 50) : String(val);
+    parts.push(`${key}: ${valStr}`);
+  }
+  const extra = entries.length > 2 ? ` +${entries.length - 2} more` : "";
+  return `(${parts.join(", ")}${extra})`;
+}
+
+// src/components/StatusLine.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import { Fragment, jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+function getContextLimit(model) {
+  const lower = model.toLowerCase();
+  if (lower.includes("llama3.1")) return 131072;
+  if (lower.includes("llama3.2")) return 131072;
+  if (lower.includes("qwen")) return 32768;
+  if (lower.includes("gemma")) return 8192;
+  if (lower.includes("phi")) return 16384;
+  if (lower.includes("deepseek")) return 32768;
+  return 8192;
+}
+function StatusLine({ model, messageCount, tokenEstimate, isStreaming }) {
+  const state = 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;
+  return /* @__PURE__ */ jsxs4(Box4, { marginTop: 1, children: [
+    /* @__PURE__ */ jsxs4(Text4, { color: theme.dim, children: [
+      "\u2500".repeat(2),
+      " "
+    ] }),
+    /* @__PURE__ */ jsx5(Text4, { color: theme.cyan, bold: true, children: model.split(":")[0] }),
+    /* @__PURE__ */ jsx5(Text4, { color: theme.dim, children: " \u2502 " }),
+    /* @__PURE__ */ jsxs4(Text4, { color: theme.dim, children: [
+      messageCount,
+      " msgs"
+    ] }),
+    /* @__PURE__ */ jsx5(Text4, { color: theme.dim, children: " \u2502 " }),
+    /* @__PURE__ */ jsxs4(Text4, { color: usageColor, children: [
+      "ctx ",
+      pct,
+      "%"
+    ] }),
+    state.planMode ? /* @__PURE__ */ jsxs4(Fragment, { children: [
+      /* @__PURE__ */ jsx5(Text4, { color: theme.dim, children: " \u2502 " }),
+      /* @__PURE__ */ jsx5(Text4, { color: theme.yellow, bold: true, children: "PLAN" })
+    ] }) : null,
+    activeTasks > 0 ? /* @__PURE__ */ jsxs4(Fragment, { children: [
+      /* @__PURE__ */ jsx5(Text4, { color: theme.dim, children: " \u2502 " }),
+      /* @__PURE__ */ jsxs4(Text4, { color: theme.green, children: [
+        activeTasks,
+        " task",
+        activeTasks > 1 ? "s" : ""
+      ] })
+    ] }) : null,
+    isStreaming ? /* @__PURE__ */ jsxs4(Fragment, { children: [
+      /* @__PURE__ */ jsx5(Text4, { color: theme.dim, children: " \u2502 " }),
+      /* @__PURE__ */ jsx5(Text4, { color: theme.cyan, children: "streaming" })
+    ] }) : null,
+    /* @__PURE__ */ jsxs4(Text4, { color: theme.dim, children: [
+      " ",
+      "\u2500".repeat(2)
+    ] })
+  ] });
+}
+
+// src/components/UserInput.tsx
+import { useState, useCallback } from "react";
+import { Box as Box5, Text as Text5, useInput } from "ink";
+import TextInput from "ink-text-input";
+
+// src/commands/help.ts
+var helpCommand = {
+  name: "help",
+  aliases: ["h", "?"],
+  description: "Show available commands",
+  async execute(_args, _context) {
+    const commands = getCommands();
+    const lines = commands.map((cmd) => {
+      const aliases = cmd.aliases ? ` (${cmd.aliases.map((a) => "/" + a).join(", ")})` : "";
+      return `  /${cmd.name}${aliases} \u2014 ${cmd.description}`;
+    });
+    const output = [
+      "\x1B[1m\x1B[36mAvailable Commands\x1B[0m",
+      "",
+      ...lines,
+      "",
+      "\x1B[2mPrefix with ! to run shell commands directly (e.g. !ls -la)\x1B[0m"
+    ].join("\n");
+    return { output, silent: true };
+  }
+};
+
+// src/commands/clear.ts
+var clearCommand = {
+  name: "clear",
+  description: "Clear conversation history",
+  async execute(_args, context) {
+    context.clearMessages();
+    return { output: "Conversation cleared.", replaceMessages: [], silent: true };
+  }
+};
+
+// src/commands/exit.ts
+var exitCommand = {
+  name: "exit",
+  aliases: ["quit", "q"],
+  description: "Exit Darkfoo Code",
+  async execute(_args, context) {
+    context.exit();
+    return { output: "", exit: true, silent: true };
+  }
+};
+
+// src/commands/model.ts
+var OLLAMA_HOST = process.env.OLLAMA_HOST || "http://localhost:11434";
+var modelCommand = {
+  name: "model",
+  aliases: ["m"],
+  description: "Switch Ollama model (usage: /model <name>)",
+  async execute(args, context) {
+    if (!args.trim()) {
+      try {
+        const res = await fetch(`${OLLAMA_HOST}/api/tags`);
+        const data = await res.json();
+        const models = data.models;
+        const lines = models.map((m) => {
+          const active = m.name === context.model ? " \x1B[36m\u2190 active\x1B[0m" : "";
+          return `  ${m.name} (${m.details.parameter_size}, ${m.details.family})${active}`;
+        });
+        return {
+          output: [
+            "\x1B[1m\x1B[36mAvailable Models\x1B[0m",
+            "",
+            ...lines,
+            "",
+            "\x1B[2mUsage: /model <name> to switch\x1B[0m"
+          ].join("\n"),
+          silent: true
+        };
+      } catch {
+        return { output: `Error: Cannot reach Ollama at ${OLLAMA_HOST}`, silent: true };
+      }
+    }
+    const newModel = args.trim();
+    context.setModel(newModel);
+    return { output: `Switched to model: ${newModel}`, silent: true };
+  }
+};
+
+// src/commands/compact.ts
+import { nanoid } from "nanoid";
+var compactCommand = {
+  name: "compact",
+  description: "Compress conversation history to save context",
+  async execute(_args, context) {
+    if (context.messages.length < 4) {
+      return { output: "Conversation is too short to compact.", silent: true };
+    }
+    const transcript = context.messages.filter((m) => m.role === "user" || m.role === "assistant" && m.content).map((m) => `${m.role}: ${m.content}`).join("\n\n");
+    const summaryPrompt = `Summarize this conversation concisely. Capture all key decisions, code changes, file paths mentioned, and current task state. Be thorough but brief:
+
+${transcript}`;
+    try {
+      const provider = getProvider();
+      const result = await provider.chat({
+        model: context.model,
+        messages: [{ role: "user", content: summaryPrompt }]
+      });
+      const summaryMsg = {
+        id: nanoid(),
+        role: "user",
+        content: `[Previous conversation summary]
+${result.content}
+[End summary \u2014 conversation continues below]`,
+        timestamp: Date.now()
+      };
+      const before = context.messages.length;
+      return {
+        output: `Compacted ${before} messages into summary.`,
+        replaceMessages: [summaryMsg],
+        silent: true
+      };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { output: `Compact failed: ${msg}`, silent: true };
+    }
+  }
+};
+
+// src/commands/cost.ts
+var costCommand = {
+  name: "cost",
+  aliases: ["usage", "tokens"],
+  description: "Show token usage for this session",
+  async execute(_args, context) {
+    const { input, output } = context.tokenCounts;
+    const total = input + output;
+    const msgCount = context.messages.length;
+    const lines = [
+      "\x1B[1m\x1B[36mSession Usage\x1B[0m",
+      "",
+      `  Messages:      ${msgCount}`,
+      `  Input tokens:  ~${input.toLocaleString()}`,
+      `  Output tokens: ~${output.toLocaleString()}`,
+      `  Total tokens:  ~${total.toLocaleString()}`,
+      "",
+      "\x1B[2mToken counts are estimates based on character length.\x1B[0m"
+    ];
+    return { output: lines.join("\n"), silent: true };
+  }
+};
+
+// src/commands/context.ts
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+var contextCommand = {
+  name: "context",
+  aliases: ["ctx"],
+  description: "Show context window usage",
+  async execute(_args, context) {
+    const contextLimit = getContextLimit2(context.model);
+    let totalTokens = 0;
+    const breakdown = [];
+    const roles = ["system", "user", "assistant", "tool"];
+    for (const role of roles) {
+      const msgs = context.messages.filter((m) => m.role === role);
+      const tokens = msgs.reduce((sum, m) => sum + estimateTokens(m.content), 0);
+      if (msgs.length > 0) {
+        breakdown.push({ role, tokens, count: msgs.length });
+      }
+      totalTokens += tokens;
+    }
+    const sysTokens = 2e3;
+    totalTokens += sysTokens;
+    const usage = totalTokens / contextLimit;
+    const barWidth = 40;
+    const filled = Math.round(usage * barWidth);
+    const bar = "\x1B[36m" + "\u2588".repeat(Math.min(filled, barWidth)) + "\x1B[0m\x1B[2m" + "\u2591".repeat(Math.max(barWidth - filled, 0)) + "\x1B[0m";
+    const pct = (usage * 100).toFixed(1);
+    const lines = [
+      "\x1B[1m\x1B[36mContext Window\x1B[0m",
+      "",
+      `  [${bar}] ${pct}%`,
+      `  ~${totalTokens.toLocaleString()} / ${contextLimit.toLocaleString()} tokens`,
+      "",
+      "  Breakdown:",
+      `    System prompt:  ~${sysTokens.toLocaleString()} tokens`,
+      ...breakdown.map(
+        (b) => `    ${b.role.padEnd(12)} ${b.count} msgs, ~${b.tokens.toLocaleString()} tokens`
+      ),
+      "",
+      `\x1B[2m  Model: ${context.model} (${contextLimit.toLocaleString()} ctx)\x1B[0m`
+    ];
+    if (usage > 0.8) {
+      lines.push("", "\x1B[33m  \u26A0 Context is getting full. Consider /compact to free space.\x1B[0m");
+    }
+    return { output: lines.join("\n"), silent: true };
+  }
+};
+function getContextLimit2(model) {
+  const lower = model.toLowerCase();
+  if (lower.includes("llama3.1")) return 131072;
+  if (lower.includes("llama3.2")) return 131072;
+  if (lower.includes("qwen")) return 32768;
+  if (lower.includes("gemma")) return 8192;
+  if (lower.includes("phi")) return 16384;
+  if (lower.includes("deepseek")) return 32768;
+  return 8192;
+}
+
+// src/commands/diff.ts
+import { execFile } from "child_process";
+var diffCommand = {
+  name: "diff",
+  description: "Show uncommitted git changes",
+  async execute(_args, context) {
+    return new Promise((resolve) => {
+      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 });
+          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 });
+              return;
+            }
+            resolve({ output: `\x1B[1m\x1B[36mStaged changes:\x1B[0m
+${staged}`, silent: true });
+          });
+          return;
+        }
+        execFile("git", ["diff"], { cwd: context.cwd, timeout: 1e4, maxBuffer: 1024 * 1024 }, (_err3, fullDiff) => {
+          const output = [
+            "\x1B[1m\x1B[36mUncommitted Changes\x1B[0m",
+            "",
+            stdout.trim(),
+            "",
+            fullDiff ? fullDiff.slice(0, 3e3) : "",
+            fullDiff && fullDiff.length > 3e3 ? "\n... (truncated)" : ""
+          ].join("\n");
+          resolve({ output, silent: true });
+        });
+      });
+    });
+  }
+};
+
+// src/session.ts
+import { mkdir, readdir, readFile, writeFile } from "fs/promises";
+import { join } from "path";
+import { nanoid as nanoid2 } from "nanoid";
+var SESSIONS_DIR = join(process.env.HOME || "~", ".darkfoo", "sessions");
+async function ensureDir() {
+  await mkdir(SESSIONS_DIR, { recursive: true });
+}
+function createSessionId() {
+  return nanoid2(12);
+}
+async function saveSession(id, messages, model, cwd) {
+  await ensureDir();
+  const firstUser = messages.find((m) => m.role === "user");
+  const title = firstUser ? firstUser.content.slice(0, 80).replace(/\n/g, " ") : "Untitled session";
+  const data = {
+    id,
+    model,
+    cwd,
+    title,
+    createdAt: messages[0]?.timestamp ?? Date.now(),
+    updatedAt: Date.now(),
+    messageCount: messages.length,
+    messages
+  };
+  await writeFile(join(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");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function listSessions() {
+  await ensureDir();
+  const files = await readdir(SESSIONS_DIR);
+  const sessions = [];
+  for (const file of files) {
+    if (!file.endsWith(".json")) continue;
+    try {
+      const raw = await readFile(join(SESSIONS_DIR, file), "utf-8");
+      const data = JSON.parse(raw);
+      sessions.push({
+        id: data.id,
+        model: data.model,
+        cwd: data.cwd,
+        title: data.title,
+        createdAt: data.createdAt,
+        updatedAt: data.updatedAt,
+        messageCount: data.messageCount
+      });
+    } catch {
+    }
+  }
+  return sessions.sort((a, b) => b.updatedAt - a.updatedAt);
+}
+
+// src/commands/history.ts
+var historyCommand = {
+  name: "history",
+  aliases: ["sessions"],
+  description: "List past sessions (usage: /history, /resume <id>)",
+  async execute(_args, _context) {
+    const sessions = await listSessions();
+    if (sessions.length === 0) {
+      return { output: "No saved sessions.", silent: true };
+    }
+    const lines = sessions.slice(0, 20).map((s) => {
+      const date = new Date(s.updatedAt).toLocaleDateString();
+      const time = new Date(s.updatedAt).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+      return `  \x1B[36m${s.id}\x1B[0m  ${date} ${time}  ${s.messageCount} msgs  ${s.title}`;
+    });
+    return {
+      output: [
+        "\x1B[1m\x1B[36mRecent Sessions\x1B[0m",
+        "",
+        ...lines,
+        "",
+        "\x1B[2mUsage: /resume <id> to continue a session\x1B[0m"
+      ].join("\n"),
+      silent: true
+    };
+  }
+};
+var resumeCommand = {
+  name: "resume",
+  description: "Resume a saved session (usage: /resume <id>)",
+  async execute(args, _context) {
+    const id = args.trim();
+    if (!id) {
+      return { output: "Usage: /resume <session-id>", silent: true };
+    }
+    const session = await loadSession(id);
+    if (!session) {
+      return { output: `Session ${id} not found.`, silent: true };
+    }
+    return {
+      output: `Resumed session: ${session.title} (${session.messageCount} messages)`,
+      replaceMessages: session.messages,
+      silent: true
+    };
+  }
+};
+
+// src/commands/commit.ts
+import { execFile as execFile2 } from "child_process";
+var commitCommand = {
+  name: "commit",
+  description: "Stage changes and commit with an AI-generated message",
+  async execute(args, context) {
+    const diff = await gitExec(["diff", "--staged"], context.cwd);
+    const unstaged = await gitExec(["diff"], context.cwd);
+    const status = await gitExec(["status", "--short"], context.cwd);
+    if (!status.trim()) {
+      return { output: "No changes to commit.", silent: true };
+    }
+    if (!diff.trim() && unstaged.trim()) {
+      await gitExec(["add", "-A"], context.cwd);
+    }
+    const finalDiff = await gitExec(["diff", "--staged"], context.cwd);
+    if (!finalDiff.trim()) {
+      return { output: "No changes staged for commit.", silent: true };
+    }
+    const truncatedDiff = finalDiff.slice(0, 4e3);
+    let commitMsg;
+    if (args.trim()) {
+      commitMsg = args.trim();
+    } else {
+      try {
+        const provider = getProvider();
+        const result = await provider.chat({
+          model: context.model,
+          messages: [{
+            role: "user",
+            content: `Generate a short, clean git commit message (one line, under 72 chars) for this diff. No quotes, no prefix like "feat:" unless it truly fits. Just the message:
+
+${truncatedDiff}`
+          }]
+        });
+        commitMsg = result.content.trim().replace(/^["']|["']$/g, "");
+      } catch {
+        return { output: "Failed to generate commit message. Use: /commit <message>", silent: true };
+      }
+    }
+    try {
+      const output = await gitExec(["commit", "-m", commitMsg], context.cwd);
+      return {
+        output: [
+          `\x1B[32m\u2713\x1B[0m Committed: ${commitMsg}`,
+          "",
+          output.trim()
+        ].join("\n"),
+        silent: true
+      };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { output: `Commit failed: ${msg}`, silent: true };
+    }
+  }
+};
+function gitExec(args, cwd) {
+  return new Promise((resolve, 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);
+      }
+    });
+  });
+}
+
+// src/commands/copy.ts
+import { execFile as execFile3 } from "child_process";
+var copyCommand = {
+  name: "copy",
+  description: "Copy the last assistant response to clipboard",
+  async execute(_args, context) {
+    const lastAssistant = [...context.messages].reverse().find((m) => m.role === "assistant" && m.content);
+    if (!lastAssistant) {
+      return { output: "No assistant response to copy.", silent: true };
+    }
+    try {
+      await copyToClipboard(lastAssistant.content);
+      return { output: "Copied to clipboard.", silent: true };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { output: `Copy failed: ${msg}`, silent: true };
+    }
+  }
+};
+function copyToClipboard(text) {
+  return new Promise((resolve, reject) => {
+    const tools = [
+      { cmd: "xclip", args: ["-selection", "clipboard"] },
+      { cmd: "xsel", args: ["--clipboard", "--input"] },
+      { cmd: "wl-copy", args: [] }
+    ];
+    let attempted = 0;
+    const tryNext = () => {
+      if (attempted >= tools.length) {
+        reject(new Error("No clipboard tool found (install xclip, xsel, or wl-copy)"));
+        return;
+      }
+      const tool = tools[attempted];
+      attempted++;
+      const proc = execFile3(tool.cmd, tool.args, { timeout: 5e3 }, (err) => {
+        if (err) {
+          tryNext();
+        } else {
+          resolve();
+        }
+      });
+      if (proc.stdin) {
+        proc.stdin.write(text);
+        proc.stdin.end();
+      }
+    };
+    tryNext();
+  });
+}
+
+// src/commands/rewind.ts
+var rewindCommand = {
+  name: "rewind",
+  aliases: ["undo"],
+  description: "Remove the last conversation turn (user message + assistant response)",
+  async execute(_args, context) {
+    const messages = context.messages;
+    if (messages.length < 2) {
+      return { output: "Nothing to rewind.", silent: true };
+    }
+    let cutIdx = messages.length;
+    for (let i = messages.length - 1; i >= 0; i--) {
+      if (messages[i].role === "user") {
+        cutIdx = i;
+        break;
+      }
+    }
+    const removed = messages.length - cutIdx;
+    const kept = messages.slice(0, cutIdx);
+    return {
+      output: `Rewound ${removed} message${removed !== 1 ? "s" : ""}. Last turn removed.`,
+      replaceMessages: kept,
+      silent: true
+    };
+  }
+};
+
+// src/commands/review.ts
+var reviewCommand = {
+  name: "review",
+  aliases: ["code-review", "security-review"],
+  description: "Request an AI code review of recent changes or a file",
+  async execute(args, _context) {
+    const target = args.trim() || "the uncommitted changes in this repository";
+    const isSecurityReview = false;
+    const prompt = isSecurityReview ? `Perform a thorough security review of ${target}. Look for: injection vulnerabilities, authentication/authorization issues, data exposure, insecure defaults, dependency risks, and OWASP Top 10 concerns. Use Read, Grep, and Bash tools as needed.` : `Perform a code review of ${target}. Look for: bugs, logic errors, performance issues, code style problems, missing error handling, and potential improvements. Use Read, Grep, and Bash (for git diff) tools as needed. Be specific and actionable.`;
+    return { output: prompt, silent: false };
+  }
+};
+
+// 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");
+var configCommand = {
+  name: "config",
+  aliases: ["settings"],
+  description: "View or edit settings (usage: /config, /config set <key> <value>)",
+  async execute(args, _context) {
+    const parts = args.trim().split(/\s+/);
+    if (!args.trim() || parts[0] === "show") {
+      try {
+        const raw = await readFile2(SETTINGS_PATH, "utf-8");
+        const config = JSON.parse(raw);
+        return {
+          output: [
+            "\x1B[1m\x1B[36mSettings\x1B[0m",
+            `\x1B[2m${SETTINGS_PATH}\x1B[0m`,
+            "",
+            JSON.stringify(config, null, 2)
+          ].join("\n"),
+          silent: true
+        };
+      } catch {
+        return {
+          output: [
+            "\x1B[1m\x1B[36mSettings\x1B[0m",
+            "",
+            "No settings file found. Default settings in use.",
+            `\x1B[2mSettings will be created at: ${SETTINGS_PATH}\x1B[0m`
+          ].join("\n"),
+          silent: true
+        };
+      }
+    }
+    if (parts[0] === "set" && parts.length >= 3) {
+      const key = parts[1];
+      const value = parts.slice(2).join(" ");
+      let config;
+      try {
+        const raw = await readFile2(SETTINGS_PATH, "utf-8");
+        config = JSON.parse(raw);
+      } catch {
+        config = {};
+      }
+      let parsed = value;
+      if (value === "true") parsed = true;
+      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");
+      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");
+        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");
+      return { output: `Deleted ${key}`, silent: true };
+    }
+    return {
+      output: [
+        "Usage:",
+        "  /config              \u2014 Show current settings",
+        "  /config set <k> <v>  \u2014 Set a value",
+        "  /config delete <k>   \u2014 Delete a key"
+      ].join("\n"),
+      silent: true
+    };
+  }
+};
+
+// src/commands/theme.ts
+var THEMES = {
+  darkfoo: {
+    cyan: "#5eead4",
+    pink: "#f472b6",
+    green: "#4ade80",
+    yellow: "#fbbf24",
+    purple: "#a78bfa",
+    red: "#ef4444",
+    text: "#e2e8f0",
+    dim: "#7e8ea6"
+  },
+  neon: {
+    cyan: "#00ffff",
+    pink: "#ff00ff",
+    green: "#00ff00",
+    yellow: "#ffff00",
+    purple: "#8000ff",
+    red: "#ff0000",
+    text: "#ffffff",
+    dim: "#808080"
+  },
+  mono: {
+    cyan: "#aaaaaa",
+    pink: "#cccccc",
+    green: "#bbbbbb",
+    yellow: "#dddddd",
+    purple: "#999999",
+    red: "#eeeeee",
+    text: "#ffffff",
+    dim: "#666666"
+  },
+  ocean: {
+    cyan: "#64b5f6",
+    pink: "#f48fb1",
+    green: "#81c784",
+    yellow: "#fff176",
+    purple: "#ce93d8",
+    red: "#e57373",
+    text: "#e0e0e0",
+    dim: "#78909c"
+  }
+};
+var themeCommand = {
+  name: "theme",
+  description: "Switch color theme (usage: /theme <name>)",
+  async execute(args, _context) {
+    if (!args.trim()) {
+      const names = Object.keys(THEMES);
+      const lines = names.map((name2) => {
+        const t = THEMES[name2];
+        const swatch = `\x1B[38;2;${hexToRgb(t.cyan)}m\u25CF\x1B[0m\x1B[38;2;${hexToRgb(t.pink)}m\u25CF\x1B[0m\x1B[38;2;${hexToRgb(t.green)}m\u25CF\x1B[0m\x1B[38;2;${hexToRgb(t.yellow)}m\u25CF\x1B[0m\x1B[38;2;${hexToRgb(t.purple)}m\u25CF\x1B[0m`;
+        return `  ${name2.padEnd(10)} ${swatch}`;
+      });
+      return {
+        output: ["\x1B[1m\x1B[36mAvailable Themes\x1B[0m", "", ...lines, "", "\x1B[2mUsage: /theme <name>\x1B[0m"].join("\n"),
+        silent: true
+      };
+    }
+    const name = args.trim().toLowerCase();
+    if (!THEMES[name]) {
+      return { output: `Unknown theme: ${name}. Available: ${Object.keys(THEMES).join(", ")}`, silent: true };
+    }
+    const { theme: theme2 } = await import("./theme-BQAEFGVB.js");
+    const newTheme = THEMES[name];
+    Object.assign(theme2, newTheme);
+    return { output: `Theme switched to: ${name}`, silent: true };
+  }
+};
+function hexToRgb(hex) {
+  const r = parseInt(hex.slice(1, 3), 16);
+  const g = parseInt(hex.slice(3, 5), 16);
+  const b = parseInt(hex.slice(5, 7), 16);
+  return `${r};${g};${b}`;
+}
+
+// src/commands/export.ts
+import { writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
+import { join as join3 } from "path";
+var exportCommand = {
+  name: "export",
+  description: "Export conversation to markdown file (usage: /export [filename])",
+  async execute(args, context) {
+    if (context.messages.length === 0) {
+      return { output: "No conversation to export.", silent: true };
+    }
+    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 lines = [
+      `# Darkfoo Code Session`,
+      ``,
+      `**Model:** ${context.model}`,
+      `**Working Directory:** ${context.cwd}`,
+      `**Date:** ${(/* @__PURE__ */ new Date()).toISOString()}`,
+      `**Messages:** ${context.messages.length}`,
+      ``,
+      `---`,
+      ``
+    ];
+    for (const msg of context.messages) {
+      switch (msg.role) {
+        case "user":
+          lines.push(`## User`, ``, msg.content, ``);
+          break;
+        case "assistant":
+          if (msg.content) {
+            lines.push(`## Assistant`, ``, msg.content, ``);
+          }
+          if (msg.toolCalls) {
+            for (const tc of msg.toolCalls) {
+              lines.push(`> **Tool Call:** \`${tc.function.name}\``, `> \`\`\`json`, `> ${JSON.stringify(tc.function.arguments)}`, `> \`\`\``, ``);
+            }
+          }
+          break;
+        case "tool":
+          lines.push(`> **[${msg.toolName}]** result:`, `> \`\`\``, `> ${msg.content.slice(0, 500)}`, `> \`\`\``, ``);
+          break;
+      }
+    }
+    await writeFile3(filePath, lines.join("\n"), "utf-8");
+    return { output: `Exported to ${filePath}`, silent: true };
+  }
+};
+
+// src/commands/status.ts
+var statusCommand = {
+  name: "status",
+  description: "Show session status overview",
+  async execute(_args, context) {
+    const state = 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 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;
+    const lines = [
+      "\x1B[1m\x1B[36mSession Status\x1B[0m",
+      "",
+      `  Model:            \x1B[36m${context.model}\x1B[0m`,
+      `  Working Dir:      ${context.cwd}`,
+      `  Plan Mode:        ${state.planMode ? "\x1B[33mActive\x1B[0m" : "Off"}`,
+      "",
+      "  \x1B[1mMessages\x1B[0m",
+      `    User:           ${userMsgs}`,
+      `    Assistant:       ${assistantMsgs}`,
+      `    Tool results:    ${toolMsgs}`,
+      `    Est. tokens:     ~${estTokens.toLocaleString()}`,
+      "",
+      "  \x1B[1mTasks\x1B[0m",
+      `    Pending:         ${pending}`,
+      `    In Progress:     ${inProgress}`,
+      `    Completed:       ${completed}`,
+      "",
+      `  Files tracked:     ${trackedFileCount()}`
+    ];
+    return { output: lines.join("\n"), silent: true };
+  }
+};
+
+// src/commands/files.ts
+var filesCommand = {
+  name: "files",
+  description: "List files modified or referenced in this session",
+  async execute(_args, context) {
+    const readFiles = /* @__PURE__ */ new Set();
+    const writtenFiles = /* @__PURE__ */ new Set();
+    const editedFiles = /* @__PURE__ */ new Set();
+    for (const msg of context.messages) {
+      if (msg.role === "assistant" && msg.toolCalls) {
+        for (const tc of msg.toolCalls) {
+          const args = tc.function.arguments;
+          const path = typeof args.file_path === "string" ? args.file_path : null;
+          if (!path) continue;
+          switch (tc.function.name) {
+            case "Read":
+              readFiles.add(path);
+              break;
+            case "Write":
+              writtenFiles.add(path);
+              break;
+            case "Edit":
+              editedFiles.add(path);
+              break;
+          }
+        }
+      }
+    }
+    if (readFiles.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) {
+      lines.push("  \x1B[1mRead:\x1B[0m");
+      for (const f of readFiles) lines.push(`    \x1B[36m${f}\x1B[0m`);
+      lines.push("");
+    }
+    if (writtenFiles.size > 0) {
+      lines.push("  \x1B[1mWritten:\x1B[0m");
+      for (const f of writtenFiles) lines.push(`    \x1B[32m${f}\x1B[0m`);
+      lines.push("");
+    }
+    if (editedFiles.size > 0) {
+      lines.push("  \x1B[1mEdited:\x1B[0m");
+      for (const f of editedFiles) lines.push(`    \x1B[33m${f}\x1B[0m`);
+      lines.push("");
+    }
+    return { output: lines.join("\n"), silent: true };
+  }
+};
+
+// src/commands/brief.ts
+var briefCommand = {
+  name: "brief",
+  aliases: ["summary"],
+  description: "Show a quick summary of the conversation so far",
+  async execute(_args, context) {
+    if (context.messages.length === 0) {
+      return { output: "No conversation yet.", silent: true };
+    }
+    const userMsgs = context.messages.filter((m) => m.role === "user");
+    const toolCalls = context.messages.filter((m) => m.role === "assistant" && m.toolCalls).flatMap((m) => m.toolCalls ?? []);
+    const toolCounts = /* @__PURE__ */ new Map();
+    for (const tc of toolCalls) {
+      const name = tc.function.name;
+      toolCounts.set(name, (toolCounts.get(name) || 0) + 1);
+    }
+    const lines = [
+      "\x1B[1m\x1B[36mSession Brief\x1B[0m",
+      "",
+      `  Turns: ${userMsgs.length}`
+    ];
+    if (userMsgs.length > 0) {
+      lines.push("", "  \x1B[1mRecent prompts:\x1B[0m");
+      const recent = userMsgs.slice(-5);
+      for (const msg of recent) {
+        const preview = msg.content.length > 70 ? msg.content.slice(0, 70) + "..." : msg.content;
+        lines.push(`    \x1B[2m\u2022\x1B[0m ${preview}`);
+      }
+    }
+    if (toolCounts.size > 0) {
+      lines.push("", "  \x1B[1mTools used:\x1B[0m");
+      const sorted = [...toolCounts.entries()].sort((a, b) => b[1] - a[1]);
+      for (const [name, count] of sorted) {
+        lines.push(`    ${name}: ${count}x`);
+      }
+    }
+    return { output: lines.join("\n"), silent: true };
+  }
+};
+
+// src/commands/provider.ts
+var providerCommand = {
+  name: "provider",
+  aliases: ["backend"],
+  description: "List, switch, or add LLM providers (usage: /provider [name], /provider add <name> <url>)",
+  async execute(args, _context) {
+    const parts = args.trim().split(/\s+/);
+    const subcommand = parts[0]?.toLowerCase();
+    if (!subcommand) {
+      const results = await discoverProviders();
+      const active = getActiveProviderName();
+      const lines = [
+        "\x1B[1m\x1B[36mLLM Providers\x1B[0m",
+        ""
+      ];
+      for (const { config, online } of results) {
+        const status = online ? "\x1B[32m\u25CF online\x1B[0m" : "\x1B[31m\u25CF offline\x1B[0m";
+        const isActive = config.name === active ? " \x1B[36m\u2190 active\x1B[0m" : "";
+        lines.push(`  ${config.name.padEnd(14)} ${config.label.padEnd(14)} ${config.baseUrl.padEnd(30)} ${status}${isActive}`);
+      }
+      lines.push(
+        "",
+        "\x1B[2mUsage:\x1B[0m",
+        "  /provider <name>                      \u2014 Switch active provider",
+        "  /provider add <name> <url> [label]     \u2014 Add a custom provider",
+        "  /provider remove <name>                \u2014 Remove a custom provider",
+        "  /provider models                       \u2014 List models from active provider"
+      );
+      return { output: lines.join("\n"), silent: true };
+    }
+    if (subcommand !== "add" && subcommand !== "remove" && subcommand !== "models") {
+      try {
+        setActiveProvider(subcommand);
+        await saveProviderSettings();
+        const configs = getProviderConfigs();
+        const config = configs.find((c) => c.name === subcommand);
+        return { output: `Switched to provider: ${config?.label || subcommand} (${config?.baseUrl})`, silent: true };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { output: msg, silent: true };
+      }
+    }
+    if (subcommand === "add") {
+      const name = parts[1];
+      const url = parts[2];
+      const label = parts.slice(3).join(" ") || name;
+      if (!name || !url) {
+        return { output: "Usage: /provider add <name> <url> [label]", silent: true };
+      }
+      const config = { type: "openai", name, label: label || name, baseUrl: url };
+      upsertProviderConfig(config);
+      await saveProviderSettings();
+      return { output: `Added provider: ${name} \u2192 ${url}`, silent: true };
+    }
+    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)) {
+        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 provider = getProvider2();
+      const models = await provider.listModels();
+      if (models.length === 0) {
+        return { output: `No models found from ${provider.label}.`, silent: true };
+      }
+      const lines = [
+        `\x1B[1m\x1B[36mModels from ${provider.label}\x1B[0m`,
+        "",
+        ...models.map((m) => {
+          const extra = [m.size, m.family].filter(Boolean).join(", ");
+          return `  ${m.name}${extra ? `  (${extra})` : ""}`;
+        })
+      ];
+      return { output: lines.join("\n"), silent: true };
+    }
+    return { output: "Unknown subcommand. See /provider for usage.", silent: true };
+  }
+};
+
+// src/commands/index.ts
+var COMMANDS = [
+  helpCommand,
+  clearCommand,
+  exitCommand,
+  modelCommand,
+  compactCommand,
+  costCommand,
+  contextCommand,
+  diffCommand,
+  historyCommand,
+  resumeCommand,
+  commitCommand,
+  copyCommand,
+  rewindCommand,
+  reviewCommand,
+  configCommand,
+  themeCommand,
+  exportCommand,
+  statusCommand,
+  filesCommand,
+  briefCommand,
+  providerCommand
+];
+function getCommands() {
+  return COMMANDS;
+}
+async function dispatchCommand(input, context) {
+  if (!input.startsWith("/")) return null;
+  const [rawName, ...rest] = input.slice(1).split(/\s+/);
+  const name = rawName?.toLowerCase();
+  if (!name) return null;
+  const args = rest.join(" ");
+  const cmd = COMMANDS.find(
+    (c) => c.name === name || c.aliases?.includes(name)
+  );
+  if (!cmd) {
+    return {
+      output: `Unknown command: /${name}. Type /help for available commands.`,
+      silent: true
+    };
+  }
+  return cmd.execute(args, context);
+}
+function getCommandNames() {
+  const names = [];
+  for (const cmd of COMMANDS) {
+    names.push("/" + cmd.name);
+    if (cmd.aliases) {
+      for (const alias of cmd.aliases) {
+        names.push("/" + alias);
+      }
+    }
+  }
+  return names.sort();
+}
+
+// src/components/UserInput.tsx
+import { Fragment as Fragment2, jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+function UserInput({ value, onChange, onSubmit, disabled, history }) {
+  const [historyIdx, setHistoryIdx] = useState(-1);
+  const [suggestion, setSuggestion] = useState("");
+  useInput((_input, key) => {
+    if (disabled || !history || history.length === 0) return;
+    if (key.upArrow) {
+      const nextIdx = Math.min(historyIdx + 1, history.length - 1);
+      setHistoryIdx(nextIdx);
+      onChange(history[nextIdx]);
+    } else if (key.downArrow) {
+      if (historyIdx <= 0) {
+        setHistoryIdx(-1);
+        onChange("");
+      } else {
+        const nextIdx = historyIdx - 1;
+        setHistoryIdx(nextIdx);
+        onChange(history[nextIdx]);
+      }
+    }
+  });
+  const handleChange = useCallback(
+    (val) => {
+      onChange(val);
+      setHistoryIdx(-1);
+      if (val.startsWith("/") && val.length > 1 && !val.includes(" ")) {
+        const matches = getCommandNames().filter((n) => n.startsWith(val));
+        if (matches.length === 1 && matches[0] !== val) {
+          setSuggestion(matches[0].slice(val.length));
+        } else {
+          setSuggestion("");
+        }
+      } else {
+        setSuggestion("");
+      }
+    },
+    [onChange]
+  );
+  useInput((input, key) => {
+    if (key.tab && suggestion) {
+      onChange(value + suggestion);
+      setSuggestion("");
+    }
+  });
+  const isBash = value.startsWith("!");
+  const isCommand = value.startsWith("/");
+  const borderColor = disabled ? theme.dim : isBash ? theme.yellow : isCommand ? theme.purple : theme.cyan;
+  const promptChar = isBash ? "!" : "\u276F";
+  const promptColor = isBash ? theme.yellow : theme.cyan;
+  return /* @__PURE__ */ jsxs5(
+    Box5,
+    {
+      borderStyle: "round",
+      borderColor,
+      paddingLeft: 1,
+      paddingRight: 1,
+      children: [
+        /* @__PURE__ */ jsxs5(Text5, { color: disabled ? theme.dim : promptColor, bold: true, children: [
+          promptChar,
+          " "
+        ] }),
+        disabled ? /* @__PURE__ */ jsx6(Text5, { color: theme.dim, children: "..." }) : /* @__PURE__ */ jsxs5(Fragment2, { children: [
+          /* @__PURE__ */ jsx6(
+            TextInput,
+            {
+              value,
+              onChange: handleChange,
+              onSubmit: (val) => {
+                if (val.trim()) {
+                  setSuggestion("");
+                  setHistoryIdx(-1);
+                  onSubmit(val.trim());
+                }
+              }
+            }
+          ),
+          suggestion ? /* @__PURE__ */ jsx6(Text5, { color: theme.dim, children: suggestion }) : null
+        ] })
+      ]
+    }
+  );
+}
+
+// src/repl.tsx
+import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
+function getContextLimit3(model) {
+  const lower = model.toLowerCase();
+  if (lower.includes("llama3.1")) return 131072;
+  if (lower.includes("llama3.2")) return 131072;
+  if (lower.includes("qwen")) return 32768;
+  if (lower.includes("gemma")) return 8192;
+  if (lower.includes("phi")) return 16384;
+  if (lower.includes("deepseek")) return 32768;
+  return 8192;
+}
+function REPL({ initialPrompt }) {
+  const { model: initialModel, systemPromptOverride } = useDarkfooContext();
+  const { exit } = useApp();
+  const [model, setModel] = useState2(initialModel);
+  const [messages, setMessages] = useState2([]);
+  const [inputValue, setInputValue] = useState2("");
+  const [isStreaming, setIsStreaming] = useState2(false);
+  const [streamingText, setStreamingText] = useState2("");
+  const [activeTool, setActiveTool] = useState2(null);
+  const [toolResults, setToolResults] = useState2([]);
+  const [commandOutput, setCommandOutput] = useState2(null);
+  const [inputHistory, setInputHistory] = useState2([]);
+  const [tokenCounts, setTokenCounts] = useState2({ input: 0, output: 0 });
+  const [systemPrompt, setSystemPrompt] = useState2("");
+  const abortRef = useRef(null);
+  const hasRun = useRef(false);
+  const sessionId = useRef(createSessionId());
+  const tools = getTools();
+  const cwd = process.cwd();
+  useEffect(() => {
+    if (systemPromptOverride) {
+      setSystemPrompt(systemPromptOverride);
+    } else {
+      buildSystemPrompt(tools, cwd).then(setSystemPrompt);
+    }
+  }, []);
+  const commandContext = {
+    messages,
+    model,
+    cwd,
+    setModel,
+    clearMessages: () => setMessages([]),
+    exit,
+    tokenCounts
+  };
+  const addToHistory = useCallback2((input) => {
+    setInputHistory((prev) => {
+      const filtered = prev.filter((h) => h !== input);
+      return [input, ...filtered].slice(0, 100);
+    });
+  }, []);
+  const runQuery = useCallback2(
+    async (userMessage) => {
+      const userMsg = {
+        id: nanoid3(),
+        role: "user",
+        content: userMessage,
+        timestamp: Date.now()
+      };
+      setMessages((prev) => [...prev, userMsg]);
+      setIsStreaming(true);
+      setStreamingText("");
+      setToolResults([]);
+      setCommandOutput(null);
+      const controller = new AbortController();
+      abortRef.current = controller;
+      const allMessages = [...messages, userMsg];
+      setTokenCounts((prev) => ({
+        ...prev,
+        input: prev.input + Math.ceil(userMessage.length / 4)
+      }));
+      try {
+        for await (const event of query({
+          model,
+          messages: allMessages,
+          tools,
+          systemPrompt,
+          signal: controller.signal
+        })) {
+          if (controller.signal.aborted) break;
+          switch (event.type) {
+            case "text_delta":
+              setStreamingText((prev) => prev + event.text);
+              break;
+            case "tool_call":
+              setActiveTool({ name: event.toolCall.function.name, args: event.toolCall.function.arguments });
+              break;
+            case "tool_result":
+              setActiveTool(null);
+              setToolResults((prev) => [
+                ...prev,
+                { id: nanoid3(), toolName: event.toolName, output: event.output, isError: event.isError }
+              ]);
+              break;
+            case "assistant_message":
+              setMessages((prev) => {
+                const updated = [...prev, event.message];
+                saveSession(sessionId.current, updated, model, cwd).catch(() => {
+                });
+                return updated;
+              });
+              setTokenCounts((prev) => ({
+                ...prev,
+                output: prev.output + Math.ceil((event.message.content?.length ?? 0) / 4)
+              }));
+              setStreamingText("");
+              break;
+            case "error":
+              setMessages((prev) => [
+                ...prev,
+                { id: nanoid3(), role: "assistant", content: `Error: ${event.error}`, timestamp: Date.now() }
+              ]);
+              break;
+          }
+        }
+      } catch (err) {
+        if (err.name !== "AbortError") {
+          const msg = err instanceof Error ? err.message : String(err);
+          setMessages((prev) => [
+            ...prev,
+            { id: nanoid3(), role: "assistant", content: `Error: ${msg}`, timestamp: Date.now() }
+          ]);
+        }
+      } finally {
+        setIsStreaming(false);
+        setStreamingText("");
+        setActiveTool(null);
+        setToolResults([]);
+        abortRef.current = null;
+      }
+    },
+    [model, messages, tools, systemPrompt]
+  );
+  const handleSubmit = useCallback2(
+    async (value) => {
+      setInputValue("");
+      addToHistory(value);
+      setCommandOutput(null);
+      const lower = value.toLowerCase().trim();
+      if (lower === "exit" || lower === "quit" || lower === "q") {
+        exit();
+        return;
+      }
+      if (value.startsWith("/")) {
+        const result = await dispatchCommand(value, commandContext);
+        if (result) {
+          if (result.replaceMessages) {
+            setMessages(result.replaceMessages);
+          }
+          if (result.exit) return;
+          if (!result.silent && result.output) {
+            runQuery(result.output);
+            return;
+          }
+          if (result.output) {
+            setCommandOutput(result.output);
+          }
+        }
+        return;
+      }
+      if (value.startsWith("!")) {
+        const cmd = value.slice(1).trim();
+        if (!cmd) return;
+        setIsStreaming(true);
+        setCommandOutput(null);
+        try {
+          const result = await BashTool.call(
+            { command: cmd },
+            { cwd, abortSignal: new AbortController().signal }
+          );
+          setCommandOutput(result.output);
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          setCommandOutput(`Error: ${msg}`);
+        } finally {
+          setIsStreaming(false);
+        }
+        return;
+      }
+      runQuery(value);
+    },
+    [addToHistory, commandContext, cwd, runQuery]
+  );
+  useEffect(() => {
+    if (initialPrompt && !hasRun.current) {
+      hasRun.current = true;
+      runQuery(initialPrompt);
+    }
+  }, [initialPrompt, runQuery]);
+  const autoCompactRef = useRef(false);
+  useEffect(() => {
+    if (isStreaming || autoCompactRef.current || messages.length < 6) return;
+    const totalChars = messages.reduce((sum, m) => sum + m.content.length, 0);
+    const estTokens = Math.ceil(totalChars / 4) + 2e3;
+    const limit = getContextLimit3(model);
+    const usage = estTokens / limit;
+    if (usage > 0.85) {
+      autoCompactRef.current = true;
+      setCommandOutput("\x1B[33m\u26A0 Context 85%+ full \u2014 auto-compacting...\x1B[0m");
+      const transcript = messages.filter((m) => m.role === "user" || m.role === "assistant" && m.content).map((m) => `${m.role}: ${m.content}`).join("\n\n");
+      getProvider().chat({
+        model,
+        messages: [{ role: "user", content: `Summarize concisely. Capture key decisions, code changes, file paths, and current task state:
+
+${transcript}` }]
+      }).then((result) => {
+        const summaryMsg = {
+          id: nanoid3(),
+          role: "user",
+          content: `[Auto-compacted summary]
+${result.content}
+[End summary]`,
+          timestamp: Date.now()
+        };
+        setMessages([summaryMsg]);
+        setTokenCounts({ input: Math.ceil(result.content.length / 4), output: 0 });
+        setCommandOutput("\x1B[32m\u2713 Auto-compacted conversation.\x1B[0m");
+        autoCompactRef.current = false;
+      }).catch(() => {
+        setCommandOutput("\x1B[31m\u2717 Auto-compact failed.\x1B[0m");
+        autoCompactRef.current = false;
+      });
+    }
+  }, [messages, model, isStreaming]);
+  useInput2((input, key) => {
+    if (key.ctrl && input === "c") {
+      if (isStreaming && abortRef.current) {
+        abortRef.current.abort();
+      } else {
+        exit();
+      }
+    }
+  });
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsx7(Banner, { model, cwd }),
+    /* @__PURE__ */ jsx7(Messages, { messages }),
+    commandOutput ? /* @__PURE__ */ jsx7(Box6, { marginBottom: 1, marginLeft: 2, flexDirection: "column", children: /* @__PURE__ */ jsx7(Text6, { children: commandOutput }) }) : null,
+    toolResults.map((tr) => /* @__PURE__ */ jsx7(ToolResultDisplay, { toolName: tr.toolName, output: tr.output, isError: tr.isError }, tr.id)),
+    activeTool ? /* @__PURE__ */ jsx7(ActiveToolCall, { toolName: activeTool.name, args: activeTool.args }) : null,
+    isStreaming && streamingText ? /* @__PURE__ */ jsxs6(Box6, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsx7(Text6, { color: theme.cyan, children: "\u23BF " }),
+      /* @__PURE__ */ jsx7(Text6, { color: theme.text, wrap: "wrap", children: streamingText }),
+      /* @__PURE__ */ jsxs6(Text6, { color: theme.cyan, children: [
+        " ",
+        /* @__PURE__ */ jsx7(Spinner2, { type: "dots" })
+      ] })
+    ] }) : null,
+    isStreaming && !streamingText && !activeTool ? /* @__PURE__ */ jsxs6(Box6, { marginLeft: 2, children: [
+      /* @__PURE__ */ jsx7(Text6, { color: theme.cyan, children: /* @__PURE__ */ jsx7(Spinner2, { type: "dots" }) }),
+      /* @__PURE__ */ jsx7(Text6, { color: theme.dim, children: " Thinking..." })
+    ] }) : null,
+    /* @__PURE__ */ jsx7(
+      UserInput,
+      {
+        value: inputValue,
+        onChange: setInputValue,
+        onSubmit: handleSubmit,
+        disabled: isStreaming,
+        history: inputHistory
+      }
+    ),
+    /* @__PURE__ */ jsx7(
+      StatusLine,
+      {
+        model,
+        messageCount: messages.length,
+        tokenEstimate: tokenCounts.input + tokenCounts.output,
+        isStreaming
+      }
+    )
+  ] });
+}
+
+// src/main.tsx
+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) => {
+  const { model, prompt, provider, systemPrompt } = options;
+  await loadProviderSettings();
+  if (provider) {
+    try {
+      setActiveProvider(provider);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${msg}
+`);
+      process.exit(1);
+    }
+  }
+  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 tools = getTools2();
+    const sysPrompt = systemPrompt ?? await buildSystemPrompt2(tools, process.cwd());
+    const { nanoid: nanoid4 } = await import("nanoid");
+    const userMsg = {
+      id: nanoid4(),
+      role: "user",
+      content: prompt,
+      timestamp: Date.now()
+    };
+    const controller = new AbortController();
+    process.on("SIGINT", () => {
+      controller.abort();
+      process.exit(0);
+    });
+    for await (const event of query2({
+      model,
+      messages: [userMsg],
+      tools,
+      systemPrompt: sysPrompt,
+      signal: controller.signal
+    })) {
+      switch (event.type) {
+        case "text_delta":
+          process.stdout.write(event.text);
+          break;
+        case "tool_result":
+          if (event.isError) {
+            process.stderr.write(`
+[${event.toolName}] Error: ${event.output}
+`);
+          }
+          break;
+        case "error":
+          process.stderr.write(`
+Error: ${event.error}
+`);
+          break;
+      }
+    }
+    process.stdout.write("\n");
+    process.exit(0);
+  }
+  const { waitUntilExit } = render(
+    /* @__PURE__ */ jsx8(App, { model, systemPromptOverride: systemPrompt, children: /* @__PURE__ */ jsx8(REPL, {}) })
+  );
+  await waitUntilExit();
+});
+program.parse();