botholomew 0.18.6 → 0.19.3

package/src/prompts/capabilities.ts

@@ -1,8 +1,15 @@
 import { join } from "node:path";
-import Anthropic from "@anthropic-ai/sdk";
 import type { McpxClient } from "@evantahler/mcpx";
+import { generateObject } from "ai";
+import { z } from "zod";
 import type { BotholomewConfig } from "../config/schemas.ts";
 import { getPromptsDir } from "../constants.ts";
+import {
+  buildProviderOptions,
+  formatLlmError,
+  getLanguageModel,
+  getMaxInputTokens,
+} from "../llm/index.ts";
 import { getAllTools, type ToolDefinition } from "../tools/tool.ts";
 import {
   type ContextFileMeta,
@@ -14,7 +21,6 @@ import { logger } from "../utils/logger.ts";
 export const CAPABILITIES_FILENAME = "capabilities.md";
 
 // LLM config — summarization is one call per refresh, no streaming needed.
-const SUMMARIZE_TIMEOUT_MS = 30_000;
 const SUMMARIZE_MAX_TOKENS = 4096;
 
 // biome-ignore lint/suspicious/noExplicitAny: Zod-free tool schema for Anthropic SDK
@@ -142,71 +148,34 @@ interface SummarizedCapabilities {
   mcpx_servers: ServerThemes[];
 }
 
-const SUMMARIZE_TOOL_NAME = "return_capability_summary";
-const SUMMARIZE_TOOL = {
-  name: SUMMARIZE_TOOL_NAME,
-  description:
-    "Return thematic capability summaries for the agent's tool inventory.",
-  input_schema: {
-    type: "object" as const,
-    properties: {
-      internal_themes: {
-        type: "array",
-        description:
-          "Themes covering the agent's built-in tools (task queue, files & sandbox, search, threads, MCPX meta-tools, workers, self-reflection, etc.).",
-        items: {
-          type: "object",
-          properties: {
-            name: {
-              type: "string",
-              description: "Short theme name (2-4 words).",
-            },
-            summary: {
-              type: "string",
-              description:
-                "One sentence with concrete action verbs. No tool names. No preamble.",
-            },
-          },
-          required: ["name", "summary"],
-        },
-      },
-      mcpx_servers: {
-        type: "array",
-        description:
-          "MCPX tools grouped by their source server. Within each server, split into themes only when the server exposes distinct services (e.g. Gmail + Google Calendar on one server).",
-        items: {
-          type: "object",
-          properties: {
-            server: {
-              type: "string",
-              description: "Server name exactly as given in the inventory.",
-            },
-            themes: {
-              type: "array",
-              items: {
-                type: "object",
-                properties: {
-                  name: {
-                    type: "string",
-                    description: "Theme name (usually the service, e.g. Gmail)",
-                  },
-                  summary: {
-                    type: "string",
-                    description:
-                      "One sentence with concrete action verbs. No tool names.",
-                  },
-                },
-                required: ["name", "summary"],
-              },
-            },
-          },
-          required: ["server", "themes"],
-        },
-      },
-    },
-    required: ["internal_themes", "mcpx_servers"],
-  },
-};
+const ThemeSchema = z.object({
+  name: z.string().describe("Short theme name (2-4 words)."),
+  summary: z
+    .string()
+    .describe(
+      "One sentence with concrete action verbs. No tool names. No preamble.",
+    ),
+});
+
+const SummarySchema = z.object({
+  internal_themes: z
+    .array(ThemeSchema)
+    .describe(
+      "Themes covering the agent's built-in tools (task queue, files & sandbox, search, threads, MCPX meta-tools, workers, self-reflection, etc.).",
+    ),
+  mcpx_servers: z
+    .array(
+      z.object({
+        server: z
+          .string()
+          .describe("Server name exactly as given in the inventory."),
+        themes: z.array(ThemeSchema),
+      }),
+    )
+    .describe(
+      "MCPX tools grouped by their source server. Within each server, split into themes only when the server exposes distinct services.",
+    ),
+});
 
 function renderInventoryForPrompt(inv: RawInventory): string {
   const sections: string[] = [];
@@ -255,42 +224,42 @@ BAD examples (do not produce):
   "Provides access to Gmail operations via tools like Gmail_SendEmail..."
   "Tools for working with email"`;
 
+function hasUsableCreds(config: BotholomewConfig): boolean {
+  const cfg = config.chunker_llm;
+  if (cfg.provider === "anthropic") {
+    return !!cfg.api_key && cfg.api_key !== "your-api-key-here";
+  }
+  if (cfg.provider === "openai-compatible") {
+    return !!cfg.base_url;
+  }
+  // ollama: no credentials required, assume reachable.
+  return true;
+}
+
 async function summarizeViaLLM(
   inv: RawInventory,
-  config: Required<BotholomewConfig>,
+  config: BotholomewConfig,
 ): Promise<SummarizedCapabilities | null> {
-  if (
-    !config.anthropic_api_key ||
-    config.anthropic_api_key === "your-api-key-here"
-  ) {
-    return null;
-  }
+  if (!hasUsableCreds(config)) return null;
 
-  const client = new Anthropic({ apiKey: config.anthropic_api_key });
-  const userPrompt = `Summarize this tool inventory. Return via the \`${SUMMARIZE_TOOL_NAME}\` tool.\n\n${renderInventoryForPrompt(inv)}`;
+  const userPrompt = `Summarize this tool inventory.\n\n${renderInventoryForPrompt(inv)}`;
 
   try {
-    const response = await client.messages.create(
-      {
-        model: config.chunker_model,
-        max_tokens: SUMMARIZE_MAX_TOKENS,
-        system: SUMMARIZE_SYSTEM,
-        tools: [SUMMARIZE_TOOL],
-        tool_choice: { type: "tool", name: SUMMARIZE_TOOL_NAME },
-        messages: [{ role: "user", content: userPrompt }],
-      },
-      { timeout: SUMMARIZE_TIMEOUT_MS },
-    );
-
-    const toolBlock = response.content.find((b) => b.type === "tool_use");
-    if (!toolBlock || toolBlock.type !== "tool_use") return null;
-
-    const input = toolBlock.input as SummarizedCapabilities;
-    if (!Array.isArray(input.internal_themes)) return null;
-    if (!Array.isArray(input.mcpx_servers)) return null;
-    return input;
+    const model = getLanguageModel(config.chunker_llm);
+    const numCtx = await getMaxInputTokens(config.chunker_llm);
+    const { object } = await generateObject({
+      model,
+      schema: SummarySchema,
+      system: SUMMARIZE_SYSTEM,
+      prompt: userPrompt,
+      maxOutputTokens: SUMMARIZE_MAX_TOKENS,
+      providerOptions: buildProviderOptions(config.chunker_llm, numCtx),
+    });
+    return object;
   } catch (err) {
-    logger.debug(`Capability summarization failed: ${(err as Error).message}`);
+    logger.debug(
+      `Capability summarization failed: ${formatLlmError(err, config.chunker_llm)}`,
+    );
     return null;
   }
 }
@@ -404,7 +373,7 @@ function renderFallback(inv: RawInventory, now: Date): string {
     );
   } else {
     parts.push(
-      "_(LLM summarization unavailable — set `anthropic_api_key` and rerun to generate themed summaries. Until then, use `mcp_list_tools` with each server to see what's exposed.)_",
+      "_(LLM summarization unavailable — set `llm.api_key` (or `llm.base_url` for local providers) and rerun to generate themed summaries. Until then, use `mcp_list_tools` with each server to see what's exposed.)_",
     );
     parts.push("");
     const servers = [...inv.mcpByServer.keys()].sort();
@@ -418,29 +387,24 @@ function renderFallback(inv: RawInventory, now: Date): string {
 }
 
 /**
- * Build the body of capabilities.md. When `config.anthropic_api_key` is set,
- * Claude is asked to produce thematic summaries. Otherwise (or on failure) a
- * static fallback listing is rendered.
+ * Build the body of capabilities.md. When the configured chunker LLM has
+ * usable credentials, the model is asked to produce thematic summaries.
+ * Otherwise (or on failure) a static fallback listing is rendered.
  */
 export async function generateCapabilitiesMarkdown(
   mcpxClient: McpxClient | null,
-  config: Required<BotholomewConfig>,
+  config: BotholomewConfig,
   now: Date = new Date(),
   onPhase?: ProgressCallback,
 ): Promise<GenerateResult> {
   const inv = await collectInventory(mcpxClient, onPhase);
 
-  // Don't call the LLM when the inventory is empty / broken — the fallback
-  // conveys the same information and avoids an unnecessary API round trip.
   const hasAnythingToSummarize =
     inv.mcpByServer.size > 0 || inv.internalTotal > 0;
 
   let summary: SummarizedCapabilities | null = null;
   if (hasAnythingToSummarize) {
-    const canSummarize =
-      config.anthropic_api_key &&
-      config.anthropic_api_key !== "your-api-key-here";
-    if (canSummarize) {
+    if (hasUsableCreds(config)) {
       onPhase?.(
         `Summarizing ${inv.internalTotal} internal + ${inv.mcpTotal} MCPX tools`,
       );
@@ -472,7 +436,7 @@ export interface WriteResult {
 export async function writeCapabilitiesFile(
   projectDir: string,
   mcpxClient: McpxClient | null,
-  config: Required<BotholomewConfig>,
+  config: BotholomewConfig,
   onPhase?: ProgressCallback,
 ): Promise<WriteResult> {
   const filePath = join(getPromptsDir(projectDir), CAPABILITIES_FILENAME);

package/src/tools/membot/adapter.ts

@@ -34,13 +34,14 @@ type MembotMethodName =
   | "move"
   | "remove"
   | "refresh"
-  | "prune";
+  | "prune"
+  | "sources";
 
 /**
- * Map an Operation's exposed name (`membot_add`, `membot_delete`, …) to the
- * `MembotClient` method that actually runs it. The two diverge in a couple
- * of spots — `membot_delete` calls `client.remove`, `membot_move` calls
- * `client.move` — so we keep the routing explicit rather than guessing.
+ * Map an Operation's exposed name (`membot_add`, `membot_remove`, …) to the
+ * `MembotClient` method that actually runs it. Mostly 1:1 with the op name
+ * minus the `membot_` prefix; kept explicit so a renamed/added op fails
+ * loudly at registration instead of silently misrouting.
  */
 const METHOD_BY_OP_NAME: Record<string, MembotMethodName> = {
   membot_add: "add",
@@ -54,9 +55,10 @@ const METHOD_BY_OP_NAME: Record<string, MembotMethodName> = {
   membot_diff: "diff",
   membot_write: "write",
   membot_move: "move",
-  membot_delete: "remove",
+  membot_remove: "remove",
   membot_refresh: "refresh",
   membot_prune: "prune",
+  membot_sources: "sources",
 };
 
 /**

package/src/tools/membot/edit.ts

@@ -32,7 +32,7 @@ const outputSchema = z.object({
 export const membotEditTool = {
   name: "membot_edit",
   description:
-    "[[ bash equivalent command: patch ]] Apply line-range edits to a stored file: reads the current version, applies bottom-up patches, and writes the result back as a new version. Prefer this over membot_write when you only need to change part of a file — the diff is small and the change_note travels with the new version. To replace the whole body, use membot_write. To delete the file, use membot_delete.",
+    "[[ bash equivalent command: patch ]] Apply line-range edits to a stored file: reads the current version, applies bottom-up patches, and writes the result back as a new version. Prefer this over membot_write when you only need to change part of a file — the diff is small and the change_note travels with the new version. To replace the whole body, use membot_write. To delete the file, use membot_remove.",
   group: "membot",
   inputSchema,
   outputSchema,

package/src/tools/tool.ts

@@ -1,6 +1,5 @@
-import type { Tool as AnthropicTool } from "@anthropic-ai/sdk/resources/messages";
 import type { McpxClient } from "@evantahler/mcpx";
-import { z } from "zod";
+import type { z } from "zod";
 import type { BotholomewConfig } from "../config/schemas.ts";
 import type { WithMem } from "../mem/client.ts";
 
@@ -14,7 +13,7 @@ export interface ToolContext {
    */
   withMem: WithMem;
   projectDir: string;
-  config: Required<BotholomewConfig>;
+  config: BotholomewConfig;
   mcpxClient: McpxClient | null;
   /**
    * Identifier of the agent process running this tool, used as the holder
@@ -84,22 +83,3 @@ export function getAllTools(): AnyToolDefinition[] {
 export function getToolsByGroup(group: string): AnyToolDefinition[] {
   return getAllTools().filter((t) => t.group === group);
 }
-
-// --- Anthropic adapter ---
-
-export function toAnthropicTool(tool: AnyToolDefinition): AnthropicTool {
-  const jsonSchema = z.toJSONSchema(tool.inputSchema);
-  return {
-    name: tool.name,
-    description: tool.description,
-    input_schema: {
-      type: "object" as const,
-      properties: jsonSchema.properties ?? {},
-      required: jsonSchema.required as string[] | undefined,
-    },
-  };
-}
-
-export function toAnthropicTools(): AnthropicTool[] {
-  return getAllTools().map(toAnthropicTool);
-}

package/src/tui/components/ContextPanel.tsx

@@ -240,7 +240,7 @@ export const ContextPanel = memo(function ContextPanel({
         ? `🔍 match (score=${selectedRow.hit.score.toFixed(3)}, chunk #${selectedRow.hit.chunk_index})\n${selectedRow.hit.snippet}\n\n---\n\n`
         : "";
     const body = isMarkdownPath(fileContent.logical_path)
-      ? renderMarkdown(fileContent.content)
+      ? renderMarkdown(fileContent.content, detailWidth)
       : fileContent.content;
     return wrapDetailLines(snippetHeader + body, detailWidth);
   }, [selectedRow, fileContent, detailWidth]);

package/src/tui/hooks/useMessageQueue.ts

@@ -222,10 +222,11 @@ export function useMessageQueue({
         }
         finalizeSegment();
       } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
         const errorMsg: ChatMessage = {
           id: msgId(),
           role: "system",
-          content: `Error: ${err}`,
+          content: `Error: ${message}`,
           timestamp: new Date(),
         };
         setMessages((prev) => [...prev, errorMsg]);

package/src/tui/markdown.ts

@@ -1,6 +1,49 @@
-export function renderMarkdown(text: string): string {
+import { extractTableBlocks, renderTable } from "./markdownTables.ts";
+
+/**
+ * Render markdown to ANSI for a TUI detail pane. When `width` is provided,
+ * GFM tables are pulled out and rendered ourselves at that width before
+ * handing the rest off to `Bun.markdown.ansi` — Bun's renderer ignores any
+ * width hint and emits tables at their natural width, which `wrap-ansi` then
+ * shreds mid-cell.
+ */
+export function renderMarkdown(text: string, width?: number): string {
   if (!text) return "";
-  return Bun.markdown.ansi(text).trimEnd();
+  if (width === undefined || width <= 0) {
+    return Bun.markdown.ansi(text).trimEnd();
+  }
+
+  const blocks = extractTableBlocks(text);
+  if (blocks.length === 0) {
+    return Bun.markdown.ansi(text).trimEnd();
+  }
+
+  const lines = text.split("\n");
+  const rendered: string[] = blocks.map((b) =>
+    renderTable(b.rows, b.aligns, width),
+  );
+  // Bun.markdown.ansi mangles NUL bytes (→ U+FFFD), so use a plain alphanumeric
+  // sentinel that survives the markdown pass intact. Wrap each block's
+  // line-range with a single sentinel line, then splice the pre-rendered
+  // table back in after Bun finishes styling the rest of the document.
+  const sentinel = (i: number) => `BHTBLSENTINEL${i}BHTBLEND`;
+  const out = lines.slice();
+  for (let i = blocks.length - 1; i >= 0; i--) {
+    const b = blocks[i];
+    if (!b) continue;
+    out.splice(b.start, b.end - b.start + 1, sentinel(i));
+  }
+  const piped = Bun.markdown.ansi(out.join("\n")).trimEnd();
+  let stitched = piped;
+  for (let i = 0; i < blocks.length; i++) {
+    // Bun wraps each paragraph with a trailing reset (`\x1b[0m`). Strip any
+    // SGR escapes that hug the sentinel so the table doesn't inherit them.
+    const re = new RegExp(
+      `(?:\\x1b\\[[0-9;]*m)*${sentinel(i)}(?:\\x1b\\[[0-9;]*m)*`,
+    );
+    stitched = stitched.replace(re, rendered[i] ?? "");
+  }
+  return stitched;
 }
 
 export function isMarkdownPath(path: string): boolean {