botholomew 0.1.0

package/src/commands/upgrade.ts

@@ -0,0 +1,185 @@
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { dim, green, red, yellow } from "ansis";
+import { $ } from "bun";
+import type { Command } from "commander";
+import {
+  clearUpdateCache,
+  loadUpdateCache,
+  saveUpdateCache,
+} from "../update/cache.ts";
+import type { UpdateCache } from "../update/checker.ts";
+import {
+  checkForUpdate,
+  detectInstallMethod,
+  type InstallMethod,
+  needsCheck,
+} from "../update/checker.ts";
+
+const pkg = await Bun.file(
+  new URL("../../package.json", import.meta.url),
+).json();
+
+const GITHUB_REPO = (pkg.repository.url as string)
+  .replace(/^https:\/\/github\.com\//, "")
+  .replace(/\.git$/, "");
+
+function platformArtifactName(): string {
+  let os: string;
+  let ext = "";
+  switch (process.platform) {
+    case "darwin":
+      os = "darwin";
+      break;
+    case "win32":
+      os = "windows";
+      ext = ".exe";
+      break;
+    default:
+      os = "linux";
+      break;
+  }
+  const arch = process.arch === "arm64" ? "arm64" : "x64";
+  return `botholomew-${os}-${arch}${ext}`;
+}
+
+async function upgradeWithPackageManager(
+  command: string,
+  args: string[],
+): Promise<boolean> {
+  const result = await $`${command} ${args}`.nothrow();
+  return result.exitCode === 0;
+}
+
+async function upgradeFromBinary(latestVersion: string): Promise<boolean> {
+  const artifact = platformArtifactName();
+  const tag = `v${latestVersion}`;
+  const url = `https://github.com/${GITHUB_REPO}/releases/download/${tag}/${artifact}`;
+
+  const tmpPath = join(tmpdir(), `botholomew-upgrade-${Date.now()}`);
+  const targetPath = process.execPath;
+
+  try {
+    const res = await fetch(url);
+    if (!res.ok) {
+      console.error(red(`Failed to download binary: HTTP ${res.status}`));
+      return false;
+    }
+
+    const bytes = await res.arrayBuffer();
+    await Bun.write(tmpPath, bytes);
+
+    await $`chmod +x ${tmpPath}`.quiet();
+
+    // Try to move into place
+    const mv = await $`mv ${tmpPath} ${targetPath}`.quiet().nothrow();
+
+    if (mv.exitCode !== 0) {
+      // Try with sudo
+      console.log(dim("Requires elevated permissions..."));
+      const sudo = await $`sudo mv ${tmpPath} ${targetPath}`.nothrow();
+      if (sudo.exitCode !== 0) {
+        console.error(red("Failed to install binary. Try running with sudo."));
+        return false;
+      }
+    }
+
+    return true;
+  } catch (err) {
+    console.error(red(`Failed to upgrade binary: ${err}`));
+    // Clean up temp file
+    await $`rm -f ${tmpPath}`.quiet().nothrow();
+    return false;
+  }
+}
+
+export function registerUpgradeCommand(program: Command) {
+  program
+    .command("upgrade")
+    .description("Upgrade botholomew to the latest version")
+    .action(async () => {
+      try {
+        // Check for update (use cache if fresh)
+        const cache = await loadUpdateCache();
+        let latestVersion: string;
+        let hasUpdate: boolean;
+
+        if (!needsCheck(cache) && cache) {
+          latestVersion = cache.latestVersion;
+          hasUpdate = cache.hasUpdate;
+        } else {
+          const info = await checkForUpdate(pkg.version);
+          latestVersion = info.latestVersion;
+          hasUpdate = info.hasUpdate;
+
+          const newCache: UpdateCache = {
+            lastCheckAt: new Date().toISOString(),
+            latestVersion,
+            hasUpdate,
+            changelog: info.changelog,
+          };
+          await saveUpdateCache(newCache);
+        }
+
+        if (!hasUpdate) {
+          console.log(
+            green(`botholomew is already up to date (v${pkg.version})`),
+          );
+          return;
+        }
+
+        const method: InstallMethod = detectInstallMethod();
+        console.log(
+          `Upgrading from v${pkg.version} to v${latestVersion} (${method})...`,
+        );
+
+        let success = false;
+
+        switch (method) {
+          case "bun":
+            success = await upgradeWithPackageManager("bun", [
+              "install",
+              "-g",
+              `${pkg.name}@${latestVersion}`,
+            ]);
+            break;
+
+          case "npm":
+            success = await upgradeWithPackageManager("npm", [
+              "install",
+              "-g",
+              `${pkg.name}@${latestVersion}`,
+            ]);
+            break;
+
+          case "binary":
+            success = await upgradeFromBinary(latestVersion);
+            break;
+
+          case "local-dev":
+            console.log(
+              yellow(
+                "Running from source. Use `git pull && bun install` to update.",
+              ),
+            );
+            return;
+        }
+
+        if (success) {
+          await clearUpdateCache();
+          console.log(
+            green(
+              `Successfully upgraded botholomew: v${pkg.version} → v${latestVersion}`,
+            ),
+          );
+        } else {
+          console.error(red("Upgrade failed. See errors above."));
+          process.exit(1);
+        }
+      } catch (err) {
+        console.error("Upgrade failed");
+        console.error(String(err));
+        process.exit(1);
+      }
+    });
+}

package/src/config/loader.ts

@@ -0,0 +1,31 @@
+import { getConfigPath } from "../constants.ts";
+import { type BotholomewConfig, DEFAULT_CONFIG } from "./schemas.ts";
+
+export async function loadConfig(
+  projectDir: string,
+): Promise<Required<BotholomewConfig>> {
+  const configPath = getConfigPath(projectDir);
+  const file = Bun.file(configPath);
+
+  let userConfig: Partial<BotholomewConfig> = {};
+  if (await file.exists()) {
+    userConfig = JSON.parse(await file.text());
+  }
+
+  const config = { ...DEFAULT_CONFIG, ...userConfig };
+
+  // env var override takes precedence
+  if (process.env.ANTHROPIC_API_KEY) {
+    config.anthropic_api_key = process.env.ANTHROPIC_API_KEY;
+  }
+
+  return config;
+}
+
+export async function saveConfig(
+  projectDir: string,
+  config: Partial<BotholomewConfig>,
+): Promise<void> {
+  const configPath = getConfigPath(projectDir);
+  await Bun.write(configPath, `${JSON.stringify(config, null, 2)}\n`);
+}

package/src/config/schemas.ts

@@ -0,0 +1,15 @@
+export interface BotholomewConfig {
+  anthropic_api_key?: string;
+  model?: string;
+  tick_interval_seconds?: number;
+  max_tick_duration_seconds?: number;
+  system_prompt_override?: string;
+}
+
+export const DEFAULT_CONFIG: Required<BotholomewConfig> = {
+  anthropic_api_key: "",
+  model: "claude-sonnet-4-20250514",
+  tick_interval_seconds: 300,
+  max_tick_duration_seconds: 120,
+  system_prompt_override: "",
+};

package/src/constants.ts

@@ -0,0 +1,44 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export const BOTHOLOMEW_DIR = ".botholomew";
+export const HOME_CONFIG_DIR = join(homedir(), ".botholomew");
+
+export const ENV = {
+  NO_UPDATE_CHECK: "BOTHOLOMEW_NO_UPDATE_CHECK",
+} as const;
+
+export const DEFAULTS = {
+  UPDATE_CHECK_INTERVAL_MS: 24 * 60 * 60 * 1000, // 24 hours
+  UPDATE_CHECK_TIMEOUT_MS: 5_000,
+} as const;
+export const DB_FILENAME = "data.sqlite";
+export const PID_FILENAME = "daemon.pid";
+export const LOG_FILENAME = "daemon.log";
+export const CONFIG_FILENAME = "config.json";
+export const MCPX_DIR = "mcpx";
+export const MCPX_SERVERS_FILENAME = "servers.json";
+
+export function getBotholomewDir(projectDir: string): string {
+  return join(projectDir, BOTHOLOMEW_DIR);
+}
+
+export function getDbPath(projectDir: string): string {
+  return join(projectDir, BOTHOLOMEW_DIR, DB_FILENAME);
+}
+
+export function getPidPath(projectDir: string): string {
+  return join(projectDir, BOTHOLOMEW_DIR, PID_FILENAME);
+}
+
+export function getLogPath(projectDir: string): string {
+  return join(projectDir, BOTHOLOMEW_DIR, LOG_FILENAME);
+}
+
+export function getConfigPath(projectDir: string): string {
+  return join(projectDir, BOTHOLOMEW_DIR, CONFIG_FILENAME);
+}
+
+export function getMcpxDir(projectDir: string): string {
+  return join(projectDir, BOTHOLOMEW_DIR, MCPX_DIR);
+}

package/src/daemon/index.ts

@@ -0,0 +1,39 @@
+import { loadConfig } from "../config/loader.ts";
+import { getDbPath } from "../constants.ts";
+import { getConnection } from "../db/connection.ts";
+import { migrate } from "../db/schema.ts";
+import { logger } from "../utils/logger.ts";
+import { removePidFile, writePidFile } from "../utils/pid.ts";
+import { tick } from "./tick.ts";
+
+export async function startDaemon(projectDir: string): Promise<void> {
+  const config = await loadConfig(projectDir);
+  const dbPath = getDbPath(projectDir);
+  const conn = getConnection(dbPath);
+  migrate(conn);
+
+  writePidFile(projectDir, process.pid);
+
+  const shutdown = async () => {
+    logger.info("Daemon shutting down...");
+    await removePidFile(projectDir);
+    conn.close();
+    process.exit(0);
+  };
+
+  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", shutdown);
+
+  logger.info(`Daemon started for ${projectDir} (PID ${process.pid})`);
+  logger.info(`Tick interval: ${config.tick_interval_seconds}s`);
+
+  while (true) {
+    try {
+      await tick(projectDir, conn, config);
+    } catch (err) {
+      logger.error(`Tick failed: ${err}`);
+    }
+
+    await Bun.sleep(config.tick_interval_seconds * 1000);
+  }
+}

package/src/daemon/llm.ts

@@ -0,0 +1,186 @@
+import Anthropic from "@anthropic-ai/sdk";
+import type {
+  MessageParam,
+  ToolResultBlockParam,
+  ToolUseBlock,
+} from "@anthropic-ai/sdk/resources/messages";
+import type { BotholomewConfig } from "../config/schemas.ts";
+import type { DbConnection } from "../db/connection.ts";
+import type { Task } from "../db/tasks.ts";
+import { logInteraction } from "../db/threads.ts";
+import { registerAllTools } from "../tools/registry.ts";
+import { getTool, type ToolContext, toAnthropicTools } from "../tools/tool.ts";
+
+registerAllTools();
+
+export interface AgentLoopResult {
+  status: "complete" | "failed" | "waiting";
+  reason?: string;
+}
+
+const STATUS_MAP: Record<string, AgentLoopResult["status"]> = {
+  complete_task: "complete",
+  fail_task: "failed",
+  wait_task: "waiting",
+};
+
+export async function runAgentLoop(input: {
+  systemPrompt: string;
+  task: Task;
+  config: Required<BotholomewConfig>;
+  conn: DbConnection;
+  threadId: string;
+  projectDir: string;
+}): Promise<AgentLoopResult> {
+  const { systemPrompt, task, config, conn, threadId, projectDir } = input;
+
+  const client = new Anthropic({
+    apiKey: config.anthropic_api_key || undefined,
+  });
+
+  const toolCtx: ToolContext = { conn, projectDir, config };
+
+  const userMessage = `Please work on this task:\n\nName: ${task.name}\nDescription: ${task.description}\nPriority: ${task.priority}\n\nUse the available tools to complete this task, then call complete_task, fail_task, or wait_task to indicate the outcome.`;
+
+  const messages: MessageParam[] = [{ role: "user", content: userMessage }];
+
+  // Log the initial user message
+  await logInteraction(conn, threadId, {
+    role: "user",
+    kind: "message",
+    content: userMessage,
+  });
+
+  const daemonTools = toAnthropicTools();
+
+  const maxTurns = 10;
+  for (let turn = 0; turn < maxTurns; turn++) {
+    const startTime = Date.now();
+    const response = await client.messages.create({
+      model: config.model,
+      max_tokens: 4096,
+      system: systemPrompt,
+      messages,
+      tools: daemonTools,
+    });
+    const durationMs = Date.now() - startTime;
+    const tokenCount =
+      response.usage.input_tokens + response.usage.output_tokens;
+
+    // Log assistant text blocks
+    for (const block of response.content) {
+      if (block.type === "text" && block.text) {
+        await logInteraction(conn, threadId, {
+          role: "assistant",
+          kind: "message",
+          content: block.text,
+          durationMs,
+          tokenCount,
+        });
+      }
+    }
+
+    // Check for end turn with no tool use
+    const toolUseBlocks = response.content.filter(
+      (block): block is ToolUseBlock => block.type === "tool_use",
+    );
+
+    if (toolUseBlocks.length === 0) {
+      return {
+        status: "complete",
+        reason: "Agent completed without explicit status tool call",
+      };
+    }
+
+    // Add assistant response to conversation
+    messages.push({ role: "assistant", content: response.content });
+
+    // Process each tool call
+    const toolResults: ToolResultBlockParam[] = [];
+
+    for (const toolUse of toolUseBlocks) {
+      const toolInput = JSON.stringify(toolUse.input);
+
+      // Log tool use
+      await logInteraction(conn, threadId, {
+        role: "assistant",
+        kind: "tool_use",
+        content: `Calling ${toolUse.name}`,
+        toolName: toolUse.name,
+        toolInput,
+      });
+
+      const toolStart = Date.now();
+      const result = await executeToolCall(toolUse, toolCtx);
+      const toolDuration = Date.now() - toolStart;
+
+      // Log tool result
+      await logInteraction(conn, threadId, {
+        role: "tool",
+        kind: "tool_result",
+        content: result.output,
+        toolName: toolUse.name,
+        durationMs: toolDuration,
+      });
+
+      if (result.terminal && result.agentResult) {
+        return result.agentResult;
+      }
+
+      toolResults.push({
+        type: "tool_result",
+        tool_use_id: toolUse.id,
+        content: result.output,
+      });
+    }
+
+    messages.push({ role: "user", content: toolResults });
+  }
+
+  return { status: "failed", reason: "Max turns exceeded" };
+}
+
+interface ToolCallResult {
+  output: string;
+  terminal: boolean;
+  agentResult?: AgentLoopResult;
+}
+
+async function executeToolCall(
+  toolUse: ToolUseBlock,
+  ctx: ToolContext,
+): Promise<ToolCallResult> {
+  const tool = getTool(toolUse.name);
+  if (!tool) {
+    return { output: `Unknown tool: ${toolUse.name}`, terminal: false };
+  }
+
+  const parsed = tool.inputSchema.safeParse(toolUse.input);
+  if (!parsed.success) {
+    return {
+      output: `Invalid input: ${JSON.stringify(parsed.error)}`,
+      terminal: false,
+    };
+  }
+
+  const result = await tool.execute(parsed.data, ctx);
+  const output = typeof result === "string" ? result : JSON.stringify(result);
+
+  // Check if this is a terminal tool (complete/fail/wait)
+  if (tool.terminal) {
+    const status = STATUS_MAP[tool.name];
+    if (status) {
+      const reason =
+        (parsed.data as Record<string, unknown>).summary ??
+        (parsed.data as Record<string, unknown>).reason ??
+        "";
+      return {
+        output,
+        terminal: true,
+        agentResult: { status, reason: String(reason) },
+      };
+    }
+  }
+
+  return { output, terminal: false };
+}

package/src/daemon/prompt.ts

@@ -0,0 +1,55 @@
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { getBotholomewDir } from "../constants.ts";
+import { parseContextFile } from "../utils/frontmatter.ts";
+
+const pkg = await Bun.file(
+  new URL("../../package.json", import.meta.url),
+).json();
+
+export async function buildSystemPrompt(projectDir: string): Promise<string> {
+  const dotDir = getBotholomewDir(projectDir);
+  const parts: string[] = [];
+
+  // Meta information
+  parts.push(`# Botholomew v${pkg.version}`);
+  parts.push(`Current time: ${new Date().toISOString()}`);
+  parts.push(`Project directory: ${projectDir}`);
+  parts.push(`OS: ${process.platform} ${process.arch}`);
+  parts.push(`User: ${process.env.USER || process.env.USERNAME || "unknown"}`);
+  parts.push("");
+
+  // Load all "always" context files
+  try {
+    const files = await readdir(dotDir);
+    const mdFiles = files.filter((f) => f.endsWith(".md"));
+
+    for (const filename of mdFiles) {
+      const filePath = join(dotDir, filename);
+      const raw = await Bun.file(filePath).text();
+      const { meta, content } = parseContextFile(raw);
+
+      if (meta.loading === "always") {
+        parts.push(`## ${filename}`);
+        parts.push(content);
+        parts.push("");
+      }
+    }
+  } catch {
+    // .botholomew dir might not have md files yet
+  }
+
+  // Instructions
+  parts.push("## Instructions");
+  parts.push(
+    "You are the Botholomew daemon. You wake up periodically to work through tasks.",
+  );
+  parts.push("When given a task, use the available tools to complete it.");
+  parts.push(
+    "Always call complete_task, fail_task, or wait_task when you are done.",
+  );
+  parts.push("If you need to create subtasks, use create_task.");
+  parts.push("");
+
+  return parts.join("\n");
+}

package/src/daemon/run.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env bun
+
+// Standalone entry point for the daemon when spawned as a detached process.
+// Usage: bun run src/daemon/run.ts <projectDir>
+
+import { startDaemon } from "./index.ts";
+
+const projectDir = process.argv[2];
+if (!projectDir) {
+  console.error("Usage: bun run src/daemon/run.ts <projectDir>");
+  process.exit(1);
+}
+
+await startDaemon(projectDir);

package/src/daemon/spawn.ts

@@ -0,0 +1,38 @@
+import { join } from "node:path";
+import { getBotholomewDir, getLogPath } from "../constants.ts";
+import { logger } from "../utils/logger.ts";
+import { isProcessAlive, readPidFile } from "../utils/pid.ts";
+
+export async function spawnDaemon(projectDir: string): Promise<void> {
+  // Check if already running
+  const existingPid = await readPidFile(projectDir);
+  if (existingPid && isProcessAlive(existingPid)) {
+    logger.warn(`Daemon already running (PID ${existingPid})`);
+    return;
+  }
+
+  // Ensure .botholomew dir exists
+  const dotDir = getBotholomewDir(projectDir);
+  const dirExists = await Bun.file(join(dotDir, "config.json")).exists();
+  if (!dirExists) {
+    logger.error("Project not initialized. Run 'botholomew init' first.");
+    process.exit(1);
+  }
+
+  const logPath = getLogPath(projectDir);
+  const logFile = Bun.file(logPath);
+
+  // Find the daemon entry script
+  const daemonScript = new URL("./run.ts", import.meta.url).pathname;
+
+  const proc = Bun.spawn(["bun", "run", daemonScript, projectDir], {
+    stdio: ["ignore", logFile, logFile],
+    env: { ...process.env },
+  });
+
+  // Detach the process
+  proc.unref();
+
+  logger.success(`Daemon started in background (PID ${proc.pid})`);
+  logger.dim(`  Log: ${logPath}`);
+}

package/src/daemon/tick.ts

@@ -0,0 +1,70 @@
+import type { BotholomewConfig } from "../config/schemas.ts";
+import type { DbConnection } from "../db/connection.ts";
+import { claimNextTask, updateTaskStatus } from "../db/tasks.ts";
+import { createThread, endThread, logInteraction } from "../db/threads.ts";
+import { logger } from "../utils/logger.ts";
+import { runAgentLoop } from "./llm.ts";
+import { buildSystemPrompt } from "./prompt.ts";
+
+export async function tick(
+  projectDir: string,
+  conn: DbConnection,
+  config: Required<BotholomewConfig>,
+): Promise<void> {
+  logger.debug("Tick starting...");
+
+  // Claim a task
+  const task = await claimNextTask(conn);
+  if (!task) {
+    logger.debug("No tasks to work on. Sleeping.");
+    return;
+  }
+
+  logger.info(`Working on task: ${task.name} (${task.id})`);
+
+  // Create a thread for this tick
+  const threadId = await createThread(
+    conn,
+    "daemon_tick",
+    task.id,
+    `Working: ${task.name}`,
+  );
+
+  // Build system prompt
+  const systemPrompt = await buildSystemPrompt(projectDir);
+
+  try {
+    const result = await runAgentLoop({
+      systemPrompt,
+      task,
+      config,
+      conn,
+      threadId,
+      projectDir,
+    });
+
+    // Update task status
+    await updateTaskStatus(conn, task.id, result.status, result.reason);
+
+    // Log the status change
+    await logInteraction(conn, threadId, {
+      role: "system",
+      kind: "status_change",
+      content: `Task ${task.id} -> ${result.status}${result.reason ? `: ${result.reason}` : ""}`,
+    });
+
+    logger.info(`Task ${task.id} -> ${result.status}`);
+  } catch (err) {
+    await updateTaskStatus(conn, task.id, "failed", String(err));
+
+    await logInteraction(conn, threadId, {
+      role: "system",
+      kind: "status_change",
+      content: `Task ${task.id} failed: ${err}`,
+    });
+
+    logger.error(`Task ${task.id} failed: ${err}`);
+  } finally {
+    await endThread(conn, threadId);
+  }
+}