multiarena 0.1.0 → 0.1.3

package/dist/ui/components/DeliberationView.js

@@ -0,0 +1,81 @@
+import React from "react";
+import { Box, Text } from "ink";
+import { roundLabel } from "../../core/deliberation.js";
+const ROLE_COLORS = {
+    draft: "cyan",
+    revise: "yellow",
+    polish: "green",
+    review: "magenta",
+};
+function spinner(frame) {
+    const chars = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+    return chars[frame % chars.length] ?? ".";
+}
+export const DeliberationView = ({ progress, document, rounds, scrollOffset = 0 }) => {
+    const role = progress.role ?? "draft";
+    const roleColor = ROLE_COLORS[role];
+    const isActive = progress.type !== "done" && progress.type !== "error";
+    const isDone = progress.type === "done";
+    const spin = spinner(Date.now() % 10);
+    const allLines = document ? document.split("\n") : [];
+    const lines = allLines.slice(scrollOffset);
+    // Count total changes across all rounds
+    const totalChanges = rounds.reduce((sum, r) => sum + (r.changeCount ?? 0), 0);
+    return (React.createElement(Box, { flexDirection: "column", flexGrow: 1, padding: 1 },
+        React.createElement(Box, { flexDirection: "row" },
+            React.createElement(Text, { bold: true }, isDone
+                ? `审议完成 · ${rounds.length} 轮 · ${totalChanges} 处修改`
+                : isActive
+                    ? `第 ${progress.round}/${progress.totalRounds} 轮：${progress.modelName ?? "?"} (${roundLabel(role)})`
+                    : "审议出错")),
+        React.createElement(Box, { flexDirection: "row", marginY: 1 }, rounds.map((r, i) => {
+            const isPast = isDone || r.round < progress.round;
+            const isCurrent = !isDone && r.round === progress.round;
+            return (React.createElement(Box, { key: i, marginRight: 2, flexDirection: "column" },
+                React.createElement(Box, { flexDirection: "row" },
+                    React.createElement(Text, { color: isPast ? "green" : isCurrent ? roleColor : "gray" },
+                        isPast ? "✓" : isCurrent ? spin : "○",
+                        " ",
+                        roundLabel(r.role))),
+                React.createElement(Box, { flexDirection: "row" },
+                    React.createElement(Text, { dimColor: true }, r.modelName))));
+        })),
+        isActive && (React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { color: roleColor },
+                roundLabel(role),
+                "\u4E2D \u2014 ",
+                progress.modelName,
+                " \u2014 \u6B63\u5728\u751F\u6210\u2026"))),
+        progress.type === "error" && (React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { color: "red" },
+                "\u9519\u8BEF\uFF1A",
+                progress.error))),
+        isDone && rounds.length > 0 && (React.createElement(Box, { flexDirection: "column", marginBottom: 1 },
+            React.createElement(Text, { bold: true }, "\u2500\u2500 \u5BA1\u8BAE\u8FC7\u7A0B \u2500\u2500"),
+            rounds.map((r) => {
+                const hasChanges = (r.changeCount ?? 0) > 0;
+                return (React.createElement(Box, { key: r.round, flexDirection: "column", marginTop: 1 },
+                    React.createElement(Text, null,
+                        React.createElement(Text, { color: "cyan" },
+                            r.round,
+                            "."),
+                        " ",
+                        React.createElement(Text, { bold: true }, r.modelName),
+                        React.createElement(Text, { color: "gray" },
+                            "\uFF08",
+                            roundLabel(r.role),
+                            "\uFF09"),
+                        hasChanges && (React.createElement(Text, { color: "yellow" },
+                            " \u2014 ",
+                            r.changeCount,
+                            " \u5904\u4FEE\u6539")),
+                        !hasChanges && r.role !== "draft" && (React.createElement(Text, { color: "gray" }, " \u2014 \u65E0\u4FEE\u6539"))),
+                    r.changeSamples && r.changeSamples.length > 0 && (React.createElement(Box, { flexDirection: "column", marginLeft: 2 }, r.changeSamples.map((s, j) => (React.createElement(Text, { key: j, dimColor: true }, `  ${s}`)))))));
+            }),
+            React.createElement(Text, null, " "))),
+        isDone && (React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { bold: true, color: "green" }, "\u2500\u2500 \u6700\u7EC8\u6587\u6863 \u2500\u2500"))),
+        React.createElement(Box, { flexDirection: "column", flexGrow: 1 },
+            lines.length === 0 && isActive && (React.createElement(Text, { dimColor: true }, "\u7B49\u5F85\u8F93\u51FA\u2026")),
+            lines.map((line, i) => (React.createElement(Text, { key: i }, line))))));
+};

