tuiboard 0.11.0 → 0.13.0

package/src/store/agents.ts

@@ -1,48 +1,58 @@
 /**
- * Discovery + reactive store for local Claude Code sessions.
+ * Discovery + reactive store for local coding-agent sessions.
  *
- * Reads:
- *   ~/.claude/projects/<slug>/<sessionId>.jsonl  — transcripts
- *   ~/.claude/sessions/<sessionId>.json          — live PID records
- *
- * Watches both with chokidar; re-parses the changed jsonl on update.
- * Eager initial scan (1-2s for ~80 sessions) is acceptable startup cost.
+ * Each agent CLI (Claude Code, Codex, OpenCode, Pi) plugs in through an `AgentAdapter`
+ * that owns its own on-disk format, status semantics and resume command —
+ * see `src/store/agent-adapters/`. This module only holds the shared shape
+ * and merges every adapter's sessions into one sorted, watched list.
  */
 
-import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
+import { existsSync } from "node:fs";
+import { resolve, sep } from "node:path";
+
 import chokidar from "chokidar";
 import { createSignal } from "solid-js";
 
-const CLAUDE_HOME = join(homedir(), ".claude");
-const PROJECTS_DIR = join(CLAUDE_HOME, "projects");
-const SESSIONS_DIR = join(CLAUDE_HOME, "sessions");
+import {
+  linkHerdrSessions,
+  type HerdrLink,
+  type HerdrSnapshot,
+  type HerdrSource,
+} from "~/store/herdr";
+
+/** Threshold: session untouched longer than this is "archived" (won't show in compact list). */
+export const DORMANT_AFTER_MS = 7 * 86_400 * 1000;
+
+export type AgentProvider = "claude-code" | "codex" | "opencode" | "pi";
+
+/** Two-letter harness badge + display name, per provider. */
+export const HARNESS: Record<AgentProvider, { code: string; name: string }> = {
+  "claude-code": { code: "cc", name: "Claude Code" },
+  codex: { code: "cx", name: "Codex" },
+  opencode: { code: "oc", name: "OpenCode" },
+  pi: { code: "pi", name: "Pi" },
+};
 
-/** Threshold: PID record older than this means the Claude process likely crashed. */
-const LIVE_STALE_AFTER_MS = 5 * 60 * 1000;
-/** Threshold: jsonl untouched longer than this is "archived" (won't show in compact list). */
-const DORMANT_AFTER_MS = 7 * 86_400 * 1000;
+/** Agents-zone filter: every harness, or just one. */
+export type AgentsFilter = "all" | AgentProvider;
 
 export type AgentStatus =
+  /** Waiting for you (permission/question) — known only via herdr. */
+  | "live-blocked"
   | "live-busy"
+  /** Finished its turn, not looked at yet — known only via herdr. */
+  | "live-done"
   | "live-idle"
-  | "stale-pid"
+  /** Looks busy, but stopped updating — the process likely crashed. */
+  | "stale"
   | "dormant"
   | "archived";
 
