catherd-cli 0.2.1 → 1.0.0

package/src/tui/watch.tsx

@@ -1,236 +0,0 @@
-import { join } from "node:path";
-import { TextAttributes } from "@opentui/core";
-import { useKeyboard, useRenderer } from "@opentui/react";
-import { useEffect, useRef, useState } from "react";
-import { type BudgetStatus, formatBudget, type RunSummary, summarizeRun } from "../core/status.ts";
-import { listRuns, readJsonl, readRunRecords, type Run } from "../core/runstore.ts";
-import type { RunRecord, RungId } from "../types.ts";
-import { face, glyph, tint, type Ui } from "./theme.ts";
-import { CatSpinner, DetailPane, Frame, gradientLetters, ListLine } from "./ui.tsx";
-import {
-  budgetTone,
-  climbs,
-  jevLine,
-  type JevLine,
-  liveLine,
-  plainBudgetBar,
-  runLine,
-} from "./watch-model.ts";
-
-export interface WatchDeps {
-  listRuns: () => Run[];
-  summarizeRun: (run: Run) => RunSummary;
-  readRunRecords: (dir: string) => RunRecord[];
-  readJev: (dir: string) => JevLine[];
-}
-
-const watchDeps: WatchDeps = {
-  listRuns,
-  summarizeRun,
-  readRunRecords,
-  readJev: (dir) => readJsonl<JevLine>(join(dir, "jev.jsonl")),
-};
-
-// ponytail: only the 20 newest runs are summarized each poll; add paging when someone keeps more than that live
-const MAX_RUNS = 20;
-const LEFT_HEIGHT = 12;
-
-interface Item {
-  run: Run;
-  summary: RunSummary | null;
-  error: string | null;
-}
-
-function poll(d: WatchDeps): { items: Item[]; problem: string | null } {
-  try {
-    const items = d
-      .listRuns()
-      .slice(0, MAX_RUNS)
-      .map((run): Item => {
-        try {
-          return { run, summary: d.summarizeRun(run), error: null };
-        } catch (e) {
-          return { run, summary: null, error: (e as Error).message };
-        }
-      });
-    return { items, problem: null };
-  } catch (e) {
-    return { items: [], problem: (e as Error).message };
-  }
-}
-
-/** spec §11b: a bar in the ginger-to-pink gradient, solid ginger from 80% spent and solid pink once
- * the budget is exhausted (the palette has no dedicated warning/error tones, see watch-model.ts). */
-function BudgetBar({ ui, budget }: { ui: Ui; budget: BudgetStatus }) {
-  const width = 10;
-  if (ui.plain) {
-    return (
-      <text
-        wrapMode="none"
-        truncate
-      >{`${plainBudgetBar(budget.fraction, width)} ${formatBudget(budget)}`}</text>
-    );
-  }
-  const filled = Math.round(Math.max(0, Math.min(1, budget.fraction)) * width);
-  const tone = budgetTone(budget.fraction);
-  const solid =
-    tone === "error" ? tint("pink", ui.depth) : tone === "warning" ? tint("ginger", ui.depth) : null;
-  const cells = solid
-    ? Array.from({ length: filled }, () => ({ ch: "█", fg: solid }))
-    : gradientLetters("█".repeat(filled));
-  return (
-    <text wrapMode="none" truncate>
-      {cells.map((cell, i) => (
-        // biome-ignore lint: index key is stable, the bar never reorders
-        <span key={i} fg={cell.fg}>
-          {cell.ch}
-        </span>
-      ))}
-      <span attributes={TextAttributes.DIM}>{"░".repeat(width - filled)}</span>
-      {` ${formatBudget(budget)}`}
-    </text>
-  );
-}
-
-/** The right pane for the highlighted run: its live lanes, recent climbs, Jev decisions and the
- * budget bar — the run's records and raw state text stay out (they were noise, spec §item 4). */
-function RunDetail({ ui, it, climbed, deps }: { ui: Ui; it: Item; climbed: string[]; deps: WatchDeps }) {
-  const pink = tint("pink", ui.depth);
-  if (!it.summary) {
-    return (
-      <DetailPane ui={ui} title={it.run.id} subtitle="unreadable">
-        <text fg={pink} wrapMode="none" truncate>
-          {`${face("failed", ui.plain)} ${it.error}`}
-        </text>
-      </DetailPane>
-    );
-  }
-  const s = it.summary;
-  const jev = deps.readJev(it.run.dir);
-  return (
-    <DetailPane ui={ui} title={s.title} subtitle={it.run.meta.repo}>
-      {s.live.length > 0 ? (
-        s.live.map((l) => (
-          <text key={l.name} wrapMode="none" truncate>
-            {liveLine(l, ui.plain)}
-          </text>
-        ))
-      ) : (
-        <text attributes={TextAttributes.DIM}>no lane is running right now</text>
-      )}
-      {climbed.length > 0 ? (
-        <>
-          <text> </text>
-          {climbed.map((c, i) => (
-            <text key={`c${i}`} fg={pink} wrapMode="none" truncate>
-              {c}
-            </text>
-          ))}
-        </>
-      ) : null}
-      <text> </text>
-      <text attributes={TextAttributes.DIM}>
-        {`jev ${glyph("dot", ui.plain)} ${s.jev.decisions} decisions ${glyph("dot", ui.plain)} ${s.jev.fallbacks} fell back`}
-      </text>
-      {jev.slice(-4).map((e, i) => (
-        <text key={`j${i}`} wrapMode="none" truncate>
-          {jevLine(e, ui.plain)}
-        </text>
-      ))}
-      {s.budget ? (
-        <>
-          <text> </text>
-          <BudgetBar ui={ui} budget={s.budget} />
-        </>
-      ) : null}
-    </DetailPane>
-  );
-}
-
-export function Watch({
-  ui,
-  deps = {},
-  intervalMs = 2000,
-}: {
-  ui: Ui;
-  deps?: Partial<WatchDeps>;
-  intervalMs?: number;
-}) {
-  const d = { ...watchDeps, ...deps };
-  const renderer = useRenderer();
-  const seen = useRef(new Map<string, RungId>());
-  const [state, setState] = useState<{ items: Item[]; problem: string | null } | null>(null);
-  const [climbed, setClimbed] = useState<string[]>([]);
-  const [cursor, setCursor] = useState(0);
-
-  useEffect(() => {
-    const refresh = () => {
-      const next = poll(d);
-      const fresh = next.items.flatMap((it) =>
-        it.summary ? climbs(seen.current, it.summary, ui.plain) : [],
-      );
-      if (fresh.length > 0) setClimbed((c) => [...fresh, ...c].slice(0, 3));
-      setState(next);
-    };
-    refresh();
-    const t = setInterval(refresh, intervalMs);
-    return () => clearInterval(t);
-  }, []);
-
-  const items = state?.items ?? [];
-  const at = Math.min(cursor, Math.max(0, items.length - 1));
-  const leftStart = Math.max(0, Math.min(at - Math.floor(LEFT_HEIGHT / 2), items.length - LEFT_HEIGHT));
-
-  useKeyboard((key) => {
-    if (key.sequence === "q") {
-      renderer.destroy();
-      return;
-    }
-    if (key.name === "up") setCursor(Math.max(0, at - 1));
-    else if (key.name === "down") setCursor(Math.min(items.length - 1, at + 1));
-  });
-
-  const pink = tint("pink", ui.depth);
-  const title = `Watch ${glyph("dot", ui.plain)} ${items.length} runs`;
-  const hint = `${glyph("keys", ui.plain)} navigate   q quit   refreshes every ${intervalMs / 1000} s`;
-
-  if (state?.problem) {
-    return (
-      <Frame ui={ui} title={title} hint="q quit">
-        <text fg={pink} wrapMode="none" truncate>{`${face("failed", ui.plain)} ${state.problem}`}</text>
-      </Frame>
-    );
-  }
-
-  return (
-    <Frame ui={ui} title={title} hint={hint}>
-      {state === null ? (
-        <CatSpinner ui={ui} label="reading the runs" />
-      ) : items.length === 0 ? (
-        <text>No runs yet. Start one with /catherd in Claude Code.</text>
-      ) : (
-        <box style={{ flexDirection: "row" }}>
-          <box style={{ flexDirection: "column", width: 24 }}>
-            <text fg={pink} attributes={TextAttributes.BOLD}>
-              RUNS
-            </text>
-            {items.slice(leftStart, leftStart + LEFT_HEIGHT).map((it, i) => (
-              <ListLine
-                key={it.run.dir}
-                ui={ui}
-                selected={leftStart + i === at}
-                dim={!it.summary}
-                text={
-                  it.summary
-                    ? runLine(it.summary, ui.plain)
-                    : `${face("failed", ui.plain)} ${it.run.id} ${glyph("dot", ui.plain)} unreadable: ${it.error}`
-                }
-              />
-            ))}
-          </box>
-          {items[at] ? <RunDetail ui={ui} it={items[at]} climbed={climbed} deps={d} /> : null}
-        </box>
-      )}
-    </Frame>
-  );
-}

