botholomew 0.9.9 → 0.9.11

package/src/skills/parser.ts

@@ -55,7 +55,7 @@ export function parseSkillFile(raw: string, filePath: string): SkillDefinition {
  * Split a raw argument string into positional tokens,
  * respecting double-quoted strings.
  */
-function tokenize(raw: string): string[] {
+export function tokenize(raw: string): string[] {
   const tokens: string[] = [];
   let current = "";
   let inQuote = false;
@@ -77,10 +77,30 @@ function tokenize(raw: string): string[] {
   return tokens;
 }
 
+function escapeRegex(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
 export function renderSkill(skill: SkillDefinition, rawArgs: string): string {
   const tokens = tokenize(rawArgs);
   let result = skill.body;
 
+  // Replace $<argName> placeholders first, longest names first so a `$start`
+  // arg can't truncate `$start_date`. Word-boundary tail prevents `$end`
+  // from clipping `$endpoint`.
+  const namedArgs = skill.arguments
+    .map((argDef, i) => ({
+      name: argDef.name,
+      value: tokens[i] ?? argDef.default ?? "",
+    }))
+    .filter((a) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(a.name))
+    .sort((a, b) => b.name.length - a.name.length);
+
+  for (const { name, value } of namedArgs) {
+    const re = new RegExp(`\\$${escapeRegex(name)}(?![A-Za-z0-9_])`, "g");
+    result = result.replace(re, value);
+  }
+
   result = result.replaceAll("$ARGUMENTS", rawArgs);
 
   // Replace $1-$9 with positional args or defaults
@@ -93,3 +113,23 @@ export function renderSkill(skill: SkillDefinition, rawArgs: string): string {
 
   return result;
 }
+
+/**
+ * Identify required arguments that have neither a positional token
+ * nor a declared default. Used by the TUI to reject incomplete
+ * slash-command invocations before sending to the LLM.
+ */
+export function validateSkillArgs(
+  skill: SkillDefinition,
+  rawArgs: string,
+): { missing: string[] } {
+  const tokens = tokenize(rawArgs);
+  const missing: string[] = [];
+  skill.arguments.forEach((argDef, i) => {
+    if (!argDef.required) return;
+    const hasToken = tokens[i] !== undefined;
+    const hasDefault = argDef.default !== undefined;
+    if (!hasToken && !hasDefault) missing.push(argDef.name);
+  });
+  return { missing };
+}

package/src/tools/registry.ts

@@ -33,6 +33,7 @@ import { listSchedulesTool } from "./schedule/list.ts";
 import { searchGrepTool } from "./search/grep.ts";
 import { searchSemanticTool } from "./search/semantic.ts";
 // Skill tools
+import { skillDeleteTool } from "./skill/delete.ts";
 import { skillEditTool } from "./skill/edit.ts";
 import { skillListTool } from "./skill/list.ts";
 import { skillReadTool } from "./skill/read.ts";
@@ -102,6 +103,7 @@ export function registerAllTools(): void {
   registerTool(skillWriteTool);
   registerTool(skillEditTool);
   registerTool(skillSearchTool);
+  registerTool(skillDeleteTool);
 
   // Thread
   registerTool(listThreadsTool);

package/src/tools/skill/delete.ts

@@ -0,0 +1,56 @@
+import { z } from "zod";
+import { loadSkills } from "../../skills/loader.ts";
+import type { ToolDefinition } from "../tool.ts";
+
+const inputSchema = z.object({
+  name: z.string().describe("Skill name (case-insensitive)"),
+});
+
+const outputSchema = z.object({
+  name: z.string().nullable(),
+  path: z.string().nullable(),
+  deleted: z.boolean(),
+  is_error: z.boolean(),
+  error_type: z.string().optional(),
+  message: z.string().optional(),
+  next_action_hint: z.string().optional(),
+});
+
+export const skillDeleteTool = {
+  name: "skill_delete",
+  description:
+    "[[ bash equivalent command: rm ]] Delete a skill file (user-defined slash command) by name. The file is removed from .botholomew/skills/. Returns a not_found error with the list of available names when the skill doesn't exist.",
+  group: "skill",
+  inputSchema,
+  outputSchema,
+  execute: async (input, ctx) => {
+    const skills = await loadSkills(ctx.projectDir);
+    const skill = skills.get(input.name.toLowerCase());
+
+    if (!skill) {
+      const available = [...skills.keys()].sort();
+      const hint =
+        available.length > 0
+          ? `Available: ${available.join(", ")}. Use skill_list to browse.`
+          : "No skills exist yet. Use skill_write to create one.";
+      return {
+        name: input.name,
+        path: null,
+        deleted: false,
+        is_error: true,
+        error_type: "not_found",
+        message: `Skill not found: ${input.name}`,
+        next_action_hint: hint,
+      };
+    }
+
+    await Bun.file(skill.filePath).delete();
+
+    return {
+      name: skill.name,
+      path: skill.filePath,
+      deleted: true,
+      is_error: false,
+    };
+  },
+} satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

package/src/tui/App.tsx

@@ -145,13 +145,13 @@ export function App({
   const [activeTab, setActiveTab] = useState<TabId>(1);
   const [workerRunning, setWorkerRunning] = useState(false);
   const [chatTitle, setChatTitle] = useState<string | undefined>(undefined);
-  const queueRef = useRef<string[]>([]);
+  const queueRef = useRef<Array<{ display: string; content: string }>>([]);
   const processingRef = useRef(false);
   const [queuedMessages, setQueuedMessages] = useState<string[]>([]);
   const [selectedQueueIndex, setSelectedQueueIndex] = useState(0);
 
   const syncQueue = useCallback(() => {
-    const snapshot = [...queueRef.current];
+    const snapshot = queueRef.current.map((e) => e.display);
     setQueuedMessages(snapshot);
     setSelectedQueueIndex((prev) =>
       snapshot.length === 0 ? 0 : Math.min(prev, snapshot.length - 1),
@@ -297,7 +297,7 @@ export function App({
           );
           syncQueue();
           if (msg) {
-            setInputValue(msg);
+            setInputValue(msg.display);
           }
           return;
         }
@@ -327,9 +327,9 @@ export function App({
     processingRef.current = true;
 
     while (queueRef.current.length > 0) {
-      const trimmed = queueRef.current.shift();
+      const entry = queueRef.current.shift();
       syncQueue();
-      if (!trimmed) break;
+      if (!entry) break;
       setIsLoading(true);
       setStreamingText("");
       setActiveToolCalls([]);
@@ -338,7 +338,7 @@ export function App({
       const userMsg: ChatMessage = {
         id: msgId(),
         role: "user",
-        content: trimmed,
+        content: entry.display,
         timestamp: new Date(),
       };
       setMessages((prev) => [...prev, userMsg]);
@@ -366,7 +366,7 @@ export function App({
 
       let lastStreamFlush = 0;
       try {
-        await sendMessage(sessionRef.current, trimmed, {
+        await sendMessage(sessionRef.current, entry.content, {
           onToken: (token) => {
             currentText += token;
             const now = Date.now();
@@ -432,7 +432,10 @@ export function App({
   useEffect(() => {
     if (ready && initialPrompt && !initialPromptSent.current) {
       initialPromptSent.current = true;
-      queueRef.current.push(initialPrompt);
+      queueRef.current.push({
+        display: initialPrompt,
+        content: initialPrompt,
+      });
       syncQueue();
       setInputHistory((prev) => [...prev, initialPrompt]);
       processQueue();
@@ -570,9 +573,12 @@ export function App({
             };
             setMessages((prev) => [...prev, msg]);
           },
-          queueUserMessage: (content) => {
+          queueUserMessage: (content, opts) => {
             setInputHistory((prev) => [...prev, trimmed]);
-            queueRef.current.push(content);
+            queueRef.current.push({
+              display: opts?.display ?? content,
+              content,
+            });
             syncQueue();
             processQueue();
           },
@@ -618,7 +624,7 @@ export function App({
       }
 
       setInputHistory((prev) => [...prev, trimmed]);
-      queueRef.current.push(trimmed);
+      queueRef.current.push({ display: trimmed, content: trimmed });
       syncQueue();
       processQueue();
     },

package/src/tui/components/WorkerPanel.tsx

@@ -1,7 +1,8 @@
 import { Box, Text, useInput, useStdout } from "ink";
-import { memo, useEffect, useState } from "react";
+import { memo, useEffect, useMemo, useState } from "react";
 import { withDb } from "../../db/connection.ts";
 import { listWorkers, type Worker } from "../../db/workers.ts";
+import { readLogTail } from "../../worker/log-reader.ts";
 
 interface WorkerPanelProps {
   dbPath: string;
@@ -15,6 +16,9 @@ const STATUS_FILTERS: readonly (Worker["status"] | null)[] = [
   "dead",
 ];
 
+const PAGE_SCROLL_LINES = 10;
+const LOG_POLL_MS = 1500;
+
 function statusColor(status: Worker["status"]): string {
   switch (status) {
     case "running":
@@ -36,6 +40,12 @@ function formatAge(from: Date, now: Date): string {
   return `${Math.floor(hours / 24)}d`;
 }
 
+function formatBytes(n: number): string {
+  if (n < 1024) return `${n}B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)}KB`;
+  return `${(n / (1024 * 1024)).toFixed(1)}MB`;
+}
+
 export const WorkerPanel = memo(function WorkerPanel({
   dbPath,
   isActive,
@@ -46,6 +56,12 @@ export const WorkerPanel = memo(function WorkerPanel({
   const [selectedIndex, setSelectedIndex] = useState(0);
   const [filterIdx, setFilterIdx] = useState(0);
   const [now, setNow] = useState(() => new Date());
+  const [viewMode, setViewMode] = useState<"detail" | "log">("detail");
+  const [logContent, setLogContent] = useState("");
+  const [logSize, setLogSize] = useState(0);
+  const [logTruncated, setLogTruncated] = useState(false);
+  const [logScroll, setLogScroll] = useState(0);
+  const [logFollow, setLogFollow] = useState(true);
 
   useEffect(() => {
     let mounted = true;
@@ -72,17 +88,135 @@ export const WorkerPanel = memo(function WorkerPanel({
     };
   }, [dbPath, filterIdx]);
 
+  const selected = workers[selectedIndex];
+  const selectedLogPath = selected?.log_path ?? null;
+
+  useEffect(() => {
+    if (viewMode !== "log" || !selectedLogPath) return;
+    let mounted = true;
+
+    const refresh = async () => {
+      try {
+        const tail = await readLogTail(selectedLogPath);
+        if (!mounted) return;
+        setLogContent(tail.content);
+        setLogSize(tail.size);
+        setLogTruncated(tail.truncated);
+      } catch {
+        // Ignore transient read errors; next tick will retry.
+      }
+    };
+
+    refresh();
+    const interval = setInterval(refresh, LOG_POLL_MS);
+    return () => {
+      mounted = false;
+      clearInterval(interval);
+    };
+  }, [viewMode, selectedLogPath]);
+
+  // Reset log scroll + content when the selection or view mode changes.
+  // biome-ignore lint/correctness/useExhaustiveDependencies: intentional reset triggers
+  useEffect(() => {
+    setLogScroll(0);
+    setLogFollow(true);
+    setLogContent("");
+    setLogSize(0);
+    setLogTruncated(false);
+  }, [selected?.id, viewMode]);
+
+  const logLines = useMemo(() => {
+    if (logContent.length === 0) return [];
+    // Trim a single trailing newline so the rendered list doesn't end with a
+    // blank row, but preserve internal blank lines.
+    const trimmed = logContent.endsWith("\n")
+      ? logContent.slice(0, -1)
+      : logContent;
+    return trimmed.split("\n");
+  }, [logContent]);
+
+  const visibleRows = Math.max(4, termRows - 8);
+  const maxLogScroll = Math.max(0, logLines.length - visibleRows);
+
+  // When following, snap scroll to the bottom whenever new log content
+  // arrives. The user can break follow mode by scrolling up; pressing G or
+  // running off the end via j/J resumes it.
+  useEffect(() => {
+    if (viewMode === "log" && logFollow) {
+      setLogScroll(maxLogScroll);
+    }
+  }, [viewMode, logFollow, maxLogScroll]);
+
   useInput(
     (input, key) => {
       if (!isActive) return;
+
+      if (input === "l") {
+        setViewMode((m) => (m === "log" ? "detail" : "log"));
+        return;
+      }
+
       if (key.upArrow) {
+        if (viewMode === "log" && key.shift) {
+          setLogFollow(false);
+          setLogScroll((s) => Math.max(0, s - 1));
+          return;
+        }
         setSelectedIndex((i) => Math.max(0, i - 1));
         return;
       }
       if (key.downArrow) {
+        if (viewMode === "log" && key.shift) {
+          setLogScroll((s) => {
+            const next = Math.min(maxLogScroll, s + 1);
+            if (next >= maxLogScroll) setLogFollow(true);
+            return next;
+          });
+          return;
+        }
         setSelectedIndex((i) => Math.min(workers.length - 1, i + 1));
         return;
       }
+
+      if (viewMode === "log") {
+        if (input === "j") {
+          setLogScroll((s) => {
+            const next = Math.min(maxLogScroll, s + 1);
+            if (next >= maxLogScroll) setLogFollow(true);
+            return next;
+          });
+          return;
+        }
+        if (input === "k") {
+          setLogFollow(false);
+          setLogScroll((s) => Math.max(0, s - 1));
+          return;
+        }
+        if (input === "J") {
+          setLogScroll((s) => {
+            const next = Math.min(maxLogScroll, s + PAGE_SCROLL_LINES);
+            if (next >= maxLogScroll) setLogFollow(true);
+            return next;
+          });
+          return;
+        }
+        if (input === "K") {
+          setLogFollow(false);
+          setLogScroll((s) => Math.max(0, s - PAGE_SCROLL_LINES));
+          return;
+        }
+        if (input === "g") {
+          setLogFollow(false);
+          setLogScroll(0);
+          return;
+        }
+        if (input === "G") {
+          setLogFollow(true);
+          setLogScroll(maxLogScroll);
+          return;
+        }
+      }
+
       if (input === "f") {
         setFilterIdx((i) => (i + 1) % STATUS_FILTERS.length);
         return;
@@ -91,9 +225,8 @@ export const WorkerPanel = memo(function WorkerPanel({
     { isActive },
   );
 
-  const selected = workers[selectedIndex];
   const filterLabel = STATUS_FILTERS[filterIdx] ?? "all";
-  const visibleRows = Math.max(4, termRows - 10);
+  const visibleSidebarRows = Math.max(4, termRows - 10);
 
   return (
     <Box flexDirection="column" flexGrow={1} paddingX={1}>
@@ -103,7 +236,11 @@ export const WorkerPanel = memo(function WorkerPanel({
         </Text>
         <Text dimColor> · filter: </Text>
         <Text color="yellow">{filterLabel}</Text>
-        <Text dimColor>{" · [f] cycle filter  [↑↓] select"}</Text>
+        <Text dimColor>
+          {viewMode === "log"
+            ? "  · [l] back  [↑↓] select  [j/k] scroll  [g/G] top/bot  [f] filter"
+            : "  · [l] view log  [f] cycle filter  [↑↓] select"}
+        </Text>
       </Box>
 
       {workers.length === 0 ? (
@@ -121,7 +258,7 @@ export const WorkerPanel = memo(function WorkerPanel({
             marginRight={2}
             overflow="hidden"
           >
-            {workers.slice(0, visibleRows).map((w, i) => {
+            {workers.slice(0, visibleSidebarRows).map((w, i) => {
               const active = i === selectedIndex;
               const short = w.id.slice(0, 8);
               return (
@@ -148,7 +285,21 @@ export const WorkerPanel = memo(function WorkerPanel({
             })}
           </Box>
           <Box flexDirection="column" flexGrow={1}>
-            {selected ? <WorkerDetail worker={selected} now={now} /> : null}
+            {selected ? (
+              viewMode === "log" ? (
+                <WorkerLogView
+                  worker={selected}
+                  lines={logLines}
+                  scroll={logScroll}
+                  visibleRows={visibleRows}
+                  truncated={logTruncated}
+                  size={logSize}
+                  follow={logFollow}
+                />
+              ) : (
+                <WorkerDetail worker={selected} now={now} />
+              )
+            ) : null}
           </Box>
         </Box>
       )}
@@ -201,6 +352,89 @@ function WorkerDetail({ worker, now }: { worker: Worker; now: Date }) {
             {worker.task_id}
           </Text>
         )}
+        {worker.log_path && (
+          <Text>
+            <Text dimColor>Log </Text>
+            <Text dimColor>{worker.log_path}</Text>
+          </Text>
+        )}
+      </Box>
+    </Box>
+  );
+}
+
+function WorkerLogView({
+  worker,
+  lines,
+  scroll,
+  visibleRows,
+  truncated,
+  size,
+  follow,
+}: {
+  worker: Worker;
+  lines: string[];
+  scroll: number;
+  visibleRows: number;
+  truncated: boolean;
+  size: number;
+  follow: boolean;
+}) {
+  if (!worker.log_path) {
+    return (
+      <Box flexDirection="column">
+        <Text bold color="blue">
+          {worker.id}
+        </Text>
+        <Box marginTop={1}>
+          <Text dimColor>
+            No log file (worker is running in foreground or was started before
+            per-worker logs existed).
+          </Text>
+        </Box>
+      </Box>
+    );
+  }
+
+  if (lines.length === 0) {
+    return (
+      <Box flexDirection="column">
+        <Text bold color="blue">
+          {worker.id}
+        </Text>
+        <Box marginTop={1}>
+          <Text dimColor>Log empty.</Text>
+        </Box>
+      </Box>
+    );
+  }
+
+  const visible = lines.slice(scroll, scroll + visibleRows);
+  const lastLine = Math.min(scroll + visibleRows, lines.length);
+
+  return (
+    <Box flexDirection="column" flexGrow={1}>
+      <Box>
+        <Text bold color="blue">
+          {worker.id.slice(0, 8)}
+        </Text>
+        <Text dimColor>
+          {" "}
+          · {formatBytes(size)}
+          {truncated ? " (tail only)" : ""} ·{" "}
+        </Text>
+        <Text color={follow ? "green" : "yellow"}>
+          {follow ? "following" : "paused"}
+        </Text>
+        <Text dimColor>
+          {"  "}[{scroll + 1}–{lastLine} of {lines.length}]
+        </Text>
+      </Box>
+      <Box flexDirection="column" marginTop={1}>
+        {visible.map((line, i) => {
+          const lineNum = scroll + i;
+          return <Text key={lineNum}>{line || " "}</Text>;
+        })}
       </Box>
     </Box>
   );

package/src/worker/index.ts

@@ -24,6 +24,19 @@ export interface StartWorkerOptions {
    * When omitted, the worker claims the next eligible task from the queue.
    */
   taskId?: string;
+  /**
+   * Pre-allocated worker id from the spawn parent. When provided, the parent
+   * has already opened a per-worker log file at this id and we record both on
+   * the workers row. Foreground/in-process callers may omit this and a fresh
+   * id will be generated.
+   */
+  workerId?: string;
+  /**
+   * Path to the per-worker log file (set by the spawn parent when launching
+   * a detached worker). Stored on the workers row so the TUI can tail it.
+   * Null/undefined for foreground workers writing to stdout.
+   */
+  logPath?: string;
   /**
    * Whether to evaluate schedules as part of this run.
    * Defaults to `true` for one-shot workers without a taskId and for persist
@@ -86,7 +99,7 @@ export async function startWorker(
     logger.info("MCPX client initialized with external tools");
   }
 
-  const workerId = uuidv7();
+  const workerId = options.workerId ?? uuidv7();
   await withDb(dbPath, (conn) =>
     registerWorker(conn, {
       id: workerId,
@@ -94,6 +107,7 @@ export async function startWorker(
       hostname: hostname(),
       mode,
       taskId: taskId ?? null,
+      logPath: options.logPath ?? null,
     }),
   );
 

package/src/worker/log-reader.ts

@@ -0,0 +1,35 @@
+export const DEFAULT_LOG_TAIL_BYTES = 128 * 1024;
+
+export interface LogTail {
+  content: string;
+  truncated: boolean;
+  size: number;
+}
+
+/**
+ * Read the tail of a worker log file. Returns at most `maxBytes` from the end
+ * of the file; sets `truncated` when the file is larger than that.
+ *
+ * If the file doesn't exist (worker hasn't written anything yet), returns
+ * empty content rather than throwing — the caller renders an empty-state
+ * message instead of an error.
+ */
+export async function readLogTail(
+  logPath: string,
+  maxBytes = DEFAULT_LOG_TAIL_BYTES,
+): Promise<LogTail> {
+  const file = Bun.file(logPath);
+  if (!(await file.exists())) {
+    return { content: "", truncated: false, size: 0 };
+  }
+  const size = file.size;
+  if (size === 0) {
+    return { content: "", truncated: false, size: 0 };
+  }
+  if (size <= maxBytes) {
+    return { content: await file.text(), truncated: false, size };
+  }
+  const start = size - maxBytes;
+  const content = await file.slice(start, size).text();
+  return { content, truncated: true, size };
+}

package/src/worker/prompt.ts

@@ -13,6 +13,14 @@ const pkg = await Bun.file(
   new URL("../../package.json", import.meta.url),
 ).json();
 
+export const STYLE_RULES = `## Style
+- Open with the result, action, or next step. Skip preambles like "Great question", "You're absolutely right", "Let me…", "I'll go ahead and…".
+- Don't flatter the user or their ideas. If a request is wrong, ambiguous, or risky, say so plainly with the reason.
+- Hold your position when you have one. Don't capitulate to pushback that brings no new evidence.
+- Be terse. Don't restate what you just did or are about to do — show it.
+- Report failures and uncertainty directly. Don't paper over gaps with confident prose.
+`;
+
 /**
  * Extract keyword set from free-form text: lowercase, split on whitespace,
  * keep words longer than 3 chars. Used to match `loading: contextual` files
@@ -160,5 +168,7 @@ Skip step 2 only if you already called \`mcp_info\` for that exact server+tool e
 `;
   }
 
+  prompt += `\n${STYLE_RULES}`;
+
   return prompt;
 }

package/src/worker/run.ts

@@ -1,14 +1,14 @@
 #!/usr/bin/env bun
 
 // Standalone entry point for a worker when spawned as a detached process.
-// Usage: bun run src/worker/run.ts <projectDir> [--persist] [--task-id=<uuid>] [--no-eval-schedules]
+// Usage: bun run src/worker/run.ts <projectDir> [--worker-id=<uuid>] [--log-path=<path>] [--persist] [--task-id=<uuid>] [--no-eval-schedules]
 
 import { startWorker } from "./index.ts";
 
 const projectDir = process.argv[2];
 if (!projectDir) {
   console.error(
-    "Usage: bun run src/worker/run.ts <projectDir> [--persist] [--task-id=<uuid>] [--no-eval-schedules]",
+    "Usage: bun run src/worker/run.ts <projectDir> [--worker-id=<uuid>] [--log-path=<path>] [--persist] [--task-id=<uuid>] [--no-eval-schedules]",
   );
   process.exit(1);
 }
@@ -18,9 +18,17 @@ const persist = args.includes("--persist");
 const noEvalSchedules = args.includes("--no-eval-schedules");
 const taskIdArg = args.find((a) => a.startsWith("--task-id="));
 const taskId = taskIdArg ? taskIdArg.slice("--task-id=".length) : undefined;
+const workerIdArg = args.find((a) => a.startsWith("--worker-id="));
+const workerId = workerIdArg
+  ? workerIdArg.slice("--worker-id=".length)
+  : undefined;
+const logPathArg = args.find((a) => a.startsWith("--log-path="));
+const logPath = logPathArg ? logPathArg.slice("--log-path=".length) : undefined;
 
 await startWorker(projectDir, {
   mode: persist ? "persist" : "once",
   taskId,
+  workerId,
+  logPath,
   evalSchedules: noEvalSchedules ? false : undefined,
 });