catherd-cli 0.2.1 → 1.0.0

package/src/tui/backends.ts

@@ -1,57 +0,0 @@
-export interface BackendStatus {
-  backend: "codex" | "opencode";
-  installed: boolean;
-  version: string | null;
-  loggedIn: boolean;
-  fix: string | null;
-}
-
-interface Result {
-  exitCode: number;
-  stdout: string;
-}
-
-const PROBES = {
-  codex: {
-    install: "npm i -g @openai/codex",
-    login: "codex login",
-    status: ["login", "status"],
-    // `codex login status` prints to stderr; its exit code is the answer.
-    loggedIn: (r: Result) => r.exitCode === 0,
-  },
-  opencode: {
-    install: "npm i -g opencode-ai",
-    login: "opencode auth login",
-    status: ["auth", "list"],
-    loggedIn: (r: Result) => r.exitCode === 0 && r.stdout.trim().length > 0,
-  },
-} as const;
-
-async function run(cmd: string, args: string[]): Promise<Result> {
-  // Bun.spawn's own PATH lookup can stay stale across calls when PATH changes mid-process
-  // (as tests do), so the binary is resolved by hand against the current PATH each time.
-  const bin = Bun.which(cmd, { PATH: process.env.PATH ?? "" });
-  if (!bin) return { exitCode: 127, stdout: "" };
-  try {
-    const proc = Bun.spawn([bin, ...args], { stdout: "pipe", stderr: "pipe" });
-    const [stdout] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text()]);
-    const exitCode = await proc.exited;
-    return { exitCode, stdout };
-  } catch {
-    return { exitCode: 127, stdout: "" };
-  }
-}
-
-async function probe(backend: "codex" | "opencode"): Promise<BackendStatus> {
-  const p = PROBES[backend];
-  const v = await run(backend, ["--version"]);
-  if (v.exitCode !== 0) return { backend, installed: false, version: null, loggedIn: false, fix: p.install };
-  const version = v.stdout.trim().split(/\s+/).at(-1)?.replace(/^v/, "") ?? null;
-  const s = await run(backend, [...p.status]);
-  const loggedIn = p.loggedIn(s);
-  return { backend, installed: true, version, loggedIn, fix: loggedIn ? null : p.login };
-}
-
-export function detectBackends(): Promise<BackendStatus[]> {
-  return Promise.all([probe("codex"), probe("opencode")]);
-}

package/src/tui/commands.ts

@@ -1,53 +0,0 @@
-import { createCliRenderer } from "@opentui/core";
-import { createRoot } from "@opentui/react";
-import { defineCommand } from "citty";
-import { createElement, type ReactNode } from "react";
-import { Dashboard } from "./dashboard.tsx";
-import { Init } from "./init.tsx";
-import { detectUi } from "./theme.ts";
-import { Watch } from "./watch.tsx";
-
-const uiArgs = {
-  plain: { type: "boolean", description: "ASCII only: a text fallback for every glyph" },
-  "reduced-motion": { type: "boolean", description: "No animation" },
-} as const;
-
-export const isBare = (rawArgs: string[]): boolean => rawArgs.every((a) => a.startsWith("-"));
-
-export async function mount(el: ReactNode, stdin: { isTTY?: boolean } = process.stdin): Promise<number> {
-  if (!stdin.isTTY) {
-    console.error(
-      "catherd: this screen needs an interactive terminal. Scripts can use the MCP tools (status, profile_get).",
-    );
-    return 1;
-  }
-  const renderer = await createCliRenderer({ exitOnCtrlC: true });
-  createRoot(renderer).render(el);
-  await new Promise<void>((resolve) => renderer.once("destroy", () => resolve()));
-  return Number(process.exitCode ?? 0);
-}
-
-/** The main command's run. citty runs it after any subcommand too, hence the isBare check.
- * Bare `catherd` opens the dashboard; Profile/Watch/Setup from there render Editor/Watch/Init
- * inline, in the same mounted tree — see dashboard.tsx. */
-export async function editorRun({ rawArgs }: { rawArgs: string[] }): Promise<void> {
-  if (!isBare(rawArgs)) return;
-  process.exitCode = await mount(createElement(Dashboard, { ui: detectUi(rawArgs) }));
-}
-
-export const initCommand = defineCommand({
-  meta: { name: "init", description: "First run: the Jev key, your backends, and a profile" },
-  args: uiArgs,
-  async run({ rawArgs }) {
-    const code = await mount(createElement(Init, { ui: detectUi(rawArgs) }));
-    process.exitCode = process.exitCode || code;
-  },
-});
-
-export const watchCommand = defineCommand({
-  meta: { name: "watch", description: "Live view of running and recent runs" },
-  args: uiArgs,
-  async run({ rawArgs }) {
-    process.exitCode = await mount(createElement(Watch, { ui: detectUi(rawArgs) }));
-  },
-});