-export interface LivePidRecord {
-  mtimeMs: number;
-  /** "busy" | "idle" | undefined */
-  status?: string;
-  pid?: number;
-  version?: string;
-  cwd?: string;
-}
-
 export interface AgentSession {
+  provider: AgentProvider;
   sessionId: string;
-  jsonlPath: string;
+  /** File (or database) the session was read from. */
+  sourcePath: string;
   cwd: string;
   cwdShort: string;
   status: AgentStatus;
@@ -55,58 +65,52 @@ export interface AgentSession {
   lastUser?: string;
   lastAssistant?: string;
   gitBranch?: string;
+  /** Model id as the agent recorded it (latest turn), e.g. `claude-opus-5`. */
+  model?: string;
+  /** Shell command that resumes this session when run from `cwd`. */
+  resumeCommand: string;
+  /** Same, as argv (`[binary, ...args]`) — for launchers that start the agent directly. */
+  resumeArgv: string[];
+  /** Set when the session is open in a herdr pane. */
+  herdr?: HerdrLink;
 }
 
-/**
- * Reverse Claude Code's path-to-slug encoding (lossy on case).
- *
- * Claude Code encodes the cwd by replacing every `:`, `\` and `/` with `-`.
- *
- *   Windows  "C:\Users\foo"   → "C--Users-foo"
- *   POSIX    "/home/foo"      → "-home-foo"
- *
- * We can recognize a Windows-shaped slug by the `<letter>--` prefix
- * (drive letter followed by colon → two leading dashes). Anything else
- * is assumed POSIX. This works regardless of `process.platform`, so
- * decoding remote-shape paths (sessions originated on a different OS)
- * still produces something sensible.
- */
-export function cwdFromSlug(slug: string): string {
-  // Windows drive letter shape: "C--Users-foo" → "C:\Users\foo".
-  if (slug.length >= 3 && /^[A-Za-z]--/.test(slug)) {
-    return slug[0] + ":\\" + slug.slice(3).replaceAll("-", "\\");
-  }
-  // POSIX shape: "-home-foo" → "/home/foo".
-  if (slug.startsWith("-")) {
-    return "/" + slug.slice(1).replaceAll("-", "/");
-  }
-  // Fallback: bare directory name. Pick the separator from the host OS so
-  // the result at least concatenates correctly when the user copies it.
-  const sep = process.platform === "win32" ? "\\" : "/";
-  return slug.replaceAll("-", sep);
+/** One agent CLI's session source. */
+export interface AgentAdapter {
+  provider: AgentProvider;
+  /** Files/directories whose changes should trigger a refresh. */
+  watchPaths(): string[];
+  /** Full scan. Must not throw — a missing install yields `[]`. */
+  discover(now: number): AgentSession[];
 }
 
-/** Last 3 path parts with leading ellipsis when path is long. */
+/** Last 3 path parts with leading ellipsis when path is long. Keeps the path's own separator. */
 export function cwdShort(cwd: string): string {
   const parts = cwd.split(/[\\/]/).filter((p) => p.length > 0);
   if (parts.length >= 4) {
-    return "…" + parts.slice(-3).join("\\");
+    const sep = cwd.includes("/") ? "/" : "\\";
+    return "…" + parts.slice(-3).join(sep);
   }
   return cwd;
 }
 
-export function classifyStatus(
-  now: number,
-  jsonlMtimeMs: number,
-  live: LivePidRecord | undefined,
-): AgentStatus {
-  if (live) {
-    if (now - live.mtimeMs > LIVE_STALE_AFTER_MS) return "stale-pid";
-    return live.status === "busy" ? "live-busy" : "live-idle";
-  }
-  const age = now - jsonlMtimeMs;
-  if (age > DORMANT_AFTER_MS) return "archived";
-  return "dormant";
+/**
+ * Compact model label for tight rows: drops the provider prefix, the
+ * `claude-` family prefix, date stamps and context-window suffixes.
+ *   `claude-opus-5[1m]` → `opus-5` · `anthropic/claude-sonnet-4-5-20250929` → `sonnet-4-5`
+ */
+export function shortModel(raw: string | undefined): string | undefined {
+  if (!raw || raw.startsWith("<")) return undefined; // e.g. Claude's "<synthetic>"
+  const m = (raw.split("/").pop() ?? raw)
+    .replace(/\[[^\]]*\]$/, "")
+    .replace(/^claude-/, "")
+    .replace(/-\d{8}$/, "");
+  return m || undefined;
+}
+
+/** Apply the Agents-zone harness filter. Keeps the store's sort order. */
+export function filterSessions(arr: AgentSession[], filter: AgentsFilter): AgentSession[] {
+  return filter === "all" ? arr : arr.filter((s) => s.provider === filter);
 }
 
 /** Compact human-readable age. Mirrors av.py `_fmt_age`. */
@@ -119,268 +123,33 @@ export function formatAge(ts: number, now: number): string {
   return `${Math.floor(delta / 86_400)}d`;
 }
 
-export interface TranscriptParseResult {
-  customTitle?: string;
-  aiTitle?: string;
-  /**
-   * First user message that looks like a real human prompt — skill loaders,
-   * system tags, and bare slash-command invocations are filtered. Used as
-   * the displayName fallback when there is no custom/ai title.
-   */
-  firstHumanUser?: string;
-  lastUser?: string;
-  lastAssistant?: string;
-  messageCount: number;
-  toolCount: number;
-  gitBranch?: string;
-}
+const STATUS_RANK: Record<AgentStatus, number> = {
+  "live-blocked": 0,
+  "live-busy": 1,
+  "live-done": 2,
+  "live-idle": 3,
+  "stale": 4,
+  "dormant": 5,
+  "archived": 6,
+};
 
-/**
- * Heuristic: is this user "message" actually a skill/system bootstrap that
- * Claude Code injected on session start? Used to skip these when picking
- * a fallback displayName — otherwise N sessions opened by the same skill
- * all look identical in the list.
- */
-function looksSyntheticUser(text: string): boolean {
-  const t = text.trimStart();
-  if (!t) return true;
-  // Skill bootstrap: "Base directory for this skill: ..."
-  if (t.startsWith("Base directory for this skill")) return true;
-  // System-injected tags: <command-name>, <task-notification>, <system-reminder>, <local-command-stdout>
-  if (/^<[a-z][a-z0-9-]*>/i.test(t)) return true;
-  // Bare slash-command invocation (the literal "/morning", "/log", etc.)
-  if (/^\/[a-z][a-z0-9-]*\s*$/i.test(t)) return true;
-  return false;
+/** Is the agent process running (as far as we can tell)? */
+export function isLive(status: AgentStatus): boolean {
+  return status.startsWith("live-");
 }
 
 /**
- * Lightweight pass over a jsonl transcript. Defensive: malformed lines
- * are skipped silently because the format is internal to Claude Code
- * and may drift between versions.
+ * Most recently active first; status only breaks ties. Archived sessions
+ * always go last — the dashboard strip hides them and relies on that to keep
+ * cursor indices aligned with the full list.
  */
-export function parseTranscript(content: string): TranscriptParseResult {
-  let customTitle: string | undefined;
-  let aiTitle: string | undefined;
-  let firstHumanUser: string | undefined;
-  let lastUser: string | undefined;
-  let lastAssistant: string | undefined;
-  let gitBranch: string | undefined;
-  let messageCount = 0;
-  let toolCount = 0;
-
-  const recordUserText = (text: string) => {
-    lastUser = text;
-    if (firstHumanUser === undefined && !looksSyntheticUser(text)) {
-      firstHumanUser = text;
-    }
-  };
-
-  for (const line of content.split("\n")) {
-    if (!line.trim()) continue;
-    let obj: any;
-    try {
-      obj = JSON.parse(line);
-    } catch {
-      continue;
-    }
-    if (obj.gitBranch) gitBranch = obj.gitBranch;
-    const t = obj.type;
-    if (t === "custom-title") {
-      customTitle = obj.customTitle ?? obj.title ?? customTitle;
-      continue;
-    }
-    if (t === "ai-title") {
-      aiTitle = obj.aiTitle ?? obj.title ?? aiTitle;
-      continue;
-    }
-    const msg = obj.message ?? {};
-    const role = msg.role;
-    if (role === "user") {
-      messageCount++;
-      const content = msg.content;
-      if (typeof content === "string") {
-        recordUserText(content);
-      } else if (Array.isArray(content)) {
-        for (const part of content) {
-          if (
-            part &&
-            typeof part === "object" &&
-            part.type === "text" &&
-            typeof part.text === "string"
-          ) {
-            recordUserText(part.text);
-          }
-        }
-      }
-    } else if (role === "assistant") {
-      messageCount++;
-      const content = msg.content;
-      if (Array.isArray(content)) {
-        for (const part of content) {
-          if (!part || typeof part !== "object") continue;
-          if (part.type === "text" && typeof part.text === "string") {
-            lastAssistant = part.text;
-          } else if (part.type === "tool_use") {
-            toolCount++;
-          }
-        }
-      }
-    }
-  }
-
-  return {
-    customTitle,
-    aiTitle,
-    firstHumanUser,
-    lastUser,
-    lastAssistant,
-    messageCount,
-    toolCount,
-    gitBranch,
-  };
-}
-
-// ─── Discovery ──────────────────────────────────────────────────────────────
-
-function discoverLivePids(): Map<string, LivePidRecord> {
-  const out = new Map<string, LivePidRecord>();
-  if (!existsSync(SESSIONS_DIR)) return out;
-  let entries: string[];
-  try {
-    entries = readdirSync(SESSIONS_DIR);
-  } catch {
-    return out;
-  }
-  for (const f of entries) {
-    if (!f.endsWith(".json")) continue;
-    const path = join(SESSIONS_DIR, f);
-    try {
-      const raw = JSON.parse(readFileSync(path, "utf-8"));
-      const sid = raw.sessionId;
-      if (!sid) continue;
-      const stat = statSync(path);
-      out.set(sid, {
-        mtimeMs: stat.mtimeMs,
-        status: raw.status?.toLowerCase(),
-        pid: raw.pid,
-        version: raw.version,
-        cwd: raw.cwd,
-      });
-    } catch {
-      // ignore — malformed PID files happen during writes
-    }
-  }
-  return out;
-}
-
-interface JsonlEntry {
-  slug: string;
-  sessionId: string;
-  path: string;
-  mtimeMs: number;
-}
-
-function discoverJsonlFiles(): JsonlEntry[] {
-  const out: JsonlEntry[] = [];
-  if (!existsSync(PROJECTS_DIR)) return out;
-  let slugs: string[];
-  try {
-    slugs = readdirSync(PROJECTS_DIR);
-  } catch {
-    return out;
-  }
-  for (const slug of slugs) {
-    const slugDir = join(PROJECTS_DIR, slug);
-    let slugStat;
-    try {
-      slugStat = statSync(slugDir);
-    } catch {
-      continue;
-    }
-    if (!slugStat.isDirectory()) continue;
-    let inner: string[];
-    try {
-      inner = readdirSync(slugDir);
-    } catch {
-      continue;
-    }
-    for (const f of inner) {
-      // Skip subagent transcripts — they're addressed by their parent session.
-      if (!f.endsWith(".jsonl")) continue;
-      const path = join(slugDir, f);
-      try {
-        const stat = statSync(path);
-        if (!stat.isFile()) continue;
-        out.push({
-          slug,
-          sessionId: f.slice(0, -".jsonl".length),
-          path,
-          mtimeMs: stat.mtimeMs,
-        });
-      } catch {
-        continue;
-      }
-    }
-  }
-  return out;
-}
-
-function buildSession(
-  jsonl: JsonlEntry,
-  live: LivePidRecord | undefined,
-  now: number,
-): AgentSession {
-  let parsed: TranscriptParseResult;
-  try {
-    parsed = parseTranscript(readFileSync(jsonl.path, "utf-8"));
-  } catch {
-    parsed = { messageCount: 0, toolCount: 0 };
-  }
-  const cwd = live?.cwd ?? cwdFromSlug(jsonl.slug);
-  const hasRealTitle = Boolean(parsed.customTitle || parsed.aiTitle);
-  const fallbackText =
-    parsed.firstHumanUser?.split("\n").find((l) => l.trim().length > 0)?.slice(0, 60) ??
-    parsed.lastUser?.split("\n").find((l) => l.trim().length > 0)?.slice(0, 60);
-  const uuid8 = jsonl.sessionId.slice(0, 8);
-  // When no human-authored title is available, suffix the uuid8 so visually
-  // identical fallback titles (e.g. many sessions started by the same /skill)
-  // still produce distinct rows.
-  const displayName = hasRealTitle
-    ? (parsed.customTitle ?? parsed.aiTitle)!.slice(0, 60)
-    : fallbackText
-      ? `${fallbackText} · ${uuid8}`
-      : uuid8;
-  return {
-    sessionId: jsonl.sessionId,
-    jsonlPath: jsonl.path,
-    cwd,
-    cwdShort: cwdShort(cwd),
-    status: classifyStatus(now, jsonl.mtimeMs, live),
-    lastActivityMs: jsonl.mtimeMs,
-    customTitle: parsed.customTitle,
-    aiTitle: parsed.aiTitle,
-    displayName,
-    messageCount: parsed.messageCount,
-    toolCount: parsed.toolCount,
-    lastUser: parsed.lastUser,
-    lastAssistant: parsed.lastAssistant,
-    gitBranch: parsed.gitBranch,
-  };
-}
-
-const STATUS_RANK: Record<AgentStatus, number> = {
-  "live-busy": 0,
-  "live-idle": 1,
-  "stale-pid": 2,
-  "dormant": 3,
-  "archived": 4,
-};
-
-function sortSessions(arr: AgentSession[]): AgentSession[] {
+export function sortSessions(arr: AgentSession[]): AgentSession[] {
   return arr.slice().sort((a, b) => {
-    const r = STATUS_RANK[a.status] - STATUS_RANK[b.status];
-    if (r !== 0) return r;
-    return b.lastActivityMs - a.lastActivityMs;
+    const archived = Number(a.status === "archived") - Number(b.status === "archived");
+    if (archived !== 0) return archived;
+    const recency = b.lastActivityMs - a.lastActivityMs;
+    if (recency !== 0) return recency;
+    return STATUS_RANK[a.status] - STATUS_RANK[b.status];
   });
 }
 
@@ -388,48 +157,119 @@ function sortSessions(arr: AgentSession[]): AgentSession[] {
 
 export interface AgentsStore {
   sessions: () => AgentSession[];
+  /** Latest herdr snapshot (undefined without herdr). */
+  herdr: () => HerdrSnapshot | undefined;
   refresh: () => void;
   dispose: () => Promise<void>;
 }
 
+const DEBOUNCE_MS = 200;
+/** Cap on debounce deferral, so a session streaming non-stop still refreshes. */
+const DEBOUNCE_MAX_WAIT_MS = 1000;
+/**
+ * The watcher ignores paths that don't exist yet (agent installed, or first
+ * session started, after tuiboard launched) — poll for them this often.
+ */
+const MISSING_PATH_POLL_MS = 5000;
+
 /**
- * Reactive store of local Claude Code sessions. Watches the .claude
- * projects + sessions directories and refreshes on any change with a
- * short debounce. Initial scan is eager.
+ * Reactive store of local agent sessions. Watches every adapter's paths and,
+ * on a change, re-scans only the adapter that owns the changed path (short
+ * debounce). Initial scan is eager.
  */
-export function createAgentsStore(): AgentsStore {
+export function createAgentsStore(
+  adapters: AgentAdapter[],
+  {
+    missingPathPollMs = MISSING_PATH_POLL_MS,
+    herdr,
+  }: { missingPathPollMs?: number; herdr?: HerdrSource } = {},
+): AgentsStore {
   const [sessions, setSessions] = createSignal<AgentSession[]>([]);
+  const byAdapter = new Map<AgentAdapter, AgentSession[]>();
+
+  function scan(adapter: AgentAdapter, now: number): void {
+    try {
+      byAdapter.set(adapter, adapter.discover(now));
+    } catch {
+      // One broken adapter must not blank out the others; keep its last list.
+    }
+  }
+
+  function publish(): void {
+    const all = [...byAdapter.values()].flat();
+    setSessions(sortSessions(linkHerdrSessions(all, herdr?.snapshot())));
+  }
+  herdr?.onChange(publish);
 
   function refresh(): void {
     const now = Date.now();
-    const live = discoverLivePids();
-    const jsonlFiles = discoverJsonlFiles();
-    const built = jsonlFiles.map((j) =>
-      buildSession(j, live.get(j.sessionId), now),
-    );
-    setSessions(sortSessions(built));
+    for (const adapter of adapters) scan(adapter, now);
+    publish();
   }
 
   refresh();
 
+  const watched = adapters.flatMap((adapter) =>
+    adapter.watchPaths().map((p) => ({ root: resolve(p), adapter })),
+  );
+  const owners = (path: string) => {
+    const abs = resolve(path);
+    return new Set(
+      watched
+        .filter((w) => abs === w.root || abs.startsWith(w.root + sep))
+        .map((w) => w.adapter),
+    );
+  };
+
+  const pending = new Set<AgentAdapter>();
   let debounceTimer: ReturnType<typeof setTimeout> | undefined;
-  const onChange = () => {
+  let firstPendingAt = 0;
+  const flush = () => {
+    debounceTimer = undefined;
+    const now = Date.now();
+    for (const adapter of pending) scan(adapter, now);
+    pending.clear();
+    publish();
+  };
+  const onChange = (path: string) => {
+    const hit = owners(path);
+    if (hit.size === 0) return;
+    for (const adapter of hit) pending.add(adapter);
+    const now = Date.now();
     if (debounceTimer) clearTimeout(debounceTimer);
-    debounceTimer = setTimeout(refresh, 200);
+    else firstPendingAt = now;
+    const wait = Math.min(DEBOUNCE_MS, firstPendingAt + DEBOUNCE_MAX_WAIT_MS - now);
+    debounceTimer = setTimeout(flush, Math.max(0, wait));
   };
 
-  const watcher = chokidar.watch([PROJECTS_DIR, SESSIONS_DIR], {
-    ignoreInitial: true,
-    depth: 3,
-  });
+  const roots = [...new Set(watched.map((w) => w.root))];
+  const watcher = chokidar.watch(
+    roots.filter((r) => existsSync(r)),
+    { ignoreInitial: true, depth: 3 },
+  );
   watcher.on("add", onChange);
+  watcher.on("addDir", onChange);
   watcher.on("change", onChange);
   watcher.on("unlink", onChange);
 
+  let missing = roots.filter((r) => !existsSync(r));
+  const missingPoll = setInterval(() => {
+    const appeared = missing.filter((r) => existsSync(r));
+    if (appeared.length === 0) return;
+    missing = missing.filter((r) => !appeared.includes(r));
+    watcher.add(appeared);
+    for (const root of appeared) onChange(root);
+    if (missing.length === 0) clearInterval(missingPoll);
+  }, missingPathPollMs);
+  missingPoll.unref?.();
+  if (missing.length === 0) clearInterval(missingPoll);
+
   async function dispose() {
     if (debounceTimer) clearTimeout(debounceTimer);
+    clearInterval(missingPoll);
+    herdr?.dispose();
     await watcher.close();
   }
 
-  return { sessions, refresh, dispose };
+  return { sessions, herdr: () => herdr?.snapshot(), refresh, dispose };
 }