muonroi-cli 1.2.0

package/src/ui/slash/optimize.ts

@@ -0,0 +1,47 @@
+/**
+ * src/ui/slash/optimize.ts
+ *
+ * /optimize slash command (PIL-07, D-14, D-16, D-17).
+ * No-arg: prints last turn's layer-by-layer summary table.
+ * Arg: runs PIL pipeline on given string and prints same table.
+ *
+ * Output format: plain-text, terminal-compatible, headless-safe (D-17 — no ANSI color).
+ * Self-registers on module import.
+ */
+
+import type { PipelineContext } from "../../pil/index.js";
+import { getPilLastResult, runPipeline } from "../../pil/index.js";
+import { getLastOutputMode } from "../../pil/store.js";
+import type { SlashHandler } from "./registry.js";
+import { registerSlash } from "./registry.js";
+
+function formatPilTable(ctx: PipelineContext): string {
+  const header = `Enriched prompt: ${ctx.enriched}`;
+  const style = `Output style: ${ctx.outputStyle ?? "(none)"}`;
+  const table = ctx.layers
+    .map((l) => `  ${l.name.padEnd(28)} applied=${l.applied ? "yes" : "no "}  delta=${l.delta ?? "(none)"}`)
+    .join("\n");
+
+  let metricsBlock = "";
+  if (ctx.metrics) {
+    const m = ctx.metrics;
+    metricsBlock = `\n\nMetrics:\n  total pipeline: ${m.totalMs}ms\n  input chars: ${m.inputChars}\n  output chars: ${m.outputChars}\n  est. tokens saved: ${m.estimatedTokensSaved}\n  layer timings:\n${m.layerTimings.map((t) => `    ${t.name.padEnd(28)} ${t.ms}ms`).join("\n")}`;
+  }
+
+  const outputMode = `Output mode: ${getLastOutputMode()}`;
+
+  return `${header}\n${style}\n${outputMode}\n\nLayer breakdown:\n${table}${metricsBlock}`;
+}
+
+export const handleOptimizeSlash: SlashHandler = async (args, _ctx) => {
+  const ctx = args.length > 0 ? await runPipeline(args.join(" ")) : getPilLastResult();
+
+  if (!ctx) {
+    return '/optimize: no prompt processed yet — run a prompt first, or provide a string: /optimize "your prompt"';
+  }
+
+  return formatPilTable(ctx);
+};
+
+// Self-register on module import (same pattern as cost.ts)
+registerSlash("optimize", handleOptimizeSlash);

package/src/ui/slash/plan.ts

@@ -0,0 +1,62 @@
+/**
+ * src/ui/slash/plan.ts
+ *
+ * /plan slash command handler (FLOW-06).
+ * Gates on unresolved gray areas; writes plan to roadmap.md when unblocked.
+ *
+ * Self-registers on module import — call once from src/index.ts boot path
+ * or import in test to trigger registration.
+ */
+
+import { getActiveRunId, loadRun, updateRunFile } from "../../flow/run-manager.js";
+import { ensureFlowDir } from "../../flow/scaffold.js";
+import type { SlashHandler } from "./registry.js";
+import { registerSlash } from "./registry.js";
+
+/**
+ * Extract open gray area entries from gray-areas.md content.
+ * Returns array of matching lines like "G1 [open] Should we use X?"
+ */
+function findOpenGrayAreas(content: string): string[] {
+  const lines = content.split("\n");
+  return lines.filter((line) => /^G\d+\s+\[open\]/.test(line.trim()));
+}
+
+export const handlePlanSlash: SlashHandler = async (args, ctx) => {
+  const flowDir = await ensureFlowDir(ctx.cwd);
+  const activeRunId = await getActiveRunId(flowDir);
+
+  if (!activeRunId) {
+    return "No active run. Start with /discuss.";
+  }
+
+  const run = await loadRun(flowDir, activeRunId);
+  if (!run) {
+    return `Error: active run ${activeRunId} not found on disk.`;
+  }
+
+  // Check for unresolved gray areas
+  const gaContent = run.grayAreas.sections.get("Gray Areas") ?? "";
+  const openAreas = findOpenGrayAreas(gaContent);
+
+  if (openAreas.length > 0) {
+    const entries = openAreas
+      .map(
+        (entry) =>
+          `${entry}\n   Resolution path: Ask user in /discuss or resolve in .muonroi-flow/runs/${activeRunId}/gray-areas.md`,
+      )
+      .join("\n\n");
+
+    return `/plan blocked: ${openAreas.length} unresolved gray areas\n\n${entries}\n\nResolve these before running /plan, or edit gray-areas.md directly.`;
+  }
+
+  // No open gray areas — write plan to roadmap.md
+  const planContent = args.join(" ");
+  run.roadmap.sections.set("Plan", planContent);
+  await updateRunFile(flowDir, activeRunId, "roadmap.md", run.roadmap);
+
+  return `Plan created for run ${activeRunId}.`;
+};
+
+// Self-register on module import
+registerSlash("plan", handlePlanSlash);