package/src/tui/dashboard.tsx

@@ -1,245 +0,0 @@
-import { readFileSync } from "node:fs";
-import { TextAttributes } from "@opentui/core";
-import { useKeyboard, useRenderer } from "@opentui/react";
-import { useEffect, useState } from "react";
-import { countLinkedAgents } from "../profile/agents.ts";
-import { activeProfileName } from "../profile/profile.ts";
-import { loadCatalog } from "../routing/catalog.ts";
-import { jevKey } from "../routing/jev.ts";
-import type { Catalog } from "../types.ts";
-import { type BackendStatus, detectBackends } from "./backends.ts";
-import { Editor } from "./editor.tsx";
-import { Init } from "./init.tsx";
-import { dot, type DotState, dotTint, glyph, type Mood, tint, type Ui } from "./theme.ts";
-import { DetailPane, Frame, ListLine, Wordmark } from "./ui.tsx";
-import { Watch } from "./watch.tsx";
-
-export interface DashboardDeps {
-  detectBackends: () => Promise<BackendStatus[]>;
-  jevKey: () => string | null;
-  loadCatalog: () => Catalog;
-  countLinkedAgents: () => number;
-  activeProfileName: () => string;
-  version: string;
-}
-
-function readVersion(): string {
-  try {
-    const pkg = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf8")) as {
-      version: string;
-    };
-    return pkg.version;
-  } catch {
-    return "0.0.0";
-  }
-}
-
-const dashboardDeps: DashboardDeps = {
-  detectBackends,
-  jevKey,
-  loadCatalog,
-  countLinkedAgents,
-  activeProfileName,
-  version: readVersion(),
-};
-
-type Screen = "dashboard" | "profile" | "watch" | "setup";
-
-interface Action {
-  screen: Screen | "refresh" | "exit";
-  label: string;
-  subtitle: string;
-  description: string;
-}
-
-const ACTIONS: Action[] = [
-  {
-    screen: "profile",
-    label: "Profile",
-    subtitle: "roles, routing, budget",
-    description: "Edit which models fill each role, and how catherd escalates between them.",
-  },
-  {
-    screen: "watch",
-    label: "Watch runs",
-    subtitle: "live and recent runs",
-    description: "See what is running now, and how past runs went.",
-  },
-  {
-    screen: "setup",
-    label: "Setup",
-    subtitle: "Jev key & backends",
-    description: "Re-run first-time setup: the Jev key, Codex/opencode, and a starting profile.",
-  },
-  {
-    screen: "refresh",
-    label: "Refresh catalog",
-    subtitle: "reload models & scores",
-    description: "Re-read the model catalog from disk, in case it changed underneath catherd.",
-  },
-  {
-    screen: "exit",
-    label: "Exit",
-    subtitle: "quit catherd",
-    description: "Leave catherd without changing anything.",
-  },
-];
-
-interface Status {
-  backends: BackendStatus[];
-  jev: boolean;
-  agents: number;
-  active: string;
-}
-
-function backendState(b: BackendStatus | undefined, plain: boolean): { state: DotState; text: string } {
-  if (!b || !b.installed) return { state: "missing", text: "not installed" };
-  if (!b.loggedIn) {
-    return {
-      state: "warn",
-      text: b.version ? `${b.version} ${glyph("dot", plain)} not logged in` : "not logged in",
-    };
-  }
-  return { state: "ready", text: b.version ?? "ready" };
-}
-
-function StatusRow({ ui, state, name, value }: { ui: Ui; state: DotState; name: string; value: string }) {
-  return (
-    <text wrapMode="none" truncate>
-      <span fg={dotTint(state, ui.depth)}>{dot(state, ui.plain)}</span> {name.padEnd(16)}
-      <span attributes={TextAttributes.DIM}>{value}</span>
-    </text>
-  );
-}
-
-function mood(status: Status | null): Mood {
-  if (!status) return "working";
-  const trouble = status.backends.some((b) => !b.installed || !b.loggedIn) || !status.jev;
-  return trouble ? "waiting" : "good";
-}
-
-/** The bare `catherd` screen: an actions menu on the left, and the selected action's detail
- * plus a live status snapshot on the right. Selecting Profile/Watch/Setup swaps this same
- * mounted tree for that screen, in place — no new process, no re-mount of the renderer. */
-export function Dashboard({ ui, deps = {} }: { ui: Ui; deps?: Partial<DashboardDeps> }) {
-  const d = { ...dashboardDeps, ...deps };
-  const renderer = useRenderer();
-  const [cursor, setCursor] = useState(0);
-  const [status, setStatus] = useState<Status | null>(null);
-  const [screen, setScreen] = useState<Screen>("dashboard");
-  const [note, setNote] = useState("");
-
-  const refresh = () => {
-    d.detectBackends().then(
-      (backends) =>
-        setStatus({
-          backends,
-          jev: d.jevKey() !== null,
-          agents: d.countLinkedAgents(),
-          active: d.activeProfileName(),
-        }),
-      () => setStatus({ backends: [], jev: false, agents: 0, active: d.activeProfileName() }),
-    );
-  };
-
-  // spec: no new network calls on every keystroke — backends are probed once on mount, and
-  // again only when the user asks for it with `r`.
-  useEffect(refresh, []);
-
-  const activate = () => {
-    const a = ACTIONS[cursor];
-    if (!a) return;
-    if (a.screen === "exit") renderer.destroy();
-    else if (a.screen === "refresh") {
-      d.loadCatalog();
-      setNote("Catalog reloaded.");
-    } else setScreen(a.screen);
-  };
-
-  useKeyboard((key) => {
-    if (screen !== "dashboard") return;
-    if (key.name === "up") setCursor((v) => Math.max(0, v - 1));
-    else if (key.name === "down") setCursor((v) => Math.min(ACTIONS.length - 1, v + 1));
-    else if (key.name === "return") activate();
-    else if (key.sequence === "r") refresh();
-    else if (key.sequence === "q") renderer.destroy();
-  });
-
-  if (screen === "profile") return <Editor ui={ui} />;
-  if (screen === "watch") return <Watch ui={ui} />;
-  if (screen === "setup") return <Init ui={ui} />;
-
-  const a = ACTIONS[cursor] as Action;
-  const codex = status
-    ? backendState(
-        status.backends.find((b) => b.backend === "codex"),
-        ui.plain,
-      )
-    : null;
-  const opencode = status
-    ? backendState(
-        status.backends.find((b) => b.backend === "opencode"),
-        ui.plain,
-      )
-    : null;
-
-  return (
-    <Frame
-      ui={ui}
-      title="catherd"
-      hint={`${glyph("keys", ui.plain)} navigate   Enter open   r refresh   q exit`}
-      above={<Wordmark ui={ui} mood={mood(status)} suffix={d.version} />}
-    >
-      <box style={{ flexDirection: "row" }}>
-        <box style={{ flexDirection: "column", width: 22 }}>
-          <text fg={tint("pink", ui.depth)} attributes={TextAttributes.BOLD}>
-            ACTIONS
-          </text>
-          {ACTIONS.map((act, i) => (
-            <ListLine key={act.label} ui={ui} selected={i === cursor} text={act.label} />
-          ))}
-        </box>
-        <DetailPane ui={ui} heading="SELECTED ACTION" title={a.label} subtitle={a.subtitle}>
-          <text attributes={TextAttributes.DIM} wrapMode="word">
-            {a.description}
-          </text>
-          <text> </text>
-          <text fg={tint("pink", ui.depth)} attributes={TextAttributes.BOLD}>
-            CURRENT SETUP
-          </text>
-          {status ? (
-            <>
-              <StatusRow
-                ui={ui}
-                state={status.jev ? "ready" : "missing"}
-                name="Jev key"
-                value={status.jev ? "set" : "missing"}
-              />
-              <StatusRow ui={ui} state={codex?.state ?? "missing"} name="Codex" value={codex?.text ?? ""} />
-              <StatusRow
-                ui={ui}
-                state={opencode?.state ?? "missing"}
-                name="opencode"
-                value={opencode?.text ?? ""}
-              />
-              <StatusRow
-                ui={ui}
-                state={status.agents > 0 ? "ready" : "warn"}
-                name="Claude agents"
-                value={`${status.agents} linked`}
-              />
-              <StatusRow ui={ui} state="ready" name="Active profile" value={status.active} />
-            </>
-          ) : (
-            <text attributes={TextAttributes.DIM}>checking…</text>
-          )}
-          {note ? (
-            <text fg={tint("pink", ui.depth)} wrapMode="none" truncate>
-              {note}
-            </text>
-          ) : null}
-        </DetailPane>
-      </box>
-    </Frame>
-  );
-}

