@golba98/codexa 1.0.1

package/src/session/planTranscript.test.ts

@@ -0,0 +1,65 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { TEST_RUNTIME } from "../test/runtimeTestUtils.js";
+import type { RunEvent, TimelineEvent } from "./types.js";
+import { hasFinalizedTranscriptPlan } from "./planTranscript.js";
+
+function makeRun(overrides: Partial<RunEvent> = {}): RunEvent {
+  return {
+    id: 1,
+    type: "run",
+    createdAt: 1,
+    startedAt: 1,
+    durationMs: 10,
+    backendId: "codex-subprocess",
+    backendLabel: "Codexa",
+    runtime: TEST_RUNTIME,
+    prompt: "Plan work",
+    progressEntries: [],
+    status: "completed",
+    summary: "completed",
+    truncatedOutput: false,
+    toolActivities: [],
+    activity: [],
+    touchedFileCount: 0,
+    errorMessage: null,
+    turnId: 1,
+    streamItems: [{ kind: "plan", streamSeq: 1, refId: "plan-1" }],
+    responseSegments: [],
+    lastStreamSeq: 1,
+    activeResponseSegmentId: null,
+    plan: {
+      id: "plan-1",
+      streamSeq: 1,
+      chunks: ["1. Inspect\n2. Update"],
+      status: "completed",
+      startedAt: 1,
+    },
+    ...overrides,
+  };
+}
+
+test("approval visibility requires a non-empty finalized transcript plan", () => {
+  assert.equal(hasFinalizedTranscriptPlan([], "1. Inspect"), false);
+  assert.equal(hasFinalizedTranscriptPlan([makeRun()], ""), false);
+  assert.equal(hasFinalizedTranscriptPlan([makeRun({ plan: null })], "1. Inspect"), false);
+  assert.equal(
+    hasFinalizedTranscriptPlan([
+      makeRun({
+        status: "running",
+        plan: {
+          id: "plan-1",
+          streamSeq: 1,
+          chunks: ["1. Inspect"],
+          status: "active",
+          startedAt: 1,
+        },
+      }),
+    ], "1. Inspect"),
+    false,
+  );
+  assert.equal(
+    hasFinalizedTranscriptPlan([makeRun()] satisfies TimelineEvent[], "1. Inspect\n2. Update"),
+    true,
+  );
+});

package/src/session/planTranscript.ts

@@ -0,0 +1,15 @@
+import type { TimelineEvent } from "./types.js";
+import { getRunPlanText } from "./types.js";
+
+export function hasFinalizedTranscriptPlan(events: readonly TimelineEvent[], planText: string | null | undefined): boolean {
+  const expected = planText?.trim() ?? "";
+  if (!expected) return false;
+
+  return events.some((event) => {
+    if (event.type !== "run") return false;
+    if (event.status !== "completed") return false;
+    if (event.plan?.status !== "completed") return false;
+    const transcriptPlan = getRunPlanText(event.plan).trim();
+    return transcriptPlan.length > 0 && transcriptPlan === expected;
+  });
+}

package/src/session/promptRunSchedule.test.ts

@@ -0,0 +1,36 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { schedulePromptRunStartAfterVisibleCommit } from "./promptRunSchedule.js";
+
+function waitForTimerTurn(): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, 0));
+}
+
+test("schedulePromptRunStartAfterVisibleCommit waits past the reducer microtask before starting work", async () => {
+  const order: string[] = [];
+
+  schedulePromptRunStartAfterVisibleCommit(() => {
+    order.push("provider-started");
+  });
+  order.push("visible-run-dispatched");
+
+  await Promise.resolve();
+  assert.deepEqual(order, ["visible-run-dispatched"]);
+
+  await waitForTimerTurn();
+  assert.deepEqual(order, ["visible-run-dispatched", "provider-started"]);
+});
+
+test("schedulePromptRunStartAfterVisibleCommit can be canceled before provider start", async () => {
+  let started = false;
+
+  const cancel = schedulePromptRunStartAfterVisibleCommit(() => {
+    started = true;
+  });
+  cancel();
+
+  await Promise.resolve();
+  await waitForTimerTurn();
+
+  assert.equal(started, false);
+});

package/src/session/promptRunSchedule.ts

@@ -0,0 +1,26 @@
+export type CancelScheduledPromptRunStart = () => void;
+
+export function schedulePromptRunStartAfterVisibleCommit(
+  start: () => void,
+): CancelScheduledPromptRunStart {
+  let cancelled = false;
+  let timer: ReturnType<typeof setTimeout> | null = null;
+
+  queueMicrotask(() => {
+    if (cancelled) return;
+    timer = setTimeout(() => {
+      timer = null;
+      if (!cancelled) {
+        start();
+      }
+    }, 0);
+  });
+
+  return () => {
+    cancelled = true;
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  };
+}

package/src/session/types.ts

