ubume 0.1.0

package/src/session/types.ts

@@ -0,0 +1,234 @@
+import type {
+  AuthPreference,
+  AvailableBackend,
+} from "../config/settings.js";
+import type { ResolvedRuntimeConfig } from "../config/runtimeConfig.js";
+import type { RunActivitySummary, RunFileActivity } from "../core/workspace/workspaceActivity.js";
+
+// ─── Screen routing ──────────────────────────────────────────────────────────
+
+export type Screen =
+  | "main"
+  | "resume-picker"
+  | "model-picker"
+  | "mode-picker"
+  | "backend-picker"
+  | "provider-picker"
+  | "provider-setup"
+  | "auth-panel"
+  | "reasoning-picker"
+  | "theme-picker"
+  | "settings-panel"
+  | "permissions-panel"
+  | "permissions-approval-picker"
+  | "permissions-sandbox-picker"
+  | "permissions-network-picker"
+  | "permissions-add-writable-root"
+  | "permissions-remove-writable-root"
+  | "import-confirmation"
+  | "tool-approval"
+  | "update-prompt";
+
+// ─── Provider readiness ───────────────────────────────────────────────────────
+
+export type ExternalCliStatus = "idle" | "starting" | "ready" | "failed";
+
+// ─── UI State Machine ─────────────────────────────────────────────────────────
+// Drives all visual decisions: border colors, input persona, turn opacity.
+//
+//  IDLE ──submit──▶ THINKING ──first token──▶ RESPONDING ──answer visible──▶ ANSWER_VISIBLE ──complete──▶ IDLE
+//   ▲                  │                           │                     │
+//   │                  └──error──▶ ERROR           └──question──▶ AWAITING
+//   └──────────────────────────────────────── dismiss / answer ──────────┘
+
+export type UIState =
+  | { kind: "IDLE" }
+  | { kind: "THINKING"; turnId: number }
+  | { kind: "RESPONDING"; turnId: number }
+  | { kind: "ANSWER_VISIBLE"; turnId: number }
+  | { kind: "AWAITING_USER_ACTION"; turnId: number; question: string }
+  | { kind: "ERROR"; turnId: number; message: string }
+  | { kind: "SHELL_RUNNING"; shellId: number };
+
+/** Derive the legacy busy flag from UIState for guard functions. */
+export function isBusy(state: UIState): boolean {
+  return state.kind === "THINKING"
+    || state.kind === "RESPONDING"
+    || state.kind === "ANSWER_VISIBLE"
+    || state.kind === "SHELL_RUNNING";
+}
+
+// ─── Timeline events ─────────────────────────────────────────────────────────
+
+export interface TimelineBaseEvent {
+  id: number;
+  createdAt: number;
+}
+
+export interface UserPromptEvent extends TimelineBaseEvent {
+  type: "user";
+  prompt: string;
+  /** Links this user prompt to its run and assistant response in a TurnGroup. */
+  turnId: number;
+}
+
+export interface AssistantEvent extends TimelineBaseEvent {
+  type: "assistant";
+  content: string;
+  /** Accumulated chunks during streaming — avoids O(n²) string concatenation. */
+  contentChunks: string[];
+  /** Links this response back to the originating user prompt + run. */
+  turnId: number;
+}
+
+/**
+ * Returns the full assistant content string. During streaming, joins the
+ * accumulated chunks (single O(n) allocation). After finalization, returns
+ * the pre-joined `content` field directly.
+ */
+export function getAssistantContent(event: AssistantEvent | null | undefined): string {
+  if (!event) return "";
+  if (event.contentChunks.length > 0) return event.contentChunks.join("");
+  return event.content;
+}
+
+export function getResponseSegmentText(segment: RunResponseSegment | null | undefined): string {
+  if (!segment) return "";
+  return segment.chunks.join("");
+}
+
+export interface RunToolActivity {
+  id: string;
+  command: string;
+  status: "running" | "completed" | "failed";
+  startedAt: number;
+  completedAt?: number | null;
+  summary?: string | null;
+  /** Turn-global ordering against thinking blocks and response segments. */
+  streamSeq?: number;
+}
+
+export type RunProgressSource =
+  | "reasoning"
+  | "todo"
+  | "stdout"
+  | "tool"
+  | "activity"
+  | "stderr"
+  | "transcript";
+
+export interface RunProgressBlock {
+  id: string;
+  text: string;
+  sequence: number;
+  createdAt: number;
+  updatedAt: number;
+  status: "active" | "completed";
+  /** Turn-global ordering against tools and response segments. Set when block first becomes visible. */
+  streamSeq?: number;
+}
+
+export interface RunResponseSegment {
+  id: string;
+  streamSeq: number;
+  chunks: string[];
+  status: "active" | "completed";
+  startedAt: number;
+}
+
+export interface RunPlanBlock {
+  id: string;
+  streamSeq: number;
+  chunks: string[];
+  status: "active" | "completed";
+  startedAt: number;
+}
+
+export function getRunPlanText(plan: RunPlanBlock | null | undefined): string {
+  if (!plan) return "";
+  return plan.chunks.join("");
+}
+
+export interface RunStreamItem {
+  streamSeq: number;
+  kind: "thinking" | "action" | "response" | "plan";
+  /** block.id, tool.id, response-segment id, or plan.id depending on kind. */
+  refId: string;
+}
+
+export interface RunProgressEntry {
+  id: string;
+  source: RunProgressSource;
+  /** Latest normalized full text received for this upstream progress item. */
+  text: string;
+  sequence: number;
+  createdAt: number;
+  updatedAt: number;
+  /** Structured visible blocks derived from `text` with stable identities. */
+  blocks: RunProgressBlock[];
+  /**
+   * Count of trailing newlines that have not yet been committed into a block.
+   * This keeps single-newline vs double-newline boundaries streaming-safe.
+   */
+  pendingNewlineCount: number;
+}
+
+export interface SystemEvent extends TimelineBaseEvent {
+  type: "system";
+  title: string;
+  content: string;
+}
+
+export interface ErrorEvent extends TimelineBaseEvent {
+  type: "error";
+  title: string;
+  content: string;
+}
+
+export interface RunEvent extends TimelineBaseEvent {
+  type: "run";
+  backendId: AvailableBackend;
+  backendLabel: string;
+  runtime: ResolvedRuntimeConfig;
+  prompt: string;
+  progressEntries: RunProgressEntry[];
+  status: "running" | "completed" | "failed" | "canceled";
+  summary: string;
+  truncatedOutput: boolean;
+  startedAt: number;
+  durationMs: number | null;
+  toolActivities: RunToolActivity[];
+  activity: RunFileActivity[];
+  touchedFileCount: number;
+  activitySummary?: RunActivitySummary;
+  errorMessage?: string | null;
+  /** Links this run to its user prompt for TurnGroup rendering. */
+  turnId: number;
+  /** Chronologically ordered references to thinking/action/response items. */
+  streamItems?: RunStreamItem[];
+  /** Discrete response segments — interrupted by thinking/action events. */
+  responseSegments?: RunResponseSegment[];
+  /** Monotonic counter the reducer uses to assign streamSeq across all events. */
+  lastStreamSeq?: number;
+  /** When set, the next assistant delta extends this segment; cleared by thinking/action. */
+  activeResponseSegmentId?: string | null;
+  /** First-class plan content rendered as a stable stream item. */
+  plan?: RunPlanBlock | null;
+  /** The approved plan text, injected at the start of execution turns. */
+  approvedPlan?: string;
+  /** How the final assistant text of this run is presented. Set at run creation. */
+  responsePresentation?: "assistant" | "plan";
+}
+
+export interface ShellEvent extends TimelineBaseEvent {
+  type: "shell";
+  command: string;
+  lines: string[];
+  stderrLines: string[];
+  summary?: string | null;
+  status: "running" | "completed" | "failed";
+  exitCode: number | null;
+  durationMs: number | null;
+}
+
+export type TimelineEvent = UserPromptEvent | AssistantEvent | SystemEvent | ErrorEvent | RunEvent | ShellEvent;

