botholomew 0.1.1 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "botholomew",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "An AI agent for knowledge work",
   "type": "module",
   "bin": {
@@ -18,15 +18,20 @@
   "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": {
     "@anthropic-ai/sdk": "^0.88.0",
+    "@evantahler/mcpx": "0.18.3",
+    "@huggingface/transformers": "^4.0.1",
+    "@sqliteai/sqlite-vector": "^0.9.95",
     "ansis": "^4.2.0",
     "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/cli.ts

@@ -8,6 +8,8 @@ import { registerContextCommand } from "./commands/context.ts";
 import { registerDaemonCommand } from "./commands/daemon.ts";
 import { registerInitCommand } from "./commands/init.ts";
 import { registerMcpxCommand } from "./commands/mcpx.ts";
+import { registerPrepareCommand } from "./commands/prepare.ts";
+import { registerScheduleCommand } from "./commands/schedule.ts";
 import { registerTaskCommand } from "./commands/task.ts";
 import { registerToolCommands } from "./commands/tools.ts";
 import { registerUpgradeCommand } from "./commands/upgrade.ts";
@@ -31,10 +33,12 @@ program
 registerInitCommand(program);
 registerDaemonCommand(program);
 registerTaskCommand(program);
+registerScheduleCommand(program);
 registerChatCommand(program);
 registerContextCommand(program);
 registerMcpxCommand(program);
 registerToolCommands(program);
+registerPrepareCommand(program);
 registerCheckUpdateCommand(program);
 registerUpgradeCommand(program);
 

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

@@ -1,5 +1,25 @@
+import { readdir, stat } from "node:fs/promises";
+import { basename, join, resolve } from "node:path";
+import ansis from "ansis";
 import type { Command } from "commander";
+import { isText } from "istextorbinary";
+import { loadConfig } from "../config/loader.ts";
+import { embedSingle, warmupEmbedder } from "../context/embedder.ts";
+import { ingestContextItem } from "../context/ingest.ts";
+import type { DbConnection } from "../db/connection.ts";
+import {
+  createContextItem,
+  listContextItems,
+  listContextItemsByPrefix,
+} from "../db/context.ts";
+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");
@@ -7,21 +27,170 @@ export function registerContextCommand(program: Command) {
   ctx
     .command("list")
     .description("List context items")
-    .action(async () => {
-      logger.warn("Not yet implemented. Coming soon.");
-    });
+    .option("--path <prefix>", "filter by path prefix")
+    .option("-l, --limit <n>", "max number of items", Number.parseInt)
+    .action((opts) =>
+      withDb(program, async (conn) => {
+        const items = opts.path
+          ? await listContextItemsByPrefix(conn, opts.path, {
+              recursive: true,
+              limit: opts.limit,
+            })
+          : await listContextItems(conn, { limit: opts.limit });
+
+        if (items.length === 0) {
+          logger.dim("No context items found.");
+          return;
+        }
+
+        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));
+
+        for (const item of items) {
+          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)} ${updated} ${indexed}`,
+          );
+        }
+
+        console.log(`\n${ansis.dim(`${items.length} item(s)`)}`);
+      }),
+    );
 
   ctx
-    .command("add <path>")
-    .description("Add a file or directory to context")
-    .action(async () => {
-      logger.warn("Not yet implemented. Coming soon.");
-    });
+    .command("add <paths...>")
+    .description("Add files or directories to context")
+    .option("--prefix <prefix>", "virtual path prefix", "/")
+    .action((paths: string[], opts) =>
+      withDb(program, async (conn, dir) => {
+        const config = await loadConfig(dir);
+        await warmupEmbedder();
+
+        let added = 0;
+        let chunks = 0;
+
+        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;
+            }
+          }
+        }
+
+        logger.success(`Added ${added} file(s), ${chunks} chunk(s) indexed.`);
+      }),
+    );
 
   ctx
     .command("search <query>")
     .description("Search context items")
-    .action(async () => {
-      logger.warn("Not yet implemented. Coming soon.");
+    .option("-k, --top-k <n>", "max results", Number.parseInt, 10)
+    .action((query, opts) =>
+      withDb(program, async (conn) => {
+        await warmupEmbedder();
+        initVectorSearch(conn);
+        const queryVec = await embedSingle(query);
+        const results = hybridSearch(conn, query, queryVec, opts.topK);
+
+        if (results.length === 0) {
+          logger.dim("No results found.");
+          return;
+        }
+
+        for (const [i, r] of results.entries()) {
+          const score = (r.score * 100).toFixed(1);
+          console.log(
+            `${ansis.bold(`${i + 1}.`)} ${ansis.cyan(r.title)} ${ansis.dim(`(${score}%)`)}`,
+          );
+          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}...`);
+          }
+          console.log("");
+        }
+      }),
+    );
+}
+
+async function addFile(
+  conn: DbConnection,
+  config: Awaited<ReturnType<typeof loadConfig>>,
+  filePath: string,
+  contextPath: string,
+): Promise<number> {
+  try {
+    const bunFile = Bun.file(filePath);
+    const mimeType = bunFile.type.split(";")[0] || "application/octet-stream";
+    const filename = basename(filePath);
+    const textual = isText(filename) !== false;
+
+    const content = textual ? await bunFile.text() : null;
+
+    const item = await createContextItem(conn, {
+      title: filename,
+      content: content ?? undefined,
+      mimeType,
+      sourcePath: filePath,
+      contextPath,
+      isTextual: textual,
     });
+
+    if (textual && content) {
+      const count = await ingestContextItem(conn, item.id, config);
+      console.log(`  + ${contextPath} (${count} chunks)`);
+      return count;
+    }
+
+    console.log(`  + ${contextPath} (binary, not indexed)`);
+    return 0;
+  } catch (err) {
+    logger.warn(`  ! ${contextPath}: ${err}`);
+    return -1;
+  }
+}
+
+async function walkDirectory(dirPath: string): Promise<string[]> {
+  const files: string[] = [];
+  const entries = await readdir(dirPath, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name.startsWith(".")) continue; // skip hidden dirs
+      files.push(...(await walkDirectory(fullPath)));
+    } else if (entry.isFile()) {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
 }