@@ -0,0 +1,228 @@
+import type {
+  AuthPreference,
+  AvailableBackend,
+} from "../config/settings.js";
+import type { ResolvedRuntimeConfig } from "../config/runtimeConfig.js";
+import type { RunActivitySummary, RunFileActivity } from "../core/workspaceActivity.js";
+
+// ─── Screen routing ──────────────────────────────────────────────────────────
+
+export type Screen =
+  | "main"
+  | "model-picker"
+  | "mode-picker"
+  | "backend-picker"
+  | "provider-picker"
+  | "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";
+
+// ─── 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;
+}
+
+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/ActionRequiredBlock.tsx

@@ -0,0 +1,38 @@
+import React from "react";
+import { Box, Text } from "ink";
+import { getUsableShellWidth } from "./layout.js";
+import { wrapPlainText } from "./textLayout.js";
+import { useTheme } from "./theme.js";
+
+interface ActionRequiredBlockProps {
+  cols: number;
+  turnIndex: number;
+  question: string;
+}
+
+export function ActionRequiredBlock({ cols, turnIndex, question }: ActionRequiredBlockProps) {
+  const theme = useTheme();
+  const contentWidth = Math.max(1, getUsableShellWidth(cols, 6));
+
+  const wrappedContent = question
+    .split("\n")
+    .flatMap((line) => {
+      const rows = wrapPlainText(line, contentWidth);
+      return rows.length > 0 ? rows : [""];
+    });
+
+  return (
+    <Box borderStyle="single" borderColor={theme.BORDER_ACTIVE} flexDirection="column" marginBottom={1} width="100%">
+      <Box width="100%" justifyContent="space-between" overflow="hidden" paddingX={1}>
+        <Text color={theme.TEXT} bold>{`[${turnIndex}] ACTION REQUIRED`}</Text>
+        <Text color={theme.TEXT} bold>{"⚡"}</Text>
+      </Box>
+      <Box flexDirection="column" paddingX={2} marginTop={1} marginBottom={1} width="100%">
+        <Text color={theme.TEXT} bold>{"Verification Question"}</Text>
+        {wrappedContent.map((row, index) => (
+          <Text key={`content-${index}`} color={theme.TEXT}>{row || " "}</Text>
+        ))}
+      </Box>
+    </Box>
+  );
+}

package/src/ui/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.DIM;
+
+  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/ActivityIndicator.test.tsx

@@ -0,0 +1,58 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import React from "react";
+import { PassThrough } from "node:stream";
+import { render } from "ink";
+import { ActivityIndicator } from "./ActivityIndicator.js";
+
+class TestOutput extends PassThrough {
+  readonly isTTY = true;
+  columns = 120;
+  rows = 40;
+}
+
+function renderIndicator(props: any): Promise<string> {
+  const stdout = new TestOutput();
+  let output = "";
+  stdout.on("data", (chunk) => {
+    output += chunk.toString();
+  });
+  const instance = render(<ActivityIndicator {...props} />, { stdout: stdout as unknown as NodeJS.WriteStream });
+  instance.unmount();
+  return Promise.resolve(output);
+}
+
+test("idle state renders static subtle indicator", async () => {
+  const output = await renderIndicator({ uiState: { kind: "IDLE" }, externalCliStatus: "idle" });
+  assert.ok(output.includes("?"));
+});
+
+test("error state renders error indicator", async () => {
+  const output = await renderIndicator({ uiState: { kind: "ERROR", turnId: 1, message: "err" } });
+  assert.ok(output.includes("�"));
+});
+
+test("tool/action state renders action indicator", async () => {
+  const output = await renderIndicator({ uiState: { kind: "SHELL_RUNNING", shellId: 1 } });
+  assert.ok(output.includes("?"));
+});
+
+test("waiting/thinking state renders animated indicator frame", async () => {
+  const output = await renderIndicator({ uiState: { kind: "THINKING", turnId: 1 } });
+  assert.ok(output.includes("?"));
+});
+
+test("streaming state renders streaming indicator frame", async () => {
+  const output = await renderIndicator({ uiState: { kind: "RESPONDING", turnId: 1 } });
+  assert.ok(output.includes("?")); // first frame
+});
+
+test("provider loading renders animated indicator frame", async () => {
+  const output = await renderIndicator({ uiState: { kind: "IDLE" }, externalCliStatus: "starting" });
+  assert.ok(output.includes("?"));
+});
+
+test("provider failed renders error indicator", async () => {
+  const output = await renderIndicator({ uiState: { kind: "IDLE" }, externalCliStatus: "failed" });
+  assert.ok(output.includes("�"));
+});

package/src/ui/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.DIM;
+  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.DIM;
+  }
+
+  return <Text color={color} bold={bold}>{glyph}</Text>;
+}

package/src/ui/AgentBlock.test.ts

@@ -0,0 +1,6 @@
+import test from "node:test";
+
+test("AgentBlock output streams organically without layout truncation", () => {
+  // buildStreamingPreviewRows has been intentionally removed to support 
+  // true variable-height scrolling transcript behavior per project requirements.
+});