package/src/test/runtimeTestUtils.ts

@@ -0,0 +1,14 @@
+import { resolveRuntimeConfig, type RuntimeConfig, DEFAULT_RUNTIME_CONFIG, type ResolvedRuntimeConfig } from "../config/runtimeConfig.js";
+
+export function makeResolvedRuntime(overrides: Partial<RuntimeConfig> = {}): ResolvedRuntimeConfig {
+  return resolveRuntimeConfig({
+    ...DEFAULT_RUNTIME_CONFIG,
+    ...overrides,
+    policy: {
+      ...DEFAULT_RUNTIME_CONFIG.policy,
+      ...overrides.policy,
+    },
+  });
+}
+
+export const TEST_RUNTIME = makeResolvedRuntime();

package/src/types/react-dom.d.ts

@@ -0,0 +1,3 @@
+declare module "react-dom" {
+  export function flushSync<T>(callback: () => T): T;
+}

package/src/ui/chrome/ActivityBars.tsx

@@ -0,0 +1,68 @@
+import React from "react";
+import { Box, Text } from "ink";
+import { useTheme } from "../theme.js";
+
+// ─── WaveBar ─────────────────────────────────────────────────────────────────
+// Audio-visualizer style wave. Renders as a single <Text> node to minimise
+// the React element tree — important for keeping Ink re-renders cheap.
+
+const WAVE_CHARS = ["▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"] as const;
+const WAVE_COLS = 12;
+const WAVE_SPEED = 0.38;  // radians per tick
+const WAVE_SPREAD = 0.6;  // phase offset between adjacent columns
+
+interface WaveBarProps {
+  tick: number;
+  color?: string;
+}
+
+export function WaveBar({ tick, color }: WaveBarProps) {
+  const theme = useTheme();
+  const activeColor = color ?? theme.accent;
+
+  let str = "";
+  for (let c = 0; c < WAVE_COLS; c++) {
+    const phase = tick * WAVE_SPEED + c * WAVE_SPREAD;
+    const normalized = (Math.sin(phase) + 1) / 2; // [0, 1]
+    const idx = Math.round(normalized * (WAVE_CHARS.length - 1));
+    str += WAVE_CHARS[idx] ?? "▄";
+  }
+
+  return <Text color={activeColor}>{str}</Text>;
+}
+
+// ─── PulseBar ─────────────────────────────────────────────────────────────────
+// Indeterminate progress bar. Renders as 3 <Text> nodes (before / fill / after).
+
+const PULSE_TOTAL = 20;
+const PULSE_FILL = 6;
+const PULSE_MAX_POS = PULSE_TOTAL - PULSE_FILL; // 14
+const PULSE_PERIOD = PULSE_MAX_POS * 2;          // 28
+const PULSE_SPEED = 2;                            // ticks per position step
+
+interface PulseBarProps {
+  tick: number;
+  color?: string;
+  dimColor?: string;
+}
+
+export function PulseBar({ tick, color, dimColor }: PulseBarProps) {
+  const theme = useTheme();
+  const activeColor = color ?? theme.accent;
+  const inactiveColor = dimColor ?? theme.textDim;
+
+  const raw = Math.floor(tick / PULSE_SPEED) % PULSE_PERIOD;
+  const pos = raw < PULSE_MAX_POS ? raw : PULSE_PERIOD - raw;
+
+  const before = "░".repeat(pos);
+  const fill = "█".repeat(PULSE_FILL);
+  const after = "░".repeat(PULSE_TOTAL - pos - PULSE_FILL);
+
+  return (
+    <Box>
+      <Text color={inactiveColor}>{before}</Text>
+      <Text color={activeColor}>{fill}</Text>
+      <Text color={inactiveColor}>{after}</Text>
+    </Box>
+  );
+}

