botholomew 0.2.0 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "botholomew",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "An AI agent for knowledge work",
   "type": "module",
   "bin": {
@@ -18,7 +18,7 @@
   "scripts": {
     "dev": "bun run src/cli.ts",
     "test": "bun test",
-    "build": "bun build --compile --minify --sourcemap ./src/cli.ts --outfile dist/botholomew",
+    "build": "bun build --compile --minify --sourcemap --external react-devtools-core ./src/cli.ts --outfile dist/botholomew",
     "lint": "tsc --noEmit && biome check ."
   },
   "dependencies": {
@@ -30,6 +30,8 @@
     "commander": "^14.0.0",
     "gray-matter": "^4.0.3",
     "ink": "^6.0.0",
+    "ink-spinner": "^5.0.0",
+    "ink-text-input": "^6.0.0",
     "istextorbinary": "^9.5.0",
     "react": "^19.1.0",
     "uuid": "^13.0.0",

package/src/chat/agent.ts

@@ -0,0 +1,216 @@
+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 { buildMetaHeader, loadPersistentContext } from "../daemon/prompt.ts";
+import type { DbConnection } from "../db/connection.ts";
+import { logInteraction } from "../db/threads.ts";
+import { registerAllTools } from "../tools/registry.ts";
+import {
+  getAllTools,
+  getTool,
+  type ToolContext,
+  toAnthropicTool,
+} from "../tools/tool.ts";
+
+registerAllTools();
+
+/** Tools available in chat mode — no daemon terminal tools, no destructive file tools */
+const CHAT_TOOL_NAMES = new Set([
+  "create_task",
+  "list_tasks",
+  "view_task",
+  "search_context",
+  "search_grep",
+  "search_semantic",
+  "list_threads",
+  "view_thread",
+  "create_schedule",
+  "list_schedules",
+  "update_beliefs",
+  "update_goals",
+  "mcp_list_tools",
+  "mcp_search",
+  "mcp_info",
+  "mcp_exec",
+]);
+
+export function getChatTools() {
+  return getAllTools()
+    .filter((t) => CHAT_TOOL_NAMES.has(t.name))
+    .map(toAnthropicTool);
+}
+
+export async function buildChatSystemPrompt(
+  projectDir: string,
+): Promise<string> {
+  const parts: string[] = [];
+
+  parts.push(...buildMetaHeader(projectDir));
+  parts.push(...(await loadPersistentContext(projectDir)));
+
+  parts.push("## Instructions");
+  parts.push(
+    "You are Botholomew's interactive chat interface. Help the user manage tasks, review results from daemon activity, search context, and answer questions.",
+  );
+  parts.push(
+    "You do NOT execute long-running work directly — enqueue tasks for the daemon instead using create_task.",
+  );
+  parts.push(
+    "Use the available tools to look up tasks, threads, schedules, and context when the user asks about them.",
+  );
+  parts.push(
+    "You can update the agent's beliefs and goals files when the user asks you to.",
+  );
+  parts.push(
+    "Format your responses using Markdown. Use headings, bold, italic, lists, and code blocks to make your responses clear and well-structured.",
+  );
+  parts.push("");
+
+  return parts.join("\n");
+}
+
+export interface ChatTurnCallbacks {
+  onToken: (text: string) => void;
+  onToolStart: (name: string, input: string) => void;
+  onToolEnd: (name: string, output: string) => void;
+}
+
+/**
+ * Run a single chat turn: stream the assistant response, execute any tool calls,
+ * and loop until the model produces end_turn with no tool calls.
+ * Mutates `messages` in-place by appending assistant/tool messages.
+ */
+export async function runChatTurn(input: {
+  messages: MessageParam[];
+  systemPrompt: string;
+  config: Required<BotholomewConfig>;
+  conn: DbConnection;
+  threadId: string;
+  toolCtx: ToolContext;
+  callbacks: ChatTurnCallbacks;
+}): Promise<void> {
+  const { messages, systemPrompt, config, conn, threadId, toolCtx, callbacks } =
+    input;
+
+  const client = new Anthropic({
+    apiKey: config.anthropic_api_key || undefined,
+  });
+
+  const chatTools = getChatTools();
+  const maxTurns = 10;
+
+  for (let turn = 0; turn < maxTurns; turn++) {
+    const startTime = Date.now();
+
+    const stream = client.messages.stream({
+      model: config.model,
+      max_tokens: 4096,
+      system: systemPrompt,
+      messages,
+      tools: chatTools,
+    });
+
+    // Collect the full response
+    let assistantText = "";
+
+    stream.on("text", (text) => {
+      assistantText += text;
+      callbacks.onToken(text);
+    });
+
+    const response = await stream.finalMessage();
+    const durationMs = Date.now() - startTime;
+    const tokenCount =
+      response.usage.input_tokens + response.usage.output_tokens;
+
+    // Log assistant text
+    if (assistantText) {
+      await logInteraction(conn, threadId, {
+        role: "assistant",
+        kind: "message",
+        content: assistantText,
+        durationMs,
+        tokenCount,
+      });
+    }
+
+    // Check for tool calls
+    const toolUseBlocks = response.content.filter(
+      (block): block is ToolUseBlock => block.type === "tool_use",
+    );
+
+    if (toolUseBlocks.length === 0) {
+      // No tool calls — turn is complete
+      messages.push({ role: "assistant", content: response.content });
+      return;
+    }
+
+    // Add assistant response to conversation
+    messages.push({ role: "assistant", content: response.content });
+
+    // Execute tool calls
+    const toolResults: ToolResultBlockParam[] = [];
+
+    for (const toolUse of toolUseBlocks) {
+      const toolInput = JSON.stringify(toolUse.input);
+      callbacks.onToolStart(toolUse.name, toolInput);
+
+      await logInteraction(conn, threadId, {
+        role: "assistant",
+        kind: "tool_use",
+        content: `Calling ${toolUse.name}`,
+        toolName: toolUse.name,
+        toolInput,
+      });
+
+      const toolStart = Date.now();
+      const result = await executeChatToolCall(toolUse, toolCtx);
+      const toolDuration = Date.now() - toolStart;
+
+      await logInteraction(conn, threadId, {
+        role: "tool",
+        kind: "tool_result",
+        content: result,
+        toolName: toolUse.name,
+        durationMs: toolDuration,
+      });
+
+      callbacks.onToolEnd(toolUse.name, result);
+
+      toolResults.push({
+        type: "tool_result",
+        tool_use_id: toolUse.id,
+        content: result,
+      });
+    }
+
+    messages.push({ role: "user", content: toolResults });
+    // Loop to get the model's next response after tool results
+  }
+}
+
+async function executeChatToolCall(
+  toolUse: ToolUseBlock,
+  ctx: ToolContext,
+): Promise<string> {
+  const tool = getTool(toolUse.name);
+  if (!tool) return `Unknown tool: ${toolUse.name}`;
+  if (!CHAT_TOOL_NAMES.has(tool.name))
+    return `Tool not available in chat mode: ${tool.name}`;
+
+  const parsed = tool.inputSchema.safeParse(toolUse.input);
+  if (!parsed.success) {
+    return `Invalid input: ${JSON.stringify(parsed.error)}`;
+  }
+
+  try {
+    const result = await tool.execute(parsed.data, ctx);
+    return typeof result === "string" ? result : JSON.stringify(result);
+  } catch (err) {
+    return `Tool error: ${err}`;
+  }
+}

package/src/chat/session.ts

@@ -0,0 +1,136 @@
+import type { MessageParam } from "@anthropic-ai/sdk/resources/messages";
+import { loadConfig } from "../config/loader.ts";
+import type { BotholomewConfig } from "../config/schemas.ts";
+import { getDbPath } from "../constants.ts";
+import type { DbConnection } from "../db/connection.ts";
+import { getConnection } from "../db/connection.ts";
+import { migrate } from "../db/schema.ts";
+import {
+  createThread,
+  endThread,
+  getThread,
+  logInteraction,
+  reopenThread,
+} from "../db/threads.ts";
+import { createMcpxClient } from "../mcpx/client.ts";
+import type { ToolContext } from "../tools/tool.ts";
+import {
+  buildChatSystemPrompt,
+  type ChatTurnCallbacks,
+  runChatTurn,
+} from "./agent.ts";
+
+export interface ChatSession {
+  conn: DbConnection;
+  threadId: string;
+  projectDir: string;
+  config: Required<BotholomewConfig>;
+  messages: MessageParam[];
+  systemPrompt: string;
+  toolCtx: ToolContext;
+  cleanup: () => Promise<void>;
+}
+
+export async function startChatSession(
+  projectDir: string,
+  existingThreadId?: string,
+): Promise<ChatSession> {
+  const config = await loadConfig(projectDir);
+
+  if (!config.anthropic_api_key) {
+    throw new Error(
+      "no API key found. add anthropic_api_key to .botholomew/config.json",
+    );
+  }
+
+  const conn = getConnection(getDbPath(projectDir));
+  migrate(conn);
+
+  let threadId: string;
+  const messages: MessageParam[] = [];
+
+  if (existingThreadId) {
+    // Resume existing thread
+    const result = await getThread(conn, existingThreadId);
+    if (!result) {
+      conn.close();
+      throw new Error(`Thread not found: ${existingThreadId}`);
+    }
+    threadId = existingThreadId;
+    await reopenThread(conn, threadId);
+
+    // Rebuild message history from interactions
+    for (const interaction of result.interactions) {
+      if (interaction.kind !== "message") continue;
+      if (interaction.role === "user") {
+        messages.push({ role: "user", content: interaction.content });
+      } else if (interaction.role === "assistant") {
+        messages.push({ role: "assistant", content: interaction.content });
+      }
+    }
+  } else {
+    threadId = await createThread(
+      conn,
+      "chat_session",
+      undefined,
+      "Interactive chat",
+    );
+  }
+
+  const systemPrompt = await buildChatSystemPrompt(projectDir);
+
+  const mcpxClient = await createMcpxClient(projectDir);
+
+  const toolCtx: ToolContext = {
+    conn,
+    projectDir,
+    config,
+    mcpxClient,
+  };
+
+  const cleanup = async () => {
+    await mcpxClient?.close();
+  };
+
+  return {
+    conn,
+    threadId,
+    projectDir,
+    config,
+    messages,
+    systemPrompt,
+    toolCtx,
+    cleanup,
+  };
+}
+
+export async function sendMessage(
+  session: ChatSession,
+  userMessage: string,
+  callbacks: ChatTurnCallbacks,
+): Promise<void> {
+  // Log and append user message
+  await logInteraction(session.conn, session.threadId, {
+    role: "user",
+    kind: "message",
+    content: userMessage,
+  });
+
+  session.messages.push({ role: "user", content: userMessage });
+
+  await runChatTurn({
+    messages: session.messages,
+    systemPrompt: session.systemPrompt,
+    config: session.config,
+    conn: session.conn,
+    threadId: session.threadId,
+    toolCtx: session.toolCtx,
+    callbacks,
+  });
+}
+
+export async function endChatSession(session: ChatSession): Promise<void> {
+  await endThread(session.conn, session.threadId);
+  await session.cleanup();
+  session.conn.close();
+}

package/src/commands/chat.ts

@@ -1,11 +1,37 @@
 import type { Command } from "commander";
-import { logger } from "../utils/logger.ts";
 
 export function registerChatCommand(program: Command) {
   program
     .command("chat")
-    .description("Open the interactive chat TUI")
-    .action(async () => {
-      logger.warn("Chat TUI not yet implemented. Coming soon.");
+    .description(
+      "Open the interactive chat TUI\n\n" +
+        "  Keyboard shortcuts:\n" +
+        "    Enter          Send message\n" +
+        "    ⌥+Enter        Insert newline (multiline input)\n" +
+        "    ↑/↓            Browse input history\n\n" +
+        "  Commands:\n" +
+        "    /help           Show keyboard shortcuts\n" +
+        "    /tools          Open tool call inspector\n" +
+        "    /quit, /exit    End the chat session",
+    )
+    .option("--thread-id <id>", "Resume an existing chat thread")
+    .action(async (opts: { threadId?: string }) => {
+      const { render } = await import("ink");
+      const React = await import("react");
+      const { App } = await import("../tui/App.tsx");
+      const dir = program.opts().dir;
+      const instance = render(
+        React.createElement(App, {
+          projectDir: dir,
+          threadId: opts.threadId,
+        }),
+        {
+          kittyKeyboard: {
+            mode: "enabled",
+            flags: ["disambiguateEscapeCodes", "reportEventTypes"],
+          },
+        },
+      );
+      await instance.waitUntilExit();
     });
 }

package/src/commands/context.ts

@@ -16,6 +16,11 @@ import { hybridSearch, initVectorSearch } from "../db/embeddings.ts";
 import { logger } from "../utils/logger.ts";
 import { withDb } from "./with-db.ts";
 
+function fmtDate(d: Date): string {
+  const pad = (n: number) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
+}
+
 export function registerContextCommand(program: Command) {
   const ctx = program.command("context").description("Manage context items");
 
@@ -38,7 +43,7 @@ export function registerContextCommand(program: Command) {
           return;
         }
 
-        const header = `${ansis.bold("Path".padEnd(40))} ${"Title".padEnd(25)} ${"Type".padEnd(20)} Indexed`;
+        const header = `${ansis.bold("Path".padEnd(40))} ${"Title".padEnd(25)} ${"Type".padEnd(20)} ${"Updated".padEnd(18)} Indexed`;
         console.log(header);
         console.log("-".repeat(header.length));
 
@@ -46,8 +51,9 @@ export function registerContextCommand(program: Command) {
           const indexed = item.indexed_at
             ? ansis.green("yes")
             : ansis.dim("no");
+          const updated = ansis.dim(fmtDate(item.updated_at).padEnd(18));
           console.log(
-            `${item.context_path.padEnd(40)} ${item.title.slice(0, 24).padEnd(25)} ${item.mime_type.slice(0, 19).padEnd(20)} ${indexed}`,
+            `${item.context_path.padEnd(40)} ${item.title.slice(0, 24).padEnd(25)} ${item.mime_type.slice(0, 19).padEnd(20)} ${updated} ${indexed}`,
           );
         }
 
@@ -56,38 +62,45 @@ export function registerContextCommand(program: Command) {
     );
 
   ctx
-    .command("add <path>")
-    .description("Add a file or directory to context")
+    .command("add <paths...>")
+    .description("Add files or directories to context")
     .option("--prefix <prefix>", "virtual path prefix", "/")
-    .action((path, opts) =>
+    .action((paths: string[], opts) =>
       withDb(program, async (conn, dir) => {
         const config = await loadConfig(dir);
         await warmupEmbedder();
 
-        const resolvedPath = resolve(path);
-        const info = await stat(resolvedPath);
-
         let added = 0;
         let chunks = 0;
 
-        if (info.isDirectory()) {
-          const entries = await walkDirectory(resolvedPath);
-          for (const filePath of entries) {
-            const relativePath = filePath.slice(resolvedPath.length);
-            const contextPath = join(opts.prefix, relativePath);
-            const count = await addFile(conn, config, filePath, contextPath);
+        for (const path of paths) {
+          const resolvedPath = resolve(path);
+          const info = await stat(resolvedPath);
+
+          if (info.isDirectory()) {
+            const entries = await walkDirectory(resolvedPath);
+            for (const filePath of entries) {
+              const relativePath = filePath.slice(resolvedPath.length);
+              const contextPath = join(opts.prefix, relativePath);
+              const count = await addFile(conn, config, filePath, contextPath);
+              if (count >= 0) {
+                added++;
+                chunks += count;
+              }
+            }
+          } else {
+            const contextPath = join(opts.prefix, basename(resolvedPath));
+            const count = await addFile(
+              conn,
+              config,
+              resolvedPath,
+              contextPath,
+            );
             if (count >= 0) {
               added++;
               chunks += count;
             }
           }
-        } else {
-          const contextPath = join(opts.prefix, basename(resolvedPath));
-          const count = await addFile(conn, config, resolvedPath, contextPath);
-          if (count >= 0) {
-            added++;
-            chunks += count;
-          }
         }
 
         logger.success(`Added ${added} file(s), ${chunks} chunk(s) indexed.`);
@@ -115,7 +128,9 @@ export function registerContextCommand(program: Command) {
           console.log(
             `${ansis.bold(`${i + 1}.`)} ${ansis.cyan(r.title)} ${ansis.dim(`(${score}%)`)}`,
           );
-          console.log(`   ${ansis.dim(r.source_path || r.context_item_id)}`);
+          console.log(
+            `   ${ansis.dim(r.source_path || r.context_item_id)}  ${ansis.dim(fmtDate(r.created_at))}`,
+          );
           if (r.chunk_content) {
             const snippet = r.chunk_content.slice(0, 120).replace(/\n/g, " ");
             console.log(`   ${snippet}...`);

package/src/daemon/prompt.ts

@@ -13,35 +13,18 @@ const pkg = await Bun.file(
   new URL("../../package.json", import.meta.url),
 ).json();
 
-export async function buildSystemPrompt(
+/**
+ * Load persistent context files from .botholomew/ directory.
+ * Returns an array of formatted string sections for "always" loaded files.
+ * If taskKeywords are provided, also includes "contextual" files that match.
+ */
+export async function loadPersistentContext(
   projectDir: string,
-  task?: Task,
-  conn?: DbConnection,
-  _config?: Required<BotholomewConfig>,
-  options?: { hasMcpTools?: boolean },
-): Promise<string> {
+  taskKeywords?: Set<string> | null,
+): 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("");
-
-  // Build keyword set from task for contextual loading
-  const taskKeywords = task
-    ? new Set(
-        `${task.name} ${task.description}`
-          .toLowerCase()
-          .split(/\s+/)
-          .filter((w) => w.length > 3),
-      )
-    : null;
-
-  // Load context files from .botholomew/
   try {
     const files = await readdir(dotDir);
     const mdFiles = files.filter((f) => f.endsWith(".md"));
@@ -56,7 +39,6 @@ export async function buildSystemPrompt(
         parts.push(content);
         parts.push("");
       } else if (meta.loading === "contextual" && taskKeywords) {
-        // Include contextual files if keywords overlap with task
         const contentLower = content.toLowerCase();
         const hasOverlap = [...taskKeywords].some((kw) =>
           contentLower.includes(kw),
@@ -72,6 +54,48 @@ export async function buildSystemPrompt(
     // .botholomew dir might not have md files yet
   }
 
+  return parts;
+}
+
+/**
+ * Build common meta header (version, time, OS, user).
+ */
+export function buildMetaHeader(projectDir: string): string[] {
+  return [
+    `# Botholomew v${pkg.version}`,
+    `Current time: ${new Date().toISOString()}`,
+    `Project directory: ${projectDir}`,
+    `OS: ${process.platform} ${process.arch}`,
+    `User: ${process.env.USER || process.env.USERNAME || "unknown"}`,
+    "",
+  ];
+}
+
+export async function buildSystemPrompt(
+  projectDir: string,
+  task?: Task,
+  conn?: DbConnection,
+  _config?: Required<BotholomewConfig>,
+  options?: { hasMcpTools?: boolean },
+): Promise<string> {
+  const parts: string[] = [];
+
+  // Meta information
+  parts.push(...buildMetaHeader(projectDir));
+
+  // Build keyword set from task for contextual loading
+  const taskKeywords = task
+    ? new Set(
+        `${task.name} ${task.description}`
+          .toLowerCase()
+          .split(/\s+/)
+          .filter((w) => w.length > 3),
+      )
+    : null;
+
+  // Load context files from .botholomew/
+  parts.push(...(await loadPersistentContext(projectDir, taskKeywords)));
+
   // Relevant context from embeddings search
   if (task && conn) {
     try {

package/src/db/threads.ts

@@ -147,6 +147,13 @@ export async function endThread(
   );
 }
 
+export async function reopenThread(
+  db: DbConnection,
+  threadId: string,
+): Promise<void> {
+  db.query("UPDATE threads SET ended_at = NULL WHERE id = ?1").run(threadId);
+}
+
 export async function getThread(
   db: DbConnection,
   threadId: string,

package/src/init/index.ts

@@ -36,7 +36,7 @@ export async function initProject(
   await Bun.write(join(dotDir, "beliefs.md"), BELIEFS_MD);
   await Bun.write(join(dotDir, "goals.md"), GOALS_MD);
 
-  // Write config (without API key)
+  // Write config (with placeholder API key)
   await Bun.write(
     join(dotDir, "config.json"),
     `${JSON.stringify(DEFAULT_CONFIG, null, 2)}\n`,

package/src/init/templates.ts

@@ -38,7 +38,8 @@ agent-modification: true
 `;
 
 export const DEFAULT_CONFIG = {
-  model: "claude-sonnet-4-20250514",
+  anthropic_api_key: "your-api-key-here",
+  model: "claude-opus-4-20250514",
   tick_interval_seconds: 300,
   max_tick_duration_seconds: 120,
 };