@multiclawcli/dashboard 0.4.0 → 0.5.1

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@multiclawcli/dashboard",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "type": "module",
   "exports": {
     "./tui": {
-      "types": "./dist/tui.d.ts",
+      "types": "./dist/tui/index.d.ts",
       "default": "./dist/tui.js"
     }
   },
@@ -25,18 +25,19 @@
     "access": "public"
   },
   "dependencies": {
-    "@multiclawcli/core": "0.4.0",
+    "@multiclawcli/core": "0.5.1",
     "ink": "^8.0.0",
-    "react": "^19.3.0"
+    "react": "^19.3.1",
+    "string-width": "^8.3.0"
   },
   "devDependencies": {
-    "@types/node": "^26.6.4",
+    "@types/node": "^26.6.5",
     "@types/react": "^19.3.0",
-    "typescript": "^5.4.0",
-    "vitest": "^4.1.11"
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.4"
   },
   "scripts": {
-    "build": "tsup",
+    "build": "tsup && tsc -p tsconfig.build.json --emitDeclarationOnly --outDir dist",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage"

package/dist/tui.d.ts

@@ -1,299 +0,0 @@
-import { MultiClawConfig, EventBus, AgentStatus, MultiClawEvent, StageInfo, LeaderMessage, TurnRecord, AgentDefinition } from '@multiclawcli/core';
-
-interface AppProps {
-    config: MultiClawConfig;
-    /**
-     * Called once per turn, after that turn's orchestrator exists. The CLI uses it
-     * to attach a file log writer without the TUI depending on the CLI package.
-     */
-    onTurnStart?: (eventBus: EventBus, logDir: string) => void;
-}
-
-/**
- * Terminal geometry.
- *
- * Kept pure and separate from the components because responsive rules are the
- * part of a TUI that is easiest to get subtly wrong and hardest to eyeball. Every
- * row the console spends is budgeted here, so the arithmetic is testable rather
- * than buried in JSX.
- */
-declare const MIN_COLUMNS = 40;
-declare const MIN_ROWS = 10;
-/** Below this the roster is dropped so the stream keeps a usable width. */
-declare const COMPACT_COLUMNS = 72;
-/** The rail costs a row; it only earns one when there is vertical room. */
-declare const RAIL_MIN_ROWS = 16;
-/**
- * The most rows the pipeline rail is ever allowed to occupy.
- *
- * The rail wraps, so its height depends on how many agents the turn has and how
- * wide the terminal is. Without a cap it could eat the whole screen; with one,
- * the budget stays honest and anything past it is clipped rather than silently
- * swallowed by the body.
- */
-declare const MAX_RAIL_ROWS = 2;
-/** Enough to see the palette is a list; more would push the stream off screen. */
-declare const MAX_MENU_ROWS = 7;
-/** Queued follow-ups sit above the prompt; more than a few would crowd the stream. */
-declare const MAX_QUEUE_ROWS = 3;
-interface LayoutInput {
-    columns: number;
-    rows: number;
-    /** Zero means no turn has run yet, which swaps the body for the welcome screen. */
-    turn: number;
-    /** A modal owns the body — help or the history list. */
-    overlay: boolean;
-    /** Rows the command palette is asking for. */
-    menuRows: number;
-    /** Rows the queued follow-ups are asking for. */
-    queueRows?: number;
-    /** Whether a command result is waiting to be shown. */
-    notice: boolean;
-    /** A past turn is open for reading, which costs a banner row. */
-    viewing?: boolean;
-    /** Whether there is a leader or any stage to draw. */
-    hasRail: boolean;
-    /**
-     * Rendered widths of the rail's cells, widest first is not required — order
-     * is what the rail draws. Needed because the rail wraps: its height is a
-     * function of the content, so a flat "one row" charge under-budgets it.
-     */
-    railCells?: number[];
-}
-interface Layout {
-    columns: number;
-    rows: number;
-    compact: boolean;
-    showTeam: boolean;
-    showRail: boolean;
-    /** How many rows the rail will actually occupy once it wraps. */
-    railRows: number;
-    welcome: boolean;
-    bodyHeight: number;
-    logViewport: number;
-    teamWidth: number;
-    menuRows: number;
-    queueRows: number;
-}
-/**
- * How many rows the rail occupies given the widths of the cells it draws.
- *
- * Approximate on purpose: Yoga's own wrapping depends on margins and on how the
- * terminal renders wide glyphs, and chasing exactness here is not worth it. The
- * number is capped and the rail is clipped, so an under-count costs the last
- * chip rather than collapsing the layout.
- */
-declare function measureRailRows(cells: number[] | undefined, columns: number): number;
-declare function computeLayout(input: LayoutInput): Layout;
-
-/**
- * Per-agent log buffer cap, in characters.
- *
- * The previous web store appended output forever (`logs: a.logs + chunk`). A
- * chatty agent running for hours would grow that string without bound. The TUI
- * renders a tail window, so only the tail is worth keeping.
- */
-declare const MAX_LOG_CHARS = 8000;
-interface AgentView {
-    id: string;
-    name: string;
-    icon?: string;
-    model?: string;
-    /** Static role, from the config. Always available, even before turn one. */
-    description?: string;
-    /** Per-turn title assigned by the leader's task plan; absent until it plans. */
-    taskTitle?: string;
-    status: AgentStatus;
-    /** Wall clock at which the agent started, so its timer can tick while it runs. */
-    startedAt?: number;
-    /** Final duration, present once the agent has finished. */
-    duration?: number;
-    attempts?: number;
-    /** In-flight retry counter, present only while the agent is between attempts. */
-    retry?: {
-        attempt: number;
-        max: number;
-    };
-    error?: string;
-    logs: string;
-}
-type TuiPhase = "idle" | "running" | "complete";
-/**
- * One turn, as the panes need to see it.
- *
- * Everything that describes *a turn* lives here, and everything that describes
- * *the console* lives on {@link TuiState}. The split is what makes history
- * possible: a finished turn is just a `TurnView` kept around, and the panes take
- * a `TurnView` so they can render one without knowing which it is.
- */
-interface TurnView {
-    turn: number;
-    requirement?: string;
-    phase: TuiPhase;
-    /** Wall clock at which the turn started. */
-    startedAt?: number;
-    /** Wall clock at which the turn finished. */
-    endedAt?: number;
-    stages: StageInfo[];
-    agents: Record<string, AgentView>;
-    /**
-     * Agents that run *before* the pipeline exists (the leader), so the pipeline
-     * bar can label them without guessing. Derived from the config, not from
-     * "every agent that is not in a stage" — a configured agent that has not been
-     * scheduled yet is not a leader.
-     */
-    leaderIds: string[];
-    focusId?: string;
-    /**
-     * While true the focus pane follows whichever agent starts next. Cycling the
-     * focus by hand clears it, so the user's choice is not yanked away.
-     */
-    autoFollow: boolean;
-    /**
-     * How many lines the stream is scrolled back from the tail. Zero means the
-     * stream is live. Kept as an offset rather than an absolute index so new
-     * output arriving underneath does not shift what the user is reading.
-     */
-    scroll: number;
-    success?: boolean;
-    totalDuration?: number;
-    warning?: string;
-    /**
-     * Set when the turn ended in words rather than a pipeline: the leader answered
-     * or asked a question, so no agent ran. Distinct from `success`, because both
-     * a finished pipeline and a one-line answer are successful turns — and the
-     * console has to be able to say which one happened.
-     */
-    reply?: LeaderMessage;
-}
-/** How many finished turns the console keeps around to browse. */
-declare const MAX_HISTORY = 20;
-interface TuiState extends TurnView {
-    name: string;
-    /** Finished turns, oldest first. The live turn is `state` itself. */
-    history: TurnView[];
-    /**
-     * A finished turn opened for reading.
-     *
-     * Kept as a detached copy so scrolling and tabbing through it cannot disturb
-     * the turn that is actually running. While it is set the panes render it, and
-     * `focusId` / `scroll` edits land on it rather than on the live turn.
-     */
-    view?: TurnView;
-}
-declare const initialState: TuiState;
-type TuiAction = {
-    type: "turn:start";
-    requirement: string;
-    agents: Record<string, AgentView>;
-    leaderIds: string[];
-    startedAt: number;
-} | {
-    type: "event";
-    event: MultiClawEvent;
-} | {
-    type: "focus:cycle";
-    delta: number;
-} | {
-    type: "focus:set";
-    agentId: string;
-}
-/** Scroll the focused stream. `viewport` is needed to clamp at the tail. */
- | {
-    type: "stream:scroll";
-    delta: number;
-    viewport: number;
-}
-/** Drop the focused agent's buffered output without touching its status. */
- | {
-    type: "stream:clear";
-}
-/** Open a finished turn for reading, by its turn number. */
- | {
-    type: "view:open";
-    turn: number;
-}
-/** Go back to the live turn. */
- | {
-    type: "view:close";
-};
-declare function stripAnsi(text: string): string;
-/** Append a chunk, keeping only the last {@link MAX_LOG_CHARS} characters. */
-declare function appendLog(previous: string, chunk: string): string;
-/** Every agent that takes part in a run, in declaration order: leader first. */
-declare function plannedAgents(config: MultiClawConfig): AgentDefinition[];
-declare function leaderAgentIds(config: MultiClawConfig): string[];
-/**
- * Build the roster shown before (and between) runs.
- *
- * The orchestrator only reveals the team through `orchestration:start`, which it
- * emits *after* the leader has already run — so a console that learned its
- * agents purely from events would show an empty list until the first turn was
- * well under way. Seeding from the config makes the idle screen show the team
- * you are about to run, and gives every turn a known baseline to reset to.
- */
-declare function seedAgents(config: MultiClawConfig): Record<string, AgentView>;
-declare function createInitialState(config: MultiClawConfig): TuiState;
-declare function reduceEvent(state: TuiState, event: MultiClawEvent): TuiState;
-/**
- * The turns behind this one, as dialogue the leader can read back.
- *
- * Core has no notion of a session — an orchestrator is built per turn — so the
- * console is what carries earlier turns into the next run. Without them a bare
- * answer arrives at the leader as a requirement with nothing to answer: turn one
- * asks "which database?", turn two's requirement is the word "Postgres".
- *
- * Derived rather than tracked separately: `history` plus the turn on screen
- * *are* the finished turns, and a second copy is one more thing that could
- * disagree with what the panes show.
- *
- * Only turns that ended are carried, which makes the call site's timing
- * irrelevant: whether this is read before or after `turn:start` moves the turn
- * on screen into `history`, the set is the same.
- */
-declare function conversationTurns(state: TuiState): TurnRecord[];
-declare function tuiReducer(state: TuiState, action: TuiAction): TuiState;
-/** Roll a stage's member statuses up into one status for the pipeline bar. */
-declare function stageStatus(stage: StageInfo, agents: Record<string, AgentView>): AgentStatus;
-/** How many agents have finished, out of how many the turn will run. */
-declare function progress(turn: TurnView): {
-    done: number;
-    total: number;
-};
-/**
- * An agent's time: the live clock while it runs, the recorded duration once it
- * has stopped. Returning the *same* number after completion is what stops the
- * column from jittering when a stage ends.
- */
-declare function agentElapsed(agent: AgentView, now: number): number | undefined;
-/** The turn's time, live while running and frozen once the orchestrator reports back. */
-declare function turnElapsed(turn: TurnView, now: number): number | undefined;
-interface LogWindow {
-    lines: string[];
-    /** How many lines sit below the window. Zero means the stream is live. */
-    scrolledBack: number;
-    following: boolean;
-}
-/**
- * The slice of the focused agent's output that fits the pane.
- *
- * Clamping here as well as in the reducer keeps the window correct even when
- * the pane is resized between two scroll actions.
- */
-declare function visibleLog(turn: TurnView, viewport: number): LogWindow;
-
-interface TuiOptions {
-    config: MultiClawConfig;
-    /** Attach per-turn reporters (e.g. a file log writer) here. */
-    onTurnStart?: (eventBus: EventBus, logDir: string) => void;
-}
-/**
- * Render the interactive team console.
- *
- * Runs on the alternate screen buffer so the app owns the viewport and the
- * user's scrollback survives. The buffer is always restored — including when
- * rendering throws — otherwise the terminal is left unusable.
- */
-declare function startTui(options: TuiOptions): Promise<void>;
-
-export { type AgentView, type AppProps, COMPACT_COLUMNS, type Layout, type LayoutInput, type LogWindow, MAX_HISTORY, MAX_LOG_CHARS, MAX_MENU_ROWS, MAX_QUEUE_ROWS, MAX_RAIL_ROWS, MIN_COLUMNS, MIN_ROWS, RAIL_MIN_ROWS, type TuiAction, type TuiOptions, type TuiPhase, type TuiState, type TurnView, agentElapsed, appendLog, computeLayout, conversationTurns, createInitialState, initialState, leaderAgentIds, measureRailRows, plannedAgents, progress, reduceEvent, seedAgents, stageStatus, startTui, stripAnsi, tuiReducer, turnElapsed, visibleLog };