package/src/ui/chrome/ActivityIndicator.tsx

@@ -0,0 +1,58 @@
+import React, { useState, useEffect } from "react";
+import { Text } from "ink";
+import type { UIState, ExternalCliStatus } from "../../session/types.js";
+import { useTheme } from "../theme.js";
+
+const SPINNER_FRAMES = ["?", "?", "?", "?", "?", "?", "?", "?", "?", "?"];
+const STREAMING_FRAMES = ["?", "?", "?", "?"];
+
+export interface ActivityIndicatorProps {
+  uiState: UIState;
+  externalCliStatus?: ExternalCliStatus;
+}
+
+export function ActivityIndicator({ uiState, externalCliStatus = "idle" }: ActivityIndicatorProps) {
+  const theme = useTheme();
+  const [frameIndex, setFrameIndex] = useState(0);
+
+  const isError = uiState.kind === "ERROR" || externalCliStatus === "failed";
+  const isStarting = externalCliStatus === "starting";
+  const isThinking = uiState.kind === "THINKING";
+  const isStreaming = uiState.kind === "RESPONDING";
+  const isAction = uiState.kind === "SHELL_RUNNING";
+
+  const isAnimated = isStarting || isThinking || isStreaming;
+
+  useEffect(() => {
+    if (!isAnimated) return;
+    const interval = setInterval(() => {
+      setFrameIndex((prev) => prev + 1);
+    }, 80);
+    return () => clearInterval(interval);
+  }, [isAnimated]);
+
+  let glyph = "?";
+  let color = theme.textDim;
+  let bold = false;
+
+  if (isError) {
+    glyph = "�";
+    color = theme.error;
+    bold = true;
+  } else if (isAction) {
+    glyph = "?";
+    color = theme.warning;
+    bold = true;
+  } else if (isStarting || isThinking) {
+    glyph = SPINNER_FRAMES[frameIndex % SPINNER_FRAMES.length]!;
+    color = theme.text;
+  } else if (isStreaming) {
+    glyph = STREAMING_FRAMES[frameIndex % STREAMING_FRAMES.length]!;
+    color = theme.success;
+  } else {
+    glyph = "?";
+    color = theme.textDim;
+  }
+
+  return <Text color={color} bold={bold}>{glyph}</Text>;
+}