package/dist/ui/components/InputBar.d.ts

@@ -1,5 +1,8 @@
 import React from "react";
+import type { ModelState } from "../../core/types.js";
 interface Props {
+    models: ModelState[];
+    activeModelName: string | null;
     prefix: string;
     value: string;
     onChange: (value: string) => void;

package/dist/ui/components/InputBar.js

@@ -1,11 +1,21 @@
 import React from "react";
 import { Box, Text } from "ink";
 import TextInput from "ink-text-input";
-export const InputBar = ({ prefix, value, onChange, onSubmit }) => (React.createElement(Box, { height: 1, flexDirection: "row" },
-    React.createElement(Box, { marginRight: 1 },
-        React.createElement(Text, { color: "green" },
-            "[",
-            prefix,
-            "]")),
-    React.createElement(Text, null, "> "),
-    React.createElement(TextInput, { value: value, onChange: onChange, onSubmit: onSubmit })));
+export const InputBar = ({ models, activeModelName, prefix, value, onChange, onSubmit, }) => (React.createElement(Box, { flexDirection: "column" },
+    React.createElement(Box, { height: 1, flexDirection: "row" },
+        models.map((m) => {
+            const isTargeted = activeModelName === null || activeModelName === m.name;
+            return (React.createElement(Box, { key: m.name, marginRight: 1 },
+                React.createElement(Text, { color: isTargeted && !m.muted ? "green" : "gray", bold: isTargeted }, m.name),
+                isTargeted && !m.muted && React.createElement(Text, { color: "yellow" }, " \u25CF"),
+                m.muted && React.createElement(Text, { color: "gray" }, " [muted]")));
+        }),
+        React.createElement(Text, { dimColor: true }, " \u2014 Shift+Tab:/team Tab:model d:compare m:mute r:reset q:quit \u2191\u2193:scroll/history Esc:cancel")),
+    React.createElement(Box, { height: 1, flexDirection: "row" },
+        React.createElement(Box, { marginRight: 1 },
+            React.createElement(Text, { color: "green" },
+                "[",
+                prefix,
+                "]")),
+        React.createElement(Text, null, "> "),
+        React.createElement(TextInput, { value: value, onChange: onChange, onSubmit: onSubmit }))));

package/dist/ui/components/ModelDetail.js

@@ -1,13 +1,25 @@
 import React from "react";
 import { Box, Text } from "ink";
+import { formatTokens } from "./formatTokens.js";
 export const ModelDetail = ({ model, scrollOffset }) => {
-    const allLines = model.buffer.split("\n");
+    const allLines = model.buffer ? model.buffer.split("\n") : [];
     const visibleLines = allLines.slice(scrollOffset);
-    return (React.createElement(Box, { flexDirection: "column", flexGrow: 1 },
-        visibleLines.length === 0 && !model.isStreaming && (React.createElement(Text, { dimColor: true }, "No output yet")),
+    const totalTokens = model.usage.input + model.usage.output;
+    const isEmpty = allLines.length === 0 || (allLines.length === 1 && allLines[0].trim() === "");
+    return (React.createElement(Box, { flexDirection: "column", flexGrow: 1, borderStyle: "single", borderColor: "gray" },
+        React.createElement(Text, { bold: true }, model.name),
+        isEmpty && !model.isStreaming && (React.createElement(Text, { dimColor: true }, "No output")),
         visibleLines.map((line, i) => {
             const isError = /^\[?(?:Error|error)[:\]]/.test(line);
             return (React.createElement(Text, { key: scrollOffset + i, color: isError ? "red" : undefined }, line || " "));
         }),
-        model.isStreaming && React.createElement(Text, { color: "gray" }, "\u258B")));
+        model.isStreaming && React.createElement(Text, { color: "gray" }, "\u258B"),
+        React.createElement(Text, { dimColor: true },
+            formatTokens(totalTokens),
+            "/",
+            formatTokens(model.contextLimit),
+            " \u00B7 ",
+            isEmpty ? 0 : allLines.length,
+            " lines \u00B7 ",
+            model.isStreaming ? "streaming..." : "done")));
 };

package/dist/ui/components/OutputArea.d.ts

@@ -1,5 +1,7 @@
 import React from "react";
 import type { ModelState } from "../../core/types.js";
+import type { DeliberationProgress } from "../../core/deliberation.js";
+import { type RoundSummary } from "./DeliberationView.js";
 interface Props {
     models: ModelState[];
     targetMode: {
@@ -10,6 +12,12 @@ interface Props {
     };
     scrollOffsets: Record<string, number>;
     comparisonModel?: string | null;
+    terminalWidth: number;
+    deliberationProgress?: DeliberationProgress | null;
+    deliberationDocument?: string;
+    deliberationRounds?: RoundSummary[];
+    teamMode?: boolean;
+    deliberationScrollOffset?: number;
 }
 export declare const OutputArea: React.FC<Props>;
 export {};

package/dist/ui/components/OutputArea.js

@@ -2,9 +2,39 @@ import React from "react";
 import { Box, Text } from "ink";
 import { BroadcastSummary } from "./BroadcastSummary.js";
 import { ModelDetail } from "./ModelDetail.js";
-export const OutputArea = ({ models, targetMode, scrollOffsets, comparisonModel, }) => {
+import { DeliberationView } from "./DeliberationView.js";
+export const OutputArea = ({ models, targetMode, scrollOffsets, comparisonModel, terminalWidth, deliberationProgress, deliberationDocument, deliberationRounds, teamMode, deliberationScrollOffset = 0, }) => {
+    // ── Team mode ──────────────────────────────────────────────────
+    if (teamMode) {
+        // During active deliberation (running): always show deliberation view
+        const isDeliberating = deliberationProgress &&
+            deliberationProgress.type !== "done" &&
+            deliberationProgress.type !== "error";
+        if (isDeliberating) {
+            return (React.createElement(DeliberationView, { progress: deliberationProgress, scrollOffset: deliberationScrollOffset, document: deliberationDocument ?? "", rounds: deliberationRounds ?? [] }));
+        }
+        // Team overview (broadcast target): show deliberation result or idle prompt
+        if (targetMode.type === "broadcast") {
+            if (deliberationProgress) {
+                return (React.createElement(DeliberationView, { progress: deliberationProgress, document: deliberationDocument ?? "", rounds: deliberationRounds ?? [], scrollOffset: deliberationScrollOffset }));
+            }
+            return (React.createElement(Box, { flexDirection: "column", flexGrow: 1, padding: 1 },
+                React.createElement(Text, { bold: true }, "\u56E2\u961F\u6A21\u5F0F"),
+                React.createElement(Text, null, " "),
+                React.createElement(Text, null, "\u8F93\u5165\u4EFB\u52A1\u63CF\u8FF0\u5373\u53EF\u542F\u52A8\u591A\u6A21\u578B\u63A5\u529B\u5BA1\u8BAE\u3002"),
+                React.createElement(Text, { dimColor: true }, "Tab \u53EF\u5207\u6362\u5230\u7279\u5B9A\u6A21\u578B\u79C1\u804A\u3002Shift+Tab \u8FD4\u56DE\u5E7F\u64AD\u6A21\u5F0F\u3002")));
+        }
+        // Team directed: Tab drilled into a specific model — show its detail
+        const teamModel = models.find((m) => m.name === targetMode.modelName);
+        if (teamModel) {
+            return (React.createElement(ModelDetail, { model: teamModel, scrollOffset: scrollOffsets[teamModel.name] ?? 0 }));
+        }
+        return (React.createElement(Box, { flexGrow: 1 },
+            React.createElement(Text, null, "No model selected")));
+    }
+    // ── Not team mode ──────────────────────────────────────────────
     if (targetMode.type === "broadcast") {
-        return React.createElement(BroadcastSummary, { models: models });
+        return React.createElement(BroadcastSummary, { models: models, terminalWidth: terminalWidth });
     }
     const activeModel = models.find((m) => m.name === targetMode.modelName);
     if (!activeModel) {
@@ -19,10 +49,8 @@ export const OutputArea = ({ models, targetMode, scrollOffsets, comparisonModel,
         }
         return (React.createElement(Box, { flexDirection: "row", flexGrow: 1 },
             React.createElement(Box, { flexDirection: "column", flexGrow: 1, marginRight: 1 },
-                React.createElement(Text, { bold: true }, activeModel.name),
                 React.createElement(ModelDetail, { model: activeModel, scrollOffset: scrollOffsets[activeModel.name] ?? 0 })),
             React.createElement(Box, { flexDirection: "column", flexGrow: 1 },
-                React.createElement(Text, { bold: true }, compModel.name),
                 React.createElement(ModelDetail, { model: compModel, scrollOffset: scrollOffsets[compModel.name] ?? 0 }))));
     }
     return React.createElement(ModelDetail, { model: activeModel, scrollOffset: scrollOffsets[activeModel.name] ?? 0 });

package/dist/ui/components/formatTokens.d.ts

@@ -0,0 +1 @@
+export declare function formatTokens(n: number): string;

package/dist/ui/components/formatTokens.js

@@ -0,0 +1,7 @@
+export function formatTokens(n) {
+    if (n >= 1_000_000)
+        return `${(n / 1_000_000).toFixed(1)}M`;
+    if (n >= 1_000)
+        return `${Math.round(n / 1_000)}K`;
+    return String(n);
+}

package/dist/ui/modeTransitions.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Mode-transition decision functions for the App keyboard handler.
+ *
+ * Design: two top-level modes (Broadcast / Team), each with an overview
+ * and drill-down to individual model chats. Shift+Tab toggles modes;
+ * Tab cycles targets within the current mode; Esc returns to overview.
+ *
+ *   Broadcast overview  ←── Esc ──  Broadcast directed (model N)
+ *        ↑  ↓ Tab                       ↑  ↓ Tab
+ *   Team overview       ←── Esc ──  Team directed (model N)
+ *        ↑  ↓ Shift+Tab
+ */
+export interface ModeState {
+    teamMode: boolean;
+    /** idle = no deliberation; running = rounds in progress; done = completed; error = aborted */
+    deliberationStatus: "idle" | "running" | "done" | "error";
+    comparisonModel: string | null;
+    comparisonFromBroadcast: boolean;
+}
+export interface TabResult {
+    /** Cycle the target within the current mode. */
+    cycleTarget: boolean;
+    clearComparison: boolean;
+}
+/**
+ * Tab cycles the target within the current mode (overview → model1 →
+ * model2 → … → overview). It never changes teamMode — Shift+Tab is
+ * the only way to toggle between broadcast and team.
+ */
+export declare function reduceTab(_state: ModeState): TabResult;
+export interface ShiftTabResult {
+    teamMode: boolean;
+    /** If true, the caller should set targetMode to broadcast (overview). */
+    goToOverview: boolean;
+    clearComparison: boolean;
+    /** If true, reset deliberation UI state (entering team mode fresh). */
+    resetDeliberation: boolean;
+}
+/** Toggle team/broadcast. Only works from overview. Entering a mode always lands on its overview. */
+export declare function reduceShiftTab(state: ModeState, isOverview: boolean): ShiftTabResult | null;
+export interface EscapeResult {
+    teamMode: boolean;
+    comparisonModel: string | null;
+    comparisonFromBroadcast: boolean;
+    /** Go to the current mode's overview (broadcast target). */
+    goToOverview: boolean;
+    abortDeliberation: boolean;
+    resetDeliberation: boolean;
+    restoreBroadcast: boolean;
+}
+/**
+ * Escape returns to the current mode's overview, or exits comparison /
+ * aborts a running deliberation. It never toggles teamMode.
+ */
+export declare function reduceEscape(state: ModeState, isDeliberating: boolean): EscapeResult;
+export interface KeyDResult {
+    comparisonModel: string | null;
+    comparisonFromBroadcast: boolean;
+    setDirectedTarget: string | null;
+}
+export declare function reduceKeyD(state: ModeState, unmutedNames: string[], currentDirectedTarget: string | null): KeyDResult;
+/** Build a ModeState snapshot from UI state so the pure decision
+ *  functions can drive the keyboard handler. */
+export declare function buildModeState(params: {
+    teamMode: boolean;
+    deliberationProgress: {
+        type: string;
+    } | null;
+    comparisonModel: string | null;
+    comparisonFromBroadcast: boolean;
+}): ModeState;
+export type SubmitInTeamAction = "deliberate" | "route_normally" | "block";
+/**
+ * In team overview: submit starts deliberation (idle or after a previous one).
+ * In team directed (Tab-ed to a model): submit routes as a directed message.
+ * Running deliberation: block.
+ */
+export declare function reduceSubmitInTeam(state: ModeState, isOverview: boolean): {
+    action: SubmitInTeamAction;
+};

package/dist/ui/modeTransitions.js

@@ -0,0 +1,176 @@
+/**
+ * Mode-transition decision functions for the App keyboard handler.
+ *
+ * Design: two top-level modes (Broadcast / Team), each with an overview
+ * and drill-down to individual model chats. Shift+Tab toggles modes;
+ * Tab cycles targets within the current mode; Esc returns to overview.
+ *
+ *   Broadcast overview  ←── Esc ──  Broadcast directed (model N)
+ *        ↑  ↓ Tab                       ↑  ↓ Tab
+ *   Team overview       ←── Esc ──  Team directed (model N)
+ *        ↑  ↓ Shift+Tab
+ */
+/**
+ * Tab cycles the target within the current mode (overview → model1 →
+ * model2 → … → overview). It never changes teamMode — Shift+Tab is
+ * the only way to toggle between broadcast and team.
+ */
+export function reduceTab(_state) {
+    return { cycleTarget: true, clearComparison: true };
+}
+/** Toggle team/broadcast. Only works from overview. Entering a mode always lands on its overview. */
+export function reduceShiftTab(state, isOverview) {
+    if (!isOverview)
+        return null;
+    const next = !state.teamMode;
+    return {
+        teamMode: next,
+        goToOverview: true,
+        clearComparison: true,
+        resetDeliberation: next, // entering team mode resets stale deliberation
+    };
+}
+/**
+ * Escape returns to the current mode's overview, or exits comparison /
+ * aborts a running deliberation. It never toggles teamMode.
+ */
+export function reduceEscape(state, isDeliberating) {
+    // ── Team mode ──────────────────────────────────────────────
+    if (state.teamMode) {
+        if (state.deliberationStatus === "done") {
+            // Stay in team mode, go to overview (preserve result)
+            return {
+                teamMode: true,
+                comparisonModel: null,
+                comparisonFromBroadcast: false,
+                goToOverview: true,
+                abortDeliberation: false,
+                resetDeliberation: false,
+                restoreBroadcast: false,
+            };
+        }
+        if (state.deliberationStatus === "running") {
+            return {
+                teamMode: true,
+                comparisonModel: null,
+                comparisonFromBroadcast: false,
+                goToOverview: true,
+                abortDeliberation: isDeliberating,
+                resetDeliberation: true,
+                restoreBroadcast: false,
+            };
+        }
+        // Team idle — go to overview
+        return {
+            teamMode: true,
+            comparisonModel: null,
+            comparisonFromBroadcast: false,
+            goToOverview: true,
+            abortDeliberation: false,
+            resetDeliberation: false,
+            restoreBroadcast: false,
+        };
+    }
+    // ── Comparison mode ────────────────────────────────────────
+    if (state.comparisonModel !== null) {
+        return {
+            teamMode: false,
+            comparisonModel: null,
+            comparisonFromBroadcast: false,
+            goToOverview: true,
+            abortDeliberation: false,
+            resetDeliberation: false,
+            restoreBroadcast: state.comparisonFromBroadcast,
+        };
+    }
+    // ── Standalone deliberation ────────────────────────────────
+    if (state.deliberationStatus !== "idle") {
+        return {
+            teamMode: false,
+            comparisonModel: null,
+            comparisonFromBroadcast: false,
+            goToOverview: true,
+            abortDeliberation: isDeliberating,
+            resetDeliberation: true,
+            restoreBroadcast: false,
+        };
+    }
+    // ── Broadcast or directed (no comparison) ──────────────────
+    // Esc from directed → back to broadcast overview
+    return {
+        teamMode: false,
+        comparisonModel: null,
+        comparisonFromBroadcast: false,
+        goToOverview: true,
+        abortDeliberation: false,
+        resetDeliberation: false,
+        restoreBroadcast: false,
+    };
+}
+export function reduceKeyD(state, unmutedNames, currentDirectedTarget) {
+    // Exiting comparison mode
+    if (state.comparisonModel !== null) {
+        return { comparisonModel: null, comparisonFromBroadcast: false, setDirectedTarget: null };
+    }
+    // Need at least 2 unmuted models
+    if (unmutedNames.length < 2) {
+        return { comparisonModel: null, comparisonFromBroadcast: false, setDirectedTarget: null };
+    }
+    if (currentDirectedTarget === null) {
+        // From broadcast overview: target first, compare with second
+        return {
+            comparisonModel: unmutedNames[1],
+            comparisonFromBroadcast: true,
+            setDirectedTarget: unmutedNames[0],
+        };
+    }
+    // From directed mode: pick a different model to compare with
+    const idx = unmutedNames.indexOf(currentDirectedTarget);
+    if (idx === -1) {
+        return { comparisonModel: null, comparisonFromBroadcast: false, setDirectedTarget: null };
+    }
+    // Next model, wrapping around
+    const compareIdx = (idx + 1) % unmutedNames.length;
+    return {
+        comparisonModel: unmutedNames[compareIdx],
+        comparisonFromBroadcast: false,
+        setDirectedTarget: null,
+    };
+}
+// ── ModeState builder (extracted from app.tsx for testability) ──
+/** Build a ModeState snapshot from UI state so the pure decision
+ *  functions can drive the keyboard handler. */
+export function buildModeState(params) {
+    let deliberationStatus = "idle";
+    if (params.deliberationProgress) {
+        const t = params.deliberationProgress.type;
+        if (t === "done")
+            deliberationStatus = "done";
+        else if (t === "error")
+            deliberationStatus = "error";
+        else
+            deliberationStatus = "running";
+    }
+    return {
+        teamMode: params.teamMode,
+        deliberationStatus,
+        comparisonModel: params.comparisonModel,
+        comparisonFromBroadcast: params.comparisonFromBroadcast,
+    };
+}
+/**
+ * In team overview: submit starts deliberation (idle or after a previous one).
+ * In team directed (Tab-ed to a model): submit routes as a directed message.
+ * Running deliberation: block.
+ */
+export function reduceSubmitInTeam(state, isOverview) {
+    if (state.deliberationStatus === "running") {
+        return { action: "block" };
+    }
+    // Overview + idle/done → start (or restart) deliberation
+    if (isOverview && state.deliberationStatus !== "error") {
+        return { action: "deliberate" };
+    }
+    // Directed chat, or overview with error → normal routing
+    return { action: "route_normally" };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "multiarena",
-  "version": "0.1.0",
-  "description": "Terminal-native multi-model AI coding assistant — chat with multiple LLMs side by side",
+  "version": "0.1.3",
+  "description": "Terminal-native multi-model content generation — N models collaborate to produce the best document, analysis, script, or strategy",
   "type": "module",
   "license": "MIT",
   "engines": {
@@ -11,25 +11,30 @@
     "multiarena": "dist/index.js"
   },
   "files": [
-    "dist/"
+    "dist/",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
   ],
   "keywords": [
     "ai",
     "llm",
-    "coding-assistant",
+    "content-generation",
+    "multi-model",
+    "collaboration",
+    "document-generation",
     "terminal",
     "cli",
     "claude",
     "gpt",
-    "gemini",
-    "ollama",
-    "multi-model"
+    "gemini"
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/timgunnar/arena"
+    "url": "https://github.com/timgunnar/multiarena"
   },
   "scripts": {
+    "prebuild": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
     "build": "tsc",
     "start": "node dist/index.js",
     "dev": "tsx src/index.ts",

package/dist/ui/components/StatusBar.d.ts

@@ -1,9 +0,0 @@
-import React from "react";
-import type { ModelState } from "../../core/types.js";
-interface Props {
-    models: ModelState[];
-    activeModelName: string | null;
-    contextUsages: Record<string, number>;
-}
-export declare const StatusBar: React.FC<Props>;
-export {};

package/dist/ui/components/StatusBar.js

@@ -1,51 +0,0 @@
-import React from "react";
-import { Box, Text } from "ink";
-function renderBar(ratio) {
-    const blocks = 10;
-    const filled = Math.round(ratio * blocks);
-    return "█".repeat(filled) + "░".repeat(blocks - filled);
-}
-function formatTokens(n) {
-    if (n >= 1_000_000)
-        return `${(n / 1_000_000).toFixed(1)}M`;
-    if (n >= 1_000)
-        return `${Math.round(n / 1_000)}K`;
-    return String(n);
-}
-function barColor(ratio) {
-    if (ratio > 0.9)
-        return "red";
-    if (ratio > 0.7)
-        return "yellow";
-    return "green";
-}
-export const StatusBar = ({ models, activeModelName, contextUsages }) => (React.createElement(Box, { flexDirection: "column" },
-    React.createElement(Box, { height: 1, flexDirection: "row" }, models.map((m) => {
-        const isActive = activeModelName === m.name;
-        const hasNew = m.buffer.length > 0 && !isActive;
-        const color = isActive ? "green" : "white";
-        return (React.createElement(Box, { key: m.name, marginRight: 1 },
-            React.createElement(Text, { color: color, bold: isActive }, m.name),
-            hasNew && React.createElement(Text, { color: "yellow" }, " \u25CF"),
-            m.muted && React.createElement(Text, { color: "gray" }, " [muted]")));
-    })),
-    React.createElement(Box, { height: 1, flexDirection: "row" }, models.map((m) => {
-        const usage = contextUsages[m.name] ?? 0;
-        const pct = Math.round(usage * 100);
-        const color = barColor(usage);
-        const used = m.usage.input + m.usage.output;
-        return (React.createElement(Box, { key: m.name, marginRight: 1 },
-            React.createElement(Text, { dimColor: true },
-                formatTokens(used),
-                "/",
-                formatTokens(m.contextLimit),
-                " "),
-            React.createElement(Text, { color: color },
-                renderBar(usage),
-                " ",
-                pct,
-                "%"),
-            usage > 0.9 && React.createElement(Text, { color: "red" }, " \u26A0")));
-    })),
-    React.createElement(Box, { height: 1, flexDirection: "row" },
-        React.createElement(Text, { dimColor: true }, "Tab:switch  d:compare  m:mute  r:reset  q:quit  \u2191\u2193:scroll/history  Esc:cancel"))));