botholomew 0.15.6 → 0.16.2

package/src/tui/restoreMessages.ts

@@ -0,0 +1,106 @@
+import type { Interaction } from "../threads/store.ts";
+import { MAX_INLINE_CHARS, PAGE_SIZE_CHARS } from "../worker/large-results.ts";
+import type { ChatMessage } from "./components/MessageList.tsx";
+import type { ToolCallData } from "./components/ToolCall.tsx";
+
+let nextRestoreId = 0;
+function restoreMsgId(): string {
+  return `restore-msg-${++nextRestoreId}`;
+}
+
+function detectToolError(output: string | undefined): boolean {
+  if (!output) return false;
+  try {
+    const parsed = JSON.parse(output);
+    if (typeof parsed === "object" && parsed?.is_error === true) return true;
+  } catch {
+    /* not JSON */
+  }
+  return false;
+}
+
+/**
+ * Reconstruct `ChatMessage[]` from a thread's interaction log so the TUI can
+ * hydrate chat history (plus the Tools tab) when resuming a session.
+ *
+ * Tools attach to the assistant message that *issued* them, not the next one.
+ * `runChatTurn` logs in the order: assistant text → tool_use(s) → tool_result(s)
+ * → next assistant text, so we track the most recent assistant message and
+ * append tool calls there until a user message resets the cursor.
+ */
+export function restoreMessagesFromInteractions(
+  interactions: Interaction[],
+): ChatMessage[] {
+  const result: ChatMessage[] = [];
+  let currentAssistant: ChatMessage | null = null;
+  let orphanTools: ToolCallData[] = [];
+  let restoredIdx = 0;
+
+  const makeToolCall = (ix: Interaction): ToolCallData => ({
+    id: `restored-${restoredIdx++}`,
+    name: ix.tool_name ?? "unknown",
+    input: ix.tool_input ?? "{}",
+    running: false,
+    timestamp: ix.created_at,
+  });
+
+  for (const ix of interactions) {
+    if (ix.kind === "tool_use") {
+      const tc = makeToolCall(ix);
+      if (currentAssistant) {
+        const list = currentAssistant.toolCalls ?? [];
+        list.push(tc);
+        currentAssistant.toolCalls = list;
+      } else {
+        orphanTools.push(tc);
+      }
+    } else if (ix.kind === "tool_result") {
+      const pool = currentAssistant?.toolCalls ?? orphanTools;
+      const tc = pool.find((t) => t.name === ix.tool_name && !t.output);
+      if (tc) {
+        tc.output = ix.content;
+        tc.isError = detectToolError(ix.content);
+        if (ix.content.length > MAX_INLINE_CHARS) {
+          tc.largeResult = {
+            id: "(restored)",
+            chars: ix.content.length,
+            pages: Math.ceil(ix.content.length / PAGE_SIZE_CHARS),
+          };
+        }
+      }
+    } else if (ix.kind === "message" && ix.role === "user") {
+      result.push({
+        id: restoreMsgId(),
+        role: "user",
+        content: ix.content,
+        timestamp: ix.created_at,
+      });
+      currentAssistant = null;
+    } else if (ix.kind === "message" && ix.role === "assistant") {
+      const msg: ChatMessage = {
+        id: restoreMsgId(),
+        role: "assistant",
+        content: ix.content,
+        timestamp: ix.created_at,
+      };
+      if (orphanTools.length > 0) {
+        msg.toolCalls = [...orphanTools];
+        orphanTools = [];
+      }
+      result.push(msg);
+      currentAssistant = msg;
+    }
+  }
+
+  if (orphanTools.length > 0) {
+    result.push({
+      id: restoreMsgId(),
+      role: "assistant",
+      content: "",
+      timestamp: orphanTools[0]?.timestamp ?? new Date(),
+      toolCalls: [...orphanTools],
+    });
+  }
+
+  return result;
+}

package/src/tui/useTerminalSize.ts