package/src/tui/editor.tsx

@@ -1,214 +0,0 @@
-import { useKeyboard, useRenderer } from "@opentui/react";
-import { useEffect, useState } from "react";
-import { type HarnessCost, harnessCosts } from "../core/harness.ts";
-import { listRuns } from "../core/runstore.ts";
-import {
-  activeProfileName,
-  defaultProfile,
-  listProfiles,
-  loadProfile,
-  validateProfile,
-} from "../profile/profile.ts";
-import { loadCatalog } from "../routing/catalog.ts";
-import type { Catalog, Profile } from "../types.ts";
-import { type BackendStatus, detectBackends } from "./backends.ts";
-import { matrixHint, Matrix } from "./matrix.tsx";
-import { deleteProfile, nameError, saveAndActivate } from "./profiles.ts";
-import { glyph, tint, type Ui } from "./theme.ts";
-import { CatSpinner, Frame } from "./ui.tsx";
-
-export interface EditorDeps {
-  loadCatalog: () => Catalog;
-  detectBackends: () => Promise<BackendStatus[]>;
-  harnessCosts: () => HarnessCost[];
-  save: (p: Profile, c: Catalog) => void;
-}
-
-const editorDeps: EditorDeps = {
-  loadCatalog,
-  detectBackends,
-  harnessCosts: () => harnessCosts(listRuns().map((r) => r.dir)),
-  save: saveAndActivate,
-};
-
-type Ask = "new" | "copy" | "delete" | "quit" | null;
-
-const extraHint = (plain: boolean) =>
-  `p next profile ${glyph("dot", plain)} n new ${glyph("dot", plain)} c copy ${glyph("dot", plain)} x delete`;
-
-function openBook(): { profiles: Profile[]; idx: number } {
-  const names = listProfiles();
-  const profiles = names.length > 0 ? names.map((n) => loadProfile(n)) : [defaultProfile()];
-  const active = activeProfileName();
-  return {
-    profiles,
-    idx: Math.max(
-      0,
-      profiles.findIndex((p) => p.name === active),
-    ),
-  };
-}
-
-export function Editor({ ui, deps = {} }: { ui: Ui; deps?: Partial<EditorDeps> }) {
-  const d = { ...editorDeps, ...deps };
-  const renderer = useRenderer();
-  const exit = () => renderer.destroy();
-  const [catalog, setCatalog] = useState(d.loadCatalog);
-  const [costs] = useState(d.harnessCosts);
-  const [backends, setBackends] = useState<BackendStatus[] | null>(null);
-  const [book, setBook] = useState(openBook);
-  const [active, setActive] = useState(activeProfileName);
-  const [dirty, setDirty] = useState<ReadonlySet<string>>(new Set());
-  const [errors, setErrors] = useState<string[]>([]);
-  const [note, setNote] = useState("");
-  const [ask, setAsk] = useState<Ask>(null);
-  const [showHelp, setShowHelp] = useState(false);
-  const profile = book.profiles[book.idx] as Profile;
-  const pink = tint("pink", ui.depth);
-
-  useEffect(() => {
-    d.detectBackends().then(setBackends, () => setBackends([]));
-  }, []);
-
-  const mark = (name: string, on: boolean) => {
-    const next = new Set(dirty);
-    if (on) next.add(name);
-    else next.delete(name);
-    setDirty(next);
-  };
-
-  const put = (p: Profile) => {
-    setBook({ profiles: book.profiles.map((x, i) => (i === book.idx ? p : x)), idx: book.idx });
-    mark(p.name, true);
-    setErrors([]);
-    setNote("");
-  };
-
-  const save = () => {
-    const errs = validateProfile(profile, catalog);
-    setErrors(errs);
-    if (errs.length > 0) return;
-    d.save(profile, catalog);
-    mark(profile.name, false);
-    setActive(profile.name);
-    setNote(`Saved ${profile.name}; it is active now. New Claude Code sessions get its agents.`);
-  };
-
-  const add = (name: string) => {
-    const err = nameError(
-      name,
-      book.profiles.map((p) => p.name),
-    );
-    setAsk(null);
-    if (err) {
-      setNote(err);
-      return;
-    }
-    const base = ask === "new" ? defaultProfile() : structuredClone(profile);
-    setBook({ profiles: [...book.profiles, { ...base, name }], idx: book.profiles.length });
-    mark(name, true);
-    setNote("");
-  };
-
-  const remove = () => {
-    if (book.profiles.length === 1) {
-      setNote("Keep at least one profile.");
-      return;
-    }
-    try {
-      if (listProfiles().includes(profile.name)) deleteProfile(profile.name);
-    } catch (e) {
-      setNote((e as Error).message);
-      return;
-    }
-    mark(profile.name, false);
-    setBook({ profiles: book.profiles.filter((_, i) => i !== book.idx), idx: 0 });
-    setNote(`Deleted ${profile.name}.`);
-  };
-
-  const onKey = (input: string) => {
-    setNote("");
-    if (input === "p") {
-      setBook({ ...book, idx: (book.idx + 1) % book.profiles.length });
-      setErrors([]);
-    } else if (input === "n") setAsk("new");
-    else if (input === "c") setAsk("copy");
-    else if (input === "x") setAsk("delete");
-  };
-
-  useKeyboard((key) => {
-    if (ask === "new" || ask === "copy") {
-      if (key.name === "escape") setAsk(null);
-      return;
-    }
-    if (ask === "quit") {
-      if (key.sequence === "q") exit();
-      setAsk(null);
-      return;
-    }
-    if (ask === "delete") {
-      if (key.sequence === "y") remove();
-      setAsk(null);
-    }
-  });
-
-  const sep = ` ${glyph("dot", ui.plain)} `;
-  const title = [
-    `profile ${profile.name}`,
-    `${book.idx + 1}/${book.profiles.length}`,
-    profile.name === active ? "active" : null,
-    dirty.has(profile.name) ? "unsaved" : null,
-  ]
-    .filter(Boolean)
-    .join(sep);
-
-  return (
-    <Frame ui={ui} title={title} hint={matrixHint(ui, "save", showHelp, extraHint(ui.plain))}>
-      {backends === null ? (
-        <CatSpinner ui={ui} label="sniffing out codex and opencode" />
-      ) : (
-        <Matrix
-          key={profile.name}
-          ui={ui}
-          profile={profile}
-          catalog={catalog}
-          backends={backends}
-          costs={costs}
-          errors={errors}
-          reloadCatalog={d.loadCatalog}
-          onChange={put}
-          onCatalog={setCatalog}
-          onSubmit={save}
-          onQuit={() => (dirty.size > 0 ? setAsk("quit") : exit())}
-          onKey={onKey}
-          active={ask === null}
-          onToggleHelp={() => setShowHelp((v) => !v)}
-        />
-      )}
-      {ask === "new" || ask === "copy" ? (
-        <box style={{ flexDirection: "row" }}>
-          <text>
-            {ask === "new" ? "Name for the new profile: " : `Name for the copy of ${profile.name}: `}
-          </text>
-          {/* React 19's DOMAttributes adds a DOM `onSubmit(event: SubmitEvent)` overload to every
-              intrinsic element, including OpenTUI's non-DOM <input>; `as any` sidesteps that
-              phantom overload rather than fighting it with a full-signature cast. */}
-          <input focused onSubmit={add as any} />
-        </box>
-      ) : null}
-      {ask === "delete" ? (
-        <text fg={pink}>{`Delete profile ${profile.name}? y deletes it, any other key keeps it.`}</text>
-      ) : null}
-      {ask === "quit" ? (
-        <text fg={pink} wrapMode="none" truncate>
-          {`Unsaved changes in ${[...dirty].join(", ")}. q quits without saving, any other key stays.`}
-        </text>
-      ) : null}
-      {note ? (
-        <text wrapMode="none" truncate>
-          {note}
-        </text>
-      ) : null}
-    </Frame>
-  );
-}