darkfoo-code 0.1.2 → 0.1.4

package/dist/chunk-BT7IPQDS.js

@@ -1,19 +0,0 @@
-// src/utils/theme.ts
-var 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"
-};
-
-export {
-  theme
-};

package/dist/chunk-GQXUHUV4.js

@@ -1,171 +0,0 @@
-import {
-  getProvider
-} from "./chunk-OBL22IIN.js";
-
-// src/query.ts
-import { nanoid } from "nanoid";
-
-// src/permissions.ts
-import { readFile, writeFile, mkdir } from "fs/promises";
-import { join } from "path";
-var SETTINGS_PATH = join(process.env.HOME || "~", ".darkfoo", "settings.json");
-var cachedSettings = null;
-async function loadSettings() {
-  if (cachedSettings) return cachedSettings;
-  try {
-    const raw = await readFile(SETTINGS_PATH, "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";
-}
-
-// src/query.ts
-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: nanoid(),
-      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: nanoid(), 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: nanoid(), 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: nanoid(), 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: nanoid(), 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;
-}
-
-export {
-  query
-};

package/dist/chunk-OBL22IIN.js

@@ -1,400 +0,0 @@
-// src/providers/index.ts
-import { readFile, writeFile, mkdir } from "fs/promises";
-import { join } from "path";
-
-// src/providers/ollama.ts
-var 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;
-    }
-  }
-};
-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 } };
-}
-
-// src/providers/openai-compat.ts
-var 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 SETTINGS_PATH = join(process.env.HOME || "~", ".darkfoo", "settings.json");
-var 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" }
-];
-var activeProviderName = "ollama";
-var providerConfigs = [...DEFAULT_PROVIDERS];
-var providerInstances = /* @__PURE__ */ new Map();
-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;
-}
-
-export {
-  getProvider,
-  getProviderByName,
-  getActiveProviderName,
-  setActiveProvider,
-  getProviderConfigs,
-  upsertProviderConfig,
-  removeProviderConfig,
-  loadProviderSettings,
-  saveProviderSettings,
-  discoverProviders
-};

package/dist/chunk-VSJKCANO.js

@@ -1,117 +0,0 @@
-// src/context-loader.ts
-import { readFile, readdir, access } from "fs/promises";
-import { join, dirname, resolve } from "path";
-var CONTEXT_FILES = ["DARKFOO.md", ".darkfoo/DARKFOO.md"];
-var RULES_DIR = ".darkfoo/rules";
-var HOME_CONTEXT = join(process.env.HOME || "~", ".darkfoo", "DARKFOO.md");
-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 = join(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 = join(cwd, RULES_DIR);
-  try {
-    await access(rulesDir);
-    const files = await readdir(rulesDir);
-    for (const file of files.filter((f) => f.endsWith(".md")).sort()) {
-      const content = await tryRead(join(rulesDir, file));
-      if (content) {
-        parts.push(`# Rule: ${file}
-
-${content}`);
-      }
-    }
-  } catch {
-  }
-  return parts.join("\n\n---\n\n");
-}
-async function tryRead(path) {
-  try {
-    return await readFile(path, "utf-8");
-  } catch {
-    return null;
-  }
-}
-
-// src/system-prompt.ts
-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;
-}
-
-export {
-  buildSystemPrompt
-};