@@ -0,0 +1,26 @@
+import { useStdout } from "ink";
+import { useEffect, useState } from "react";
+
+/**
+ * Track terminal columns + rows. Ink's `useStdout` doesn't re-render on
+ * resize, so panels that compute layout from terminal width (e.g. detail
+ * panes that wrap long lines) need this hook to stay accurate.
+ */
+export function useTerminalSize(): { cols: number; rows: number } {
+  const { stdout } = useStdout();
+  const [size, setSize] = useState(() => ({
+    cols: stdout?.columns ?? 80,
+    rows: stdout?.rows ?? 24,
+  }));
+  useEffect(() => {
+    if (!stdout) return;
+    const onResize = () => {
+      setSize({ cols: stdout.columns ?? 80, rows: stdout.rows ?? 24 });
+    };
+    stdout.on("resize", onResize);
+    return () => {
+      stdout.off("resize", onResize);
+    };
+  }, [stdout]);
+  return size;
+}

package/src/tui/wrapDetail.ts

@@ -0,0 +1,15 @@
+import wrapAnsi from "wrap-ansi";
+
+/**
+ * Wrap an ANSI-colored body string to a column width and return one entry
+ * per visual line. Used by the right-pane detail views in every list/detail
+ * panel (Tools, Tasks, Threads, Schedules, Context) so long lines wrap
+ * instead of getting truncated by `<Text wrap="truncate-end">`.
+ *
+ * `wrap-ansi` preserves SGR state across wrap boundaries, so colorized
+ * JSON / markdown stays intact.
+ */
+export function wrapDetailLines(text: string, width: number): string[] {
+  if (width <= 0) return text.split("\n");
+  return wrapAnsi(text, width, { hard: true, trim: false }).split("\n");
+}

package/src/utils/frontmatter.ts

@@ -1,12 +1,18 @@
 import matter from "gray-matter";