package/src/ui/chrome/AnimatedStatusText.tsx

@@ -0,0 +1,69 @@
+import React, { useEffect, useState } from "react";
+import { Text } from "ink";
+import * as renderDebug from "../../core/perf/renderDebug.js";
+import { useTheme } from "../theme.js";
+import { sanitizeTerminalOutput } from "../../core/terminal/terminalSanitize.js";
+import { BUSY_STATUS_FRAME_MS, BUSY_STATUS_FRAMES, getBusyStatusFrame } from "./busyStatusAnimation.js";
+
+interface AnimatedStatusTextProps {
+  baseText: string;
+  isActive: boolean;
+  isError?: boolean;
+  animationFrame?: string;
+}
+
+function useLocalBusyStatusFrame(isActive: boolean, label: string): string {
+  const [frameIndex, setFrameIndex] = useState(0);
+  const staticStatus = process.env.UBUME_DEBUG_STATIC_STATUS === "1";
+
+  useEffect(() => {
+    if (!isActive || staticStatus) {
+      setFrameIndex(0);
+      return;
+    }
+
+    setFrameIndex(0);
+    const timer = setInterval(() => {
+      setFrameIndex((current) => {
+        const next = current + 1;
+        renderDebug.traceStatusTick({ owner: "Status", label, frameIndex: next });
+        return next;
+      });
+    }, BUSY_STATUS_FRAME_MS);
+    timer.unref?.();
+
+    return () => {
+      clearInterval(timer);
+    };
+  }, [isActive, label, staticStatus]);
+
+  if (isActive && staticStatus) {
+    return BUSY_STATUS_FRAMES[BUSY_STATUS_FRAMES.length - 1]!;
+  }
+  return getBusyStatusFrame(frameIndex);
+}
+
+export function AnimatedStatusText({ baseText, isActive, isError = false, animationFrame }: AnimatedStatusTextProps) {
+  const localFrame = useLocalBusyStatusFrame(isActive, baseText);
+  renderDebug.useRenderDebug("Status", {
+    baseText,
+    isActive,
+    isError,
+    animationFrame: animationFrame ?? localFrame,
+  });
+  renderDebug.useLifecycleDebug("Status", {
+    baseText,
+    isActive,
+    isError,
+  });
+
+  const theme = useTheme();
+  const renderedText = sanitizeTerminalOutput(baseText);
+  const suffix = isActive ? animationFrame ?? localFrame : "";
+
+  return (
+    <Text color={isError ? theme.error : theme.info} wrap="truncate">
+      {renderedText}{suffix}
+    </Text>
+  );
+}