package/src/ui/slash/registry.ts

@@ -0,0 +1,38 @@
+/**
+ * src/ui/slash/registry.ts
+ *
+ * Slash command registry — extensible by feature plans (Plan 06+ add commands).
+ * Plan 06 wires dispatchSlash() into app.tsx alongside existing switch.
+ */
+
+export interface SlashContext {
+  cwd: string;
+  tenantId: string;
+  lastPrompt?: string;
+  defaultProvider: string;
+  defaultModel: string;
+}
+
+export type SlashHandler = (args: string[], ctx: SlashContext) => Promise<string> | string;
+
+const registry = new Map<string, SlashHandler>();
+
+/** Register a slash command handler. */
+export function registerSlash(name: string, handler: SlashHandler): void {
+  registry.set(name, handler);
+}
+
+/**
+ * Dispatch a slash command by name.
+ * Returns null if command not registered (caller falls back to legacy switch).
+ */
+export async function dispatchSlash(name: string, args: string[], ctx: SlashContext): Promise<string | null> {
+  const h = registry.get(name);
+  if (!h) return null;
+  return await h(args, ctx);
+}
+
+/** List all registered slash command names. */
+export function listSlashCommands(): string[] {
+  return [...registry.keys()];
+}

package/src/ui/slash/route.test.ts

@@ -0,0 +1,82 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import { type StubHandle, startStubEEServer } from "../../__test-stubs__/ee-server.js";
+import { createEEClient } from "../../ee/client.js";
+import { setDefaultEEClient } from "../../ee/intercept.js";
+import { midstreamPolicy } from "../../usage/midstream.js";
+import { dispatchSlash, listSlashCommands, registerSlash, type SlashContext } from "./registry.js";
+
+// Import route.ts to trigger self-registration
+import "./route.js";
+
+const CTX: SlashContext = {
+  cwd: "/tmp",
+  tenantId: "local",
+  defaultProvider: "anthropic",
+  defaultModel: "claude-3-5-sonnet-latest",
+  lastPrompt: "create file foo.ts",
+};
+
+describe("slash registry", () => {
+  it("registerSlash + dispatchSlash round-trip", async () => {
+    registerSlash("test-cmd", (_args, _ctx) => "test-result");
+    const result = await dispatchSlash("test-cmd", [], CTX);
+    expect(result).toBe("test-result");
+  });
+
+  it("dispatchSlash returns null for unregistered command", async () => {
+    const result = await dispatchSlash("nonexistent", [], CTX);
+    expect(result).toBeNull();
+  });
+
+  it("listSlashCommands includes route after import", () => {
+    const cmds = listSlashCommands();
+    expect(cmds).toContain("route");
+  });
+});
+
+describe("handleRouteSlash", () => {
+  let stub: StubHandle;
+
+  beforeAll(async () => {
+    // Stub EE with no handlers -> warm/cold both fail -> fallback path
+    stub = await startStubEEServer({});
+    setDefaultEEClient(createEEClient({ baseUrl: `http://localhost:${stub.port}` }));
+  });
+
+  afterAll(async () => {
+    await stub.stop();
+  });
+
+  beforeEach(() => {
+    midstreamPolicy.clear();
+  });
+
+  it("returns string containing tier, model, provider, reason", async () => {
+    const result = await dispatchSlash("route", ["create file x"], CTX);
+    expect(result).toBeTypeOf("string");
+    expect(result).toContain("Tier:");
+    expect(result).toContain("Provider:");
+    expect(result).toContain("Model:");
+    expect(result).toContain("Reason:");
+  });
+
+  it("uses lastPrompt when no args given", async () => {
+    const result = await dispatchSlash("route", [], CTX);
+    expect(result).toBeTypeOf("string");
+    expect(result).toContain("Tier:");
+  });
+
+  it("returns help text when no prompt and no lastPrompt", async () => {
+    const noPromptCtx = { ...CTX, lastPrompt: undefined };
+    const result = await dispatchSlash("route", [], noPromptCtx);
+    expect(result).toContain("/route:");
+    expect(result).toContain("no recent prompt");
+  });
+
+  it("includes cap-driven note when cap_overridden", async () => {
+    // Force midstream refuse -> decide will set cap_overridden
+    midstreamPolicy.forceRefuseNext();
+    const result = await dispatchSlash("route", ["create file x"], CTX);
+    expect(result).toContain("Cap-driven");
+  });
+});