+import { z } from "zod";
+
+// --------------------------------------------------------------------------
+// Loose context-file metadata
+//
+// Used for files under `context/` (URL imports, agent-authored notes) and the
+// auto-generated `prompts/capabilities.md`. Frontmatter is permissive here:
+// imported pages may carry source_url / imported_at; agent notes may have
+// nothing at all.
+// --------------------------------------------------------------------------
 
 export interface ContextFileMeta {
   loading?: "always" | "contextual";
   "agent-modification"?: boolean;
-  // Set by `botholomew context import <url>` so the saved file remembers
-  // where it came from. Optional so files written by other paths
-  // (prompts/, beliefs/, agent-authored notes) aren't required to
-  // carry import metadata.
   source_url?: string;
   imported_at?: string;
   title?: string;
@@ -30,3 +36,86 @@ export function serializeContextFile(
 ): string {
   return matter.stringify(`\n${content}\n`, meta);
 }
+
+// --------------------------------------------------------------------------
+// Strict prompt-file schema
+//
+// Every file under `prompts/*.md` must conform. Validation runs at load time
+// (worker + chat) and on every CRUD operation; failures throw
+// PromptValidationError with the offending path so the user can fix it.
+// --------------------------------------------------------------------------
+
+export const PromptFrontmatterSchema = z
+  .object({
+    title: z.string().min(1),
+    loading: z.enum(["always", "contextual"]),
+    "agent-modification": z.boolean(),
+  })
+  .strict();
+
+export type PromptFrontmatter = z.infer<typeof PromptFrontmatterSchema>;
+
+export class PromptValidationError extends Error {
+  constructor(
+    readonly path: string,
+    readonly reason: string,
+  ) {
+    super(`${path}: ${reason}`);
+    this.name = "PromptValidationError";
+  }
+}
+
+export function parsePromptFile(
+  path: string,
+  raw: string,
+): { meta: PromptFrontmatter; content: string } {
+  let parsed: { data: Record<string, unknown>; content: string };
+  try {
+    const m = matter(raw);
+    parsed = {
+      data: (m.data ?? {}) as Record<string, unknown>,
+      content: m.content,
+    };
+  } catch (err) {
+    throw new PromptValidationError(
+      path,
+      `invalid YAML frontmatter — ${err instanceof Error ? err.message : String(err)}`,
+    );
+  }
+
+  if (Object.keys(parsed.data).length === 0) {
+    throw new PromptValidationError(
+      path,
+      "missing frontmatter (required: title, loading, agent-modification)",
+    );
+  }
+
+  const result = PromptFrontmatterSchema.safeParse(parsed.data);
+  if (!result.success) {
+    throw new PromptValidationError(path, formatZodIssues(result.error.issues));
+  }
+
+  return { meta: result.data, content: parsed.content.trim() };
+}
+
+export function serializePromptFile(
+  meta: PromptFrontmatter,
+  content: string,
+): string {
+  return matter.stringify(`\n${content}\n`, meta);
+}
+
+function formatZodIssues(issues: z.ZodIssue[]): string {
+  return issues
+    .map((issue) => {
+      if (issue.code === "unrecognized_keys") {
+        const keys = (issue as z.ZodIssue & { keys?: string[] }).keys ?? [];
+        return `unrecognized frontmatter key(s): ${keys.join(", ")}`;
+      }
+      const field = issue.path.join(".");
+      return field
+        ? `frontmatter field '${field}': ${issue.message}`
+        : issue.message;
+    })
+    .join("; ");
+}

package/src/worker/prompt.ts

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import type { BotholomewConfig } from "../config/schemas.ts";
 import { getPromptsDir } from "../constants.ts";
 import type { Task } from "../tasks/schema.ts";
-import { parseContextFile } from "../utils/frontmatter.ts";
+import { parsePromptFile } from "../utils/frontmatter.ts";
 
 const pkg = await Bun.file(
   new URL("../../package.json", import.meta.url),
@@ -36,37 +36,43 @@ export function extractKeywords(text: string): Set<string> {
  * Load persistent context files from prompts/ as a single formatted
  * string. Includes "always" files unconditionally and "contextual" files
  * whose content overlaps the provided taskKeywords.
+ *
+ * Validation is strict: any *.md file under prompts/ that fails the prompt
+ * frontmatter schema throws PromptValidationError naming the offending file.
+ * The only swallowed error is a missing prompts/ directory (e.g. fresh
+ * working dir before `botholomew init`).
  */
 export async function loadPersistentContext(
   projectDir: string,
   taskKeywords?: Set<string> | null,
 ): Promise<string> {
   const dir = getPromptsDir(projectDir);
-  let out = "";
-
+  let files: string[];
   try {
-    const files = await readdir(dir);
-    const mdFiles = files.filter((f) => f.endsWith(".md"));
-
-    for (const filename of mdFiles) {
-      const filePath = join(dir, filename);
-      const raw = await Bun.file(filePath).text();
-      const { meta, content } = parseContextFile(raw);
-
-      if (meta.loading === "always") {
-        out += `## ${filename}\n${content}\n\n`;
-      } else if (meta.loading === "contextual" && taskKeywords) {
-        const contentLower = content.toLowerCase();
-        const hasOverlap = [...taskKeywords].some((kw) =>
-          contentLower.includes(kw),
-        );
-        if (hasOverlap) {
-          out += `## ${filename} (contextual)\n${content}\n\n`;
-        }
+    files = await readdir(dir);
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code === "ENOENT") return "";
+    throw err;
+  }
+  const mdFiles = files.filter((f) => f.endsWith(".md")).sort();
+
+  let out = "";
+  for (const filename of mdFiles) {
+    const filePath = join(dir, filename);
+    const raw = await Bun.file(filePath).text();
+    const { meta, content } = parsePromptFile(filePath, raw);
+
+    if (meta.loading === "always") {
+      out += `## ${filename}\n${content}\n\n`;
+    } else if (meta.loading === "contextual" && taskKeywords) {
+      const contentLower = content.toLowerCase();
+      const hasOverlap = [...taskKeywords].some((kw) =>
+        contentLower.includes(kw),
+      );
+      if (hasOverlap) {
+        out += `## ${filename} (contextual)\n${content}\n\n`;
       }
     }
-  } catch {
-    // prompts/ might not have md files yet
   }
 
   return out;

package/src/worker/tick.ts

@@ -149,13 +149,22 @@ async function runClaimedTask(opts: {
     `Working: ${task.name}`,
   );
 
-  const systemPrompt = await buildSystemPrompt(
-    projectDir,
-    task,
-    dbPath,
-    config,
-    { hasMcpTools: mcpxClient != null },
-  );
+  let systemPrompt: string;
+  try {
+    systemPrompt = await buildSystemPrompt(projectDir, task, dbPath, config, {
+      hasMcpTools: mcpxClient != null,
+    });
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    await updateTaskStatus(projectDir, task.id, "failed", reason, null);
+    await logInteraction(projectDir, threadId, {
+      role: "system",
+      kind: "status_change",
+      content: `Task ${task.id} failed during prompt load: ${reason}`,
+    });
+    logger.error(`Task ${task.id} failed during prompt load: ${reason}`);
+    return;
+  }
 
   try {
     const result = await runAgentLoop({