botholomew 0.15.0 → 0.15.2

package/src/tui/components/WorkerPanel.tsx

@@ -1,13 +1,20 @@
+import { basename } from "node:path";
 import { Box, Text, useInput, useStdout } from "ink";
 import { memo, useEffect, useMemo, useState } from "react";
 import { readLogTail } from "../../worker/log-reader.ts";
-import { listWorkers, type Worker } from "../../workers/store.ts";
+import {
+  deleteWorkerLog,
+  listWorkers,
+  type Worker,
+} from "../../workers/store.ts";
 import {
   detailPaneBorderProps,
   type FocusState,
   handleListDetailKey,
 } from "../listDetailKeys.ts";
+import { useDeleteConfirm } from "../useDeleteConfirm.ts";
 import { useLatestRef } from "../useLatestRef.ts";
+import { DeleteArmedBanner } from "./DeleteArmedBanner.tsx";
 import { Scrollbar } from "./Scrollbar.tsx";
 
 interface WorkerPanelProps {
@@ -161,6 +168,21 @@ export const WorkerPanel = memo(function WorkerPanel({
   const itemCountRef = useLatestRef(workers.length);
   const maxLogScrollRef = useLatestRef(maxLogScroll);
   const focusRef = useLatestRef(focus);
+  const viewModeRef = useLatestRef(viewMode);
+  const selectedLogPathRef = useLatestRef(selectedLogPath);
+
+  const deleteConfirm = useDeleteConfirm(() => {
+    const path = selectedLogPathRef.current;
+    if (!path) return;
+    deleteWorkerLog(projectDir, path)
+      .catch(() => {})
+      .finally(() => {
+        setLogContent("");
+        setLogSize(0);
+        setLogTruncated(false);
+        setLogScroll(0);
+      });
+  });
 
   // The right pane scrolls with arrows when focused. Tee the log scroll into
   // the follow-state so reaching the bottom resumes follow mode (and any
@@ -181,6 +203,8 @@ export const WorkerPanel = memo(function WorkerPanel({
     (input, key) => {
       if (!isActive) return;
 
+      if (input !== "d") deleteConfirm.cancel();
+
       // `l` toggles between detail (worker info) and log (tail) view in the
       // right pane.
       if (input === "l") {
@@ -206,6 +230,14 @@ export const WorkerPanel = memo(function WorkerPanel({
         setFilterIdx((i) => (i + 1) % STATUS_FILTERS.length);
         return;
       }
+
+      if (input === "d") {
+        if (viewModeRef.current !== "log") return;
+        const path = selectedLogPathRef.current;
+        if (!path) return;
+        deleteConfirm.pressDelete(`worker log: ${basename(path)}`);
+        return;
+      }
     },
     { isActive },
   );
@@ -225,10 +257,14 @@ export const WorkerPanel = memo(function WorkerPanel({
           {focus === "detail"
             ? "  · ↑↓ scroll  ⇧↑↓ page  g/G top/bot  ← back to list  l toggle"
             : viewMode === "log"
-              ? "  · ↑↓ select  → enter log  l detail  f filter"
+              ? "  · ↑↓ select  → enter log  l detail  f filter  d delete log (×2)"
               : "  · ↑↓ select  → enter detail  l view log  f filter"}
         </Text>
       </Box>
+      <DeleteArmedBanner
+        armed={deleteConfirm.armed}
+        label={deleteConfirm.armedLabel}
+      />
 
       {workers.length === 0 ? (
         <Text dimColor>

package/src/tui/idle.tsx

@@ -0,0 +1,68 @@
+import {
+  createContext,
+  type ReactNode,
+  useCallback,
+  useContext,
+  useEffect,
+  useRef,
+  useState,
+} from "react";
+
+const CHECK_INTERVAL_MS = 10_000;
+
+export function shouldBeIdle(
+  lastActivity: number,
+  now: number,
+  timeoutMs: number,
+): boolean {
+  if (timeoutMs <= 0) return false;
+  return now - lastActivity >= timeoutMs;
+}
+
+interface IdleContextValue {
+  isIdle: boolean;
+  markActivity: () => void;
+}
+
+const IdleContext = createContext<IdleContextValue>({
+  isIdle: false,
+  markActivity: () => {},
+});
+
+interface IdleProviderProps {
+  timeoutMs: number;
+  children: ReactNode;
+}
+
+export function IdleProvider({ timeoutMs, children }: IdleProviderProps) {
+  const lastActivityRef = useRef(Date.now());
+  const [isIdle, setIsIdle] = useState(false);
+  const isIdleRef = useRef(isIdle);
+  isIdleRef.current = isIdle;
+
+  const markActivity = useCallback(() => {
+    lastActivityRef.current = Date.now();
+    if (isIdleRef.current) {
+      setIsIdle(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    if (timeoutMs <= 0) return;
+    const id = setInterval(() => {
+      const idle = shouldBeIdle(lastActivityRef.current, Date.now(), timeoutMs);
+      setIsIdle((prev) => (prev === idle ? prev : idle));
+    }, CHECK_INTERVAL_MS);
+    return () => clearInterval(id);
+  }, [timeoutMs]);
+
+  return (
+    <IdleContext.Provider value={{ isIdle, markActivity }}>
+      {children}
+    </IdleContext.Provider>
+  );
+}
+
+export function useIdle(): IdleContextValue {
+  return useContext(IdleContext);
+}

package/src/tui/useDeleteConfirm.ts

@@ -0,0 +1,115 @@
+import { useEffect, useRef, useState } from "react";
+
+/**
+ * Two-press delete confirmation. First press arms; second press within
+ * `ttlMs` confirms. Any non-`d` keystroke should call `cancel()`. The TTL
+ * is a safety net for idle/escape.
+ */
+
+export interface DeleteConfirmController {
+  isArmed(): boolean;
+  armedLabel(): string | null;
+  pressDelete: (label: string) => void;
+  cancel: () => void;
+  dispose: () => void;
+}
+
+export function createDeleteConfirmController(
+  onConfirm: () => void,
+  opts: { ttlMs?: number; onChange?: () => void } = {},
+): DeleteConfirmController {
+  const ttlMs = opts.ttlMs ?? 3000;
+  let armed = false;
+  let label: string | null = null;
+  let timer: ReturnType<typeof setTimeout> | null = null;
+
+  const clearTimer = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  };
+
+  const notify = () => {
+    opts.onChange?.();
+  };
+
+  const pressDelete = (next: string) => {
+    if (armed) {
+      clearTimer();
+      armed = false;
+      label = null;
+      notify();
+      onConfirm();
+      return;
+    }
+    armed = true;
+    label = next;
+    timer = setTimeout(() => {
+      armed = false;
+      label = null;
+      timer = null;
+      notify();
+    }, ttlMs);
+    notify();
+  };
+
+  const cancel = () => {
+    if (!armed && !timer) return;
+    clearTimer();
+    armed = false;
+    label = null;
+    notify();
+  };
+
+  const dispose = () => {
+    clearTimer();
+  };
+
+  return {
+    isArmed: () => armed,
+    armedLabel: () => label,
+    pressDelete,
+    cancel,
+    dispose,
+  };
+}
+
+export interface UseDeleteConfirmResult {
+  armed: boolean;
+  armedLabel: string | null;
+  pressDelete: (label: string) => void;
+  cancel: () => void;
+}
+
+export function useDeleteConfirm(
+  onConfirm: () => void,
+  opts: { ttlMs?: number } = {},
+): UseDeleteConfirmResult {
+  const [, setTick] = useState(0);
+
+  const onConfirmRef = useRef(onConfirm);
+  onConfirmRef.current = onConfirm;
+
+  const controllerRef = useRef<DeleteConfirmController | null>(null);
+  if (!controllerRef.current) {
+    controllerRef.current = createDeleteConfirmController(
+      () => onConfirmRef.current(),
+      { ttlMs: opts.ttlMs, onChange: () => setTick((t) => t + 1) },
+    );
+  }
+
+  useEffect(() => {
+    return () => {
+      controllerRef.current?.dispose();
+    };
+  }, []);
+
+  const c = controllerRef.current;
+  return {
+    armed: c.isArmed(),
+    armedLabel: c.armedLabel(),
+    pressDelete: c.pressDelete,
+    cancel: c.cancel,
+  };
+}

package/src/utils/frontmatter.ts

@@ -3,7 +3,7 @@ import matter from "gray-matter";
 export interface ContextFileMeta {
   loading?: "always" | "contextual";
   "agent-modification"?: boolean;
-  // Set by `bothy context import <url>` so the saved file remembers
+  // 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.

package/src/workers/store.ts

@@ -1,6 +1,6 @@
 import { readdir, stat, unlink } from "node:fs/promises";
-import { join } from "node:path";
-import { getWorkersDir } from "../constants.ts";
+import { join, resolve } from "node:path";
+import { getWorkerLogsDir, getWorkersDir } from "../constants.ts";
 import { atomicWrite, readWithMtime } from "../fs/atomic.ts";
 
 export const WORKER_MODES = ["persist", "once"] as const;
@@ -217,6 +217,28 @@ export async function deleteWorker(
   }
 }
 
+/**
+ * Delete a worker's on-disk log file. Refuses to touch anything outside
+ * `<projectDir>/logs/`. ENOENT is treated as success (idempotent).
+ */
+export async function deleteWorkerLog(
+  projectDir: string,
+  logPath: string,
+): Promise<boolean> {
+  const logsDir = resolve(getWorkerLogsDir(projectDir));
+  const target = resolve(logPath);
+  if (target !== logsDir && !target.startsWith(`${logsDir}/`)) {
+    throw new Error(`refusing to delete log outside ${logsDir}: ${logPath}`);
+  }
+  try {
+    await unlink(target);
+    return true;
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code === "ENOENT") return false;
+    throw err;
+  }
+}
+
 async function listWorkerIds(projectDir: string): Promise<string[]> {
   const dir = getWorkersDir(projectDir);
   try {