package/src/ui/slash/route.ts

@@ -0,0 +1,43 @@
+/**
+ * src/ui/slash/route.ts
+ *
+ * /route slash command handler (ROUTE-05).
+ * Prints next-prompt routing decision: tier, model, provider, reason.
+ * Includes cap-driven note when cap_overridden is true.
+ *
+ * Self-registers on module import — call once from src/index.ts boot path
+ * or import in test to trigger registration.
+ */
+
+import { decide } from "../../router/decide.js";
+import type { SlashHandler } from "./registry.js";
+import { registerSlash } from "./registry.js";
+
+export const handleRouteSlash: SlashHandler = async (args, ctx) => {
+  const prompt = args.join(" ") || ctx.lastPrompt || "";
+  if (!prompt) {
+    return "/route: no recent prompt — type a prompt first or pass it as argument: /route <prompt>";
+  }
+
+  const d = await decide(prompt, {
+    tenantId: ctx.tenantId,
+    cwd: ctx.cwd,
+    defaultModel: ctx.defaultModel,
+    defaultProvider: ctx.defaultProvider,
+  });
+
+  const lines = [`Tier:     ${d.tier}`, `Provider: ${d.provider}`, `Model:    ${d.model}`, `Reason:   ${d.reason}`];
+
+  if (typeof d.confidence === "number") {
+    lines.push(`Confidence: ${d.confidence.toFixed(2)}`);
+  }
+
+  if (d.cap_overridden) {
+    lines.push(`Cap-driven: yes (downgrade applied)`);
+  }
+
+  return lines.join("\n");
+};
+
+// Self-register on module import
+registerSlash("route", handleRouteSlash);

package/src/ui/status-bar/index.test.tsx

@@ -0,0 +1,90 @@
+/**
+ * index.test.tsx -- tests for StatusBar pure render function (renderStatusBar).
+ * Uses renderStatusBar directly to avoid needing React hooks context in tests.
+ */
+import { describe, expect, it, vi } from "vitest";
+
+// Mock upstream deps (same as store.test.ts)
+vi.mock("../../router/store.js", () => ({
+  routerStore: {
+    getState: () => ({ tier: "hot", degraded: false, lastDecision: null, lastHealthCheckAtMs: 0 }),
+    setState: () => {},
+    subscribe: () => () => {},
+  },
+}));
+vi.mock("../../usage/thresholds.js", () => ({
+  subscribeThresholds: () => () => {},
+}));
+vi.mock("../../usage/downgrade.js", () => ({
+  subscribeDowngrade: () => () => {},
+}));
+
+import { renderStatusBar } from "./index.js";
+import type { StatusBarState } from "./store.js";
+
+function makeState(overrides: Partial<StatusBarState> = {}): StatusBarState {
+  return {
+    provider: "",
+    model: "",
+    tier: "hot",
+    in_tokens: 0,
+    out_tokens: 0,
+    cache_read_tokens: 0,
+    cache_creation_tokens: 0,
+    session_usd: 0,
+    month_usd: 0,
+    cap_usd: 0,
+    current_pct: 0,
+    degraded: false,
+    routed_from: null,
+    ee_status: "unknown",
+    ...overrides,
+  };
+}
+
+describe("StatusBar (renderStatusBar)", () => {
+  it("renders a row with data-testid status-bar", () => {
+    const el = renderStatusBar(makeState({ provider: "anthropic", model: "claude-3-5-sonnet-latest" })) as any;
+    expect(el.props["data-testid"]).toBe("status-bar");
+  });
+
+  it("includes slot-provider-model, tier badge, slot-tokens, usd meter slots", () => {
+    const el = renderStatusBar(makeState({ provider: "anthropic", model: "opus", in_tokens: 10, out_tokens: 5 }));
+    const json = JSON.stringify(el);
+    expect(json).toContain("slot-provider-model");
+    // TierBadge/UsdMeter are function components -- verify by key presence in children
+    expect(json).toContain('"key":"tier"');
+    expect(json).toContain("slot-tokens");
+    expect(json).toContain('"key":"usd"');
+  });
+
+  it("shows degraded marker only when degraded=true", () => {
+    const el1 = renderStatusBar(makeState({ degraded: false }));
+    expect(JSON.stringify(el1)).not.toContain("slot-degraded");
+
+    const el2 = renderStatusBar(makeState({ degraded: true }));
+    expect(JSON.stringify(el2)).toContain("slot-degraded");
+  });
+
+  it("renders provider/model text correctly", () => {
+    const el = renderStatusBar(makeState({ provider: "openai", model: "gpt-4o" }));
+    expect(JSON.stringify(el)).toContain("openai/gpt-4o");
+  });
+
+  it("renders all 5 slots + degraded when degraded=true", () => {
+    const el = renderStatusBar(makeState({ degraded: true }));
+    const json = JSON.stringify(el);
+    expect(json).toContain("slot-provider-model");
+    expect(json).toContain('"key":"tier"');
+    expect(json).toContain("slot-tokens");
+    expect(json).toContain('"key":"usd"');
+    expect(json).toContain("slot-degraded");
+  });
+
+  it("renders separators between slots", () => {
+    const el = renderStatusBar(makeState());
+    const json = JSON.stringify(el);
+    // Should have ' | ' separators
+    expect(json).toContain(" | ");
+  });
+});