package/src/types.ts

@@ -1,184 +0,0 @@
-export const ROLES = [
-  "architect",
-  "verifier",
-  "worker",
-  "reviewer",
-  "ui-reviewer",
-  "artist",
-  "writer",
-  "researcher",
-] as const;
-export type Role = (typeof ROLES)[number];
-
-export type Backend = "codex" | "opencode" | "claude";
-
-/** "<model-id>#<effort>". Model ids may contain "/" (opencode providers); split at the LAST "#". */
-export type RungId = string;
-
-export function splitRung(rung: RungId): { model: string; effort: string } {
-  const i = rung.lastIndexOf("#");
-  if (i < 1 || i === rung.length - 1) throw new Error(`catherd: bad rung "${rung}", expected model#effort`);
-  return { model: rung.slice(0, i), effort: rung.slice(i + 1) };
-}
-
-export const rungOf = (model: string, effort: string): RungId => `${model}#${effort}`;
-
-export type Sandbox = "read-only" | "workspace-write" | "danger-full-access";
-
-/** Spec §4: the sandbox a Codex or opencode run of each role gets. */
-export const ROLE_SANDBOX: Record<Role, Sandbox> = {
-  architect: "read-only",
-  verifier: "danger-full-access",
-  worker: "workspace-write",
-  reviewer: "read-only",
-  "ui-reviewer": "danger-full-access",
-  artist: "workspace-write",
-  writer: "workspace-write",
-  researcher: "read-only",
-};
-
-export interface Capabilities {
-  toolCall: boolean;
-  imageIn: boolean;
-  imageOut: boolean;
-  reasoning: boolean;
-  context: number;
-}
-
-/** Spec §4: what a model must have to be offered for a role. */
-export const ROLE_NEEDS: Record<Role, Partial<Capabilities>> = {
-  architect: { toolCall: true },
-  verifier: { toolCall: true },
-  worker: { toolCall: true },
-  reviewer: { toolCall: true },
-  "ui-reviewer": { toolCall: true, imageIn: true },
-  artist: { imageOut: true },
-  writer: { toolCall: true },
-  researcher: { toolCall: true },
-};
-
-export const KINDS = ["repo_code", "terminal", "ui", "prose", "research"] as const;
-export type Kind = (typeof KINDS)[number];
-
-export const DIFFICULTIES = ["copy", "build", "logic", "hard"] as const;
-export type Difficulty = (typeof DIFFICULTIES)[number];
-
-export type ScoreDim = "repo_code" | "terminal" | "honesty";
-
-export interface Scores {
-  repo_code?: number;
-  terminal?: number;
-  honesty?: number;
-  secs_per_task?: number;
-}
-
-export interface CatalogModel {
-  id: string;
-  backend: Backend;
-  efforts: string[];
-  capabilities: Capabilities;
-}
-
-export interface CatalogEntry {
-  rung: RungId;
-  scores: Scores;
-  costRank: number;
-}
-
-export type Bars = Record<Kind, Record<Difficulty, Partial<Record<ScoreDim, number>>>>;
-
-export interface Catalog {
-  version: string;
-  models: CatalogModel[];
-  entries: CatalogEntry[];
-  bars: Bars;
-  /** unscored rung -> scored rung whose scores it borrows */
-  treatLike: Record<RungId, RungId>;
-}
-
-export interface RoleConfig {
-  enabled: boolean;
-  /** model id -> enabled efforts */
-  models: Record<string, string[]>;
-  defaultRung?: RungId;
-}
-
-export type NotifyMoment = "milestone" | "finish" | "blocked";
-
-/** Spec §8.2: false (the default) runs the vendor harness exactly as the user configured it. */
-export interface HarnessConfig {
-  isolated: boolean;
-}
-
-export interface Profile {
-  name: string;
-  objective: "cost" | "speed";
-  roles: Record<Role, RoleConfig>;
-  harness: { codex: HarnessConfig; opencode: HarnessConfig };
-  lock: { heavy: number | "cpus/2" };
-  notify: NotifyMoment[];
-  /** spec §11b: a rung's stand-in on another backend, used on a `limit` result */
-  failover?: Record<RungId, RungId>;
-  /** spec §11b: the run budget; `status` shows spend against it, `route` and `dispatch` react at 80%/100% */
-  budget?: { minutes?: number; tokens?: number; usd?: number };
-}
-
-export interface RouteDecision {
-  kind: Kind | null;
-  difficulty: Difficulty | null;
-  confidence: { kind: number | null; difficulty: number | null };
-  source: "jev" | "default";
-  rung: RungId;
-  ladder: RungId[];
-}
-
-export type ReplyStatus = "complete" | "partial" | "blocked" | "refused";
-export type RunStatus = "ok" | "failed" | "limit" | "cli-too-old" | "timeout" | "interrupted";
-
-export interface Tokens {
-  input: number;
-  cached: number;
-  output: number;
-}
-
-/** One Codex or opencode role run. Appended to <run>/runs.jsonl; the only record of it. */
-export interface RunRecord {
-  name: string;
-  role: Role;
-  backend: "codex" | "opencode";
-  rung: RungId;
-  thread: string | null;
-  status: RunStatus;
-  startedAt: string;
-  secs: number;
-  pid: number | null;
-  tokens: Tokens;
-  costUsd: number | null;
-  changedOwned: string[];
-  replyStatus: ReplyStatus | null;
-  replyWhy: string | null;
-  threadHeavy: boolean;
-  /** the harness ran isolated (spec §8.2); lets reports measure what the user's customizations cost */
-  isolated: boolean;
-  images: string[];
-  error: string | null;
-  replyPath: string;
-}
-
-export interface RunMeta {
-  id: string;
-  repo: string;
-  title: string;
-  aLines: string[];
-  createdAt: string;
-}
-
-export interface StateSnapshot {
-  head: string;
-  dirty: { path: string; owner: string | null }[];
-  running: { name: string; rung: RungId; thread: string | null; brief: string; since: string }[];
-  lastCheck: string | null;
-  next: string;
-}
-
-export const THREAD_HEAVY_INPUT = 8_000_000;

package/src/version.ts

@@ -1,7 +0,0 @@
-import { readFileSync } from "node:fs";
-
-const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")) as {
-  version: string;
-};
-
-export const VERSION: string = pkg.version;