package/src/ui/status-bar/index.tsx

@@ -0,0 +1,94 @@
+/**
+ * src/ui/status-bar/index.tsx
+ *
+ * OpenTUI status bar React component composing the 6 slots:
+ * [provider/model] | [tier badge] | [in/out tokens session] | [USD session | month] | [degraded marker]
+ *
+ * Subscribes to statusBarStore for live updates (no polling).
+ */
+
+import * as React from "react";
+import { type StatusBarState, statusBarStore } from "./store.js";
+import { TierBadge } from "./tier-badge.js";
+import { UsdMeter } from "./usd-meter.js";
+
+function useStatusBarState(): StatusBarState {
+  const [s, set] = React.useState(statusBarStore.getState());
+  React.useEffect(() => statusBarStore.subscribe(set), []);
+  return s;
+}
+
+const EE_DOT: Record<string, { color: string; symbol: string }> = {
+  ok: { color: "green", symbol: "●" },      // ●
+  warn: { color: "yellow", symbol: "●" },    // ●
+  down: { color: "red", symbol: "●" },        // ●
+  unknown: { color: "gray", symbol: "○" },    // ○
+};
+
+function fmtTokens(n: number): string {
+  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
+  if (n >= 1_000) return `${(n / 1_000).toFixed(1)}K`;
+  return String(n);
+}
+
+function fmtCost(usd: number): string {
+  if (usd >= 1) return `$${usd.toFixed(2)}`;
+  if (usd >= 0.01) return `$${usd.toFixed(3)}`;
+  return `$${usd.toFixed(4)}`;
+}
+
+/** Pure render function -- testable without React hooks context. */
+export function renderStatusBar(s: StatusBarState): React.ReactElement {
+  const modelLabel = s.routed_from && s.routed_from !== s.model
+    ? `${s.provider || "-"}/${s.routed_from}→${s.model}`
+    : `${s.provider || "-"}/${s.model || "-"}`;
+
+  const tokenStr = `↑${fmtTokens(s.in_tokens)} ↓${fmtTokens(s.out_tokens)}${s.cache_read_tokens ? ` ⊚${fmtTokens(s.cache_read_tokens)}` : ""}`;
+  const ee = EE_DOT[s.ee_status] ?? EE_DOT.unknown;
+
+  const slots: React.ReactNode[] = [
+    React.createElement(
+      "text",
+      { key: "pm", fg: "#5c9cf5", "data-testid": "slot-provider-model" },
+      modelLabel,
+    ),
+    React.createElement(TierBadge, { key: "tier", tier: s.tier }),
+    React.createElement("text", { key: "tok", fg: "cyan", "data-testid": "slot-tokens" }, `${tokenStr} ${fmtCost(s.session_usd)}`),
+    React.createElement(UsdMeter, {
+      key: "usd",
+      session_usd: s.session_usd,
+      month_usd: s.month_usd,
+      current_pct: s.current_pct,
+    }),
+    React.createElement(
+      "text",
+      { key: "ee", fg: ee.color, "data-testid": "slot-ee" },
+      ee.symbol,
+    ),
+  ];
+
+  if (s.degraded) {
+    slots.push(
+      React.createElement(
+        "text",
+        { key: "deg", fg: "yellow", blink: true, "data-testid": "slot-degraded" },
+        "DEGRADED",
+      ),
+    );
+  }
+
+  // Join slots with ' | ' separators
+  const joined: React.ReactNode[] = [];
+  slots.forEach((el, i) => {
+    if (i > 0) joined.push(React.createElement("text", { key: `sep-${i}` }, " | "));
+    joined.push(el);
+  });
+
+  return React.createElement("box", { "data-testid": "status-bar", flexDirection: "row" }, ...joined);
+}
+
+/** React component with hook-based subscription -- used in app.tsx layout. */
+export function StatusBar(): React.ReactElement {
+  const s = useStatusBarState();
+  return renderStatusBar(s);
+}

package/src/ui/status-bar/store.test.ts

@@ -0,0 +1,131 @@
+/**
+ * store.test.ts -- tests for statusBarStore + wireStatusBar subscriptions.
+ */
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+// Capture subscription callbacks so we can fire them in tests
+let routerCallback: ((s: any) => void) | null = null;
+let thresholdCallback: ((e: any) => void) | null = null;
+let downgradeCallback: ((e: any) => void) | null = null;
+
+vi.mock("../../router/store.js", () => ({
+  routerStore: {
+    getState: () => ({ tier: "hot", degraded: false, lastDecision: null, lastHealthCheckAtMs: 0 }),
+    setState: () => {},
+    subscribe: (fn: (s: any) => void) => {
+      routerCallback = fn;
+      return () => {
+        routerCallback = null;
+      };
+    },
+  },
+}));
+
+vi.mock("../../usage/thresholds.js", () => ({
+  subscribeThresholds: (fn: (e: any) => void) => {
+    thresholdCallback = fn;
+    return () => {
+      thresholdCallback = null;
+    };
+  },
+}));
+
+vi.mock("../../usage/downgrade.js", () => ({
+  subscribeDowngrade: (fn: (e: any) => void) => {
+    downgradeCallback = fn;
+    return () => {
+      downgradeCallback = null;
+    };
+  },
+}));
+
+import { __resetStatusBarStoreForTests, statusBarStore, wireStatusBar } from "./store.js";
+
+describe("statusBarStore", () => {
+  beforeEach(() => {
+    __resetStatusBarStoreForTests();
+    routerCallback = null;
+    thresholdCallback = null;
+    downgradeCallback = null;
+  });
+
+  it("has correct default state", () => {
+    const s = statusBarStore.getState();
+    expect(s.model).toBe("");
+    expect(s.provider).toBe("");
+    expect(s.tier).toBe("hot");
+    expect(s.in_tokens).toBe(0);
+    expect(s.out_tokens).toBe(0);
+    expect(s.session_usd).toBe(0);
+    expect(s.month_usd).toBe(0);
+    expect(s.degraded).toBe(false);
+  });
+
+  it("setState merges partial updates and notifies subscribers", () => {
+    const spy = vi.fn();
+    statusBarStore.subscribe(spy);
+    statusBarStore.setState({ model: "test-model" });
+    expect(spy).toHaveBeenCalledTimes(1);
+    expect(statusBarStore.getState().model).toBe("test-model");
+  });
+});
+
+describe("wireStatusBar", () => {
+  beforeEach(() => {
+    __resetStatusBarStoreForTests();
+    routerCallback = null;
+    thresholdCallback = null;
+    downgradeCallback = null;
+  });
+
+  it("registers 3 subscriptions; routerStore tier change updates store", () => {
+    const off = wireStatusBar();
+    expect(routerCallback).toBeTruthy();
+    expect(thresholdCallback).toBeTruthy();
+    expect(downgradeCallback).toBeTruthy();
+
+    // Fire router update
+    routerCallback!({
+      tier: "warm",
+      degraded: true,
+      lastDecision: { provider: "anthropic", model: "claude-3-5-sonnet-latest" },
+      lastHealthCheckAtMs: 1,
+    });
+
+    const s = statusBarStore.getState();
+    expect(s.tier).toBe("warm");
+    expect(s.degraded).toBe(true);
+    expect(s.provider).toBe("anthropic");
+    expect(s.model).toBe("claude-3-5-sonnet-latest");
+    off();
+  });
+
+  it("threshold event updates session_usd and month_usd", () => {
+    const off = wireStatusBar();
+    thresholdCallback!({
+      level: 80,
+      current_pct: 80,
+      current_usd: 12.5,
+      cap_usd: 15,
+      atMs: 1,
+    });
+
+    const s = statusBarStore.getState();
+    expect(s.session_usd).toBe(12.5);
+    expect(s.month_usd).toBe(12.5);
+    off();
+  });
+
+  it("downgrade event updates model", () => {
+    const off = wireStatusBar();
+    downgradeCallback!({
+      fromModel: "claude-3-opus-latest",
+      toModel: "claude-3-5-sonnet-latest",
+      pct: 80,
+      atMs: 1,
+    });
+
+    expect(statusBarStore.getState().model).toBe("claude-3-5-sonnet-latest");
+    off();
+  });
+});