@golba98/codexa 1.0.1 → 1.0.3

package/src/session/chatLifecycle.test.ts

@@ -1,64 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { appendStaticEvents } from "./chatLifecycle.js";
-import type { TimelineEvent } from "./types.js";
-
-test("appendStaticEvents deduplicates consecutive identical system events", () => {
-  const events: TimelineEvent[] = [
-    { id: 1, type: "system", createdAt: 100, title: "T1", content: "C1" },
-  ];
-  const additions: TimelineEvent[] = [
-    { id: 2, type: "system", createdAt: 200, title: "T1", content: "C1" }, // Duplicate
-    { id: 3, type: "system", createdAt: 300, title: "T2", content: "C2" }, // Different
-  ];
-
-  const result = appendStaticEvents(events, additions);
-  assert.equal(result.length, 2);
-  assert.equal(result[0]?.id, 1);
-  assert.equal(result[1]?.id, 3);
-});
-
-test("appendStaticEvents deduplicates consecutive identical error events", () => {
-  const events: TimelineEvent[] = [
-    { id: 1, type: "error", createdAt: 100, title: "E1", content: "M1" },
-  ];
-  const additions: TimelineEvent[] = [
-    { id: 2, type: "error", createdAt: 200, title: "E1", content: "M1" }, // Duplicate
-    { id: 3, type: "error", createdAt: 300, title: "E2", content: "M2" }, // Different
-  ];
-
-  const result = appendStaticEvents(events, additions);
-  assert.equal(result.length, 2);
-  assert.equal(result[0]?.id, 1);
-  assert.equal(result[1]?.id, 3);
-});
-
-test("appendStaticEvents does not deduplicate different event types with same content", () => {
-  const events: TimelineEvent[] = [
-    { id: 1, type: "system", createdAt: 100, title: "Same", content: "Same" },
-  ];
-  const additions: TimelineEvent[] = [
-    { id: 2, type: "error", createdAt: 200, title: "Same", content: "Same" },
-  ];
-
-  const result = appendStaticEvents(events, additions);
-  assert.equal(result.length, 2);
-  assert.equal(result[0]?.id, 1);
-  assert.equal(result[1]?.id, 2);
-});
-
-test("appendStaticEvents does not deduplicate non-consecutive duplicates", () => {
-  const events: TimelineEvent[] = [
-    { id: 1, type: "system", createdAt: 100, title: "T1", content: "C1" },
-  ];
-  const additions: TimelineEvent[] = [
-    { id: 2, type: "system", createdAt: 200, title: "T2", content: "C2" },
-    { id: 3, type: "system", createdAt: 300, title: "T1", content: "C1" }, // Identical to first, but not consecutive
-  ];
-
-  const result = appendStaticEvents(events, additions);
-  assert.equal(result.length, 3);
-  assert.equal(result[0]?.id, 1);
-  assert.equal(result[1]?.id, 2);
-  assert.equal(result[2]?.id, 3);
-});

package/src/session/liveRenderScheduler.test.ts

@@ -1,201 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { createLiveRenderScheduler, type LiveRenderUpdate } from "./liveRenderScheduler.js";
-
-type FakeTimer = {
-  callback: () => void;
-  delayMs: number;
-  cleared: boolean;
-};
-
-function createFakeTimers() {
-  const timers: FakeTimer[] = [];
-  return {
-    timers,
-    setTimer(callback: () => void, delayMs: number) {
-      const timer: FakeTimer = { callback, delayMs, cleared: false };
-      timers.push(timer);
-      return timer as unknown as ReturnType<typeof setTimeout>;
-    },
-    clearTimer(timer: ReturnType<typeof setTimeout>) {
-      (timer as unknown as FakeTimer).cleared = true;
-    },
-  };
-}
-
-function progress(id: string, text: string): LiveRenderUpdate {
-  return { type: "progress", update: { id, source: "reasoning", text } };
-}
-
-function tool(id: string, status: "running" | "completed"): LiveRenderUpdate {
-  return {
-    type: "tool",
-    activity: {
-      id,
-      command: "Get-Content README.md",
-      status,
-      startedAt: 1,
-      completedAt: status === "completed" ? 2 : undefined,
-    },
-  };
-}
-
-test("coalesces adjacent assistant chunks at the cadence flush", () => {
-  const flushed: LiveRenderUpdate[][] = [];
-  const fakeTimers = createFakeTimers();
-  const scheduler = createLiveRenderScheduler({
-    assistantFlushMs: 50,
-    progressOnlyFlushMs: 50,
-    flush: (updates) => flushed.push(updates),
-    setTimer: fakeTimers.setTimer,
-    clearTimer: fakeTimers.clearTimer,
-  });
-
-  scheduler.enqueue({ type: "assistant", chunk: "Hello" });
-  scheduler.enqueue({ type: "assistant", chunk: ", world" });
-
-  assert.equal(flushed.length, 0);
-  assert.equal(fakeTimers.timers.length, 1);
-  assert.equal(fakeTimers.timers[0]?.delayMs, 50);
-  fakeTimers.timers[0]!.callback();
-
-  assert.equal(flushed.length, 1);
-  assert.deepEqual(flushed[0], [{ type: "assistant", chunk: "Hello, world" }]);
-});
-
-test("first progress-only update waits for the progress cadence", () => {
-  const flushed: LiveRenderUpdate[][] = [];
-  const fakeTimers = createFakeTimers();
-  const scheduler = createLiveRenderScheduler({
-    assistantFlushMs: 50,
-    progressOnlyFlushMs: 50,
-    flush: (updates) => flushed.push(updates),
-    setTimer: fakeTimers.setTimer,
-    clearTimer: fakeTimers.clearTimer,
-  });
-
-  scheduler.enqueue(tool("t1", "running"));
-
-  assert.equal(flushed.length, 0);
-  assert.equal(fakeTimers.timers.length, 1);
-  assert.equal(fakeTimers.timers[0]?.delayMs, 50);
-
-  fakeTimers.timers[0]!.callback();
-  assert.deepEqual(flushed[0]?.map((update) => update.type), ["tool"]);
-});
-
-test("preserves event order while keeping only the latest same-id progress update", () => {
-  const flushed: LiveRenderUpdate[][] = [];
-  const scheduler = createLiveRenderScheduler({
-    assistantFlushMs: 50,
-    progressOnlyFlushMs: 50,
-    flush: (updates) => flushed.push(updates),
-  });
-
-  scheduler.enqueue(progress("p1", "Thinking"));
-  scheduler.enqueue(tool("t1", "running"));
-  scheduler.enqueue({ type: "assistant", chunk: "First" });
-  scheduler.enqueue({ type: "assistant", chunk: " segment" });
-  scheduler.enqueue(progress("p1", "Thinking harder"));
-  scheduler.flushNow();
-
-  assert.deepEqual(flushed[0]?.map((update) => update.type), ["progress", "tool", "assistant"]);
-  assert.equal((flushed[0]?.[2] as Extract<LiveRenderUpdate, { type: "assistant" }>).chunk, "First segment");
-  assert.equal((flushed[0]?.[0] as Extract<LiveRenderUpdate, { type: "progress" }>).update.text, "Thinking harder");
-});
-
-test("coalesces repeated keyed progress and tool updates across a noisy flush window", () => {
-  const flushed: LiveRenderUpdate[][] = [];
-  const scheduler = createLiveRenderScheduler({
-    assistantFlushMs: 50,
-    progressOnlyFlushMs: 175,
-    flush: (updates) => flushed.push(updates),
-  });
-
-  scheduler.enqueue(progress("p1", "Reading file 1"));
-  scheduler.enqueue(tool("t1", "running"));
-  scheduler.enqueue(progress("p1", "Reading file 2"));
-  scheduler.enqueue(tool("t1", "completed"));
-  scheduler.enqueue(progress("p2", "Listing files"));
-  scheduler.flushNow();
-
-  assert.deepEqual(flushed[0]?.map((update) => update.type), ["progress", "tool", "progress"]);
-  assert.equal((flushed[0]?.[0] as Extract<LiveRenderUpdate, { type: "progress" }>).update.text, "Reading file 2");
-  assert.equal((flushed[0]?.[1] as Extract<LiveRenderUpdate, { type: "tool" }>).activity.status, "completed");
-});
-
-test("records scheduler flush diagnostics", () => {
-  const flushed: LiveRenderUpdate[][] = [];
-  const fakeTimers = createFakeTimers();
-  const scheduler = createLiveRenderScheduler({
-    assistantFlushMs: 50,
-    progressOnlyFlushMs: 175,
-    flush: (updates) => flushed.push(updates),
-    setTimer: fakeTimers.setTimer,
-    clearTimer: fakeTimers.clearTimer,
-  });
-
-  scheduler.enqueue(progress("p1", "Listing files"));
-  assert.equal(scheduler.getStats().providerEvents, 1);
-  assert.equal(fakeTimers.timers[0]?.delayMs, 175);
-  fakeTimers.timers[0]!.callback();
-
-  scheduler.enqueue({ type: "assistant", chunk: "hello" });
-  assert.equal(fakeTimers.timers[1]?.delayMs, 50);
-  fakeTimers.timers[1]!.callback();
-
-  const stats = scheduler.getStats();
-  assert.equal(stats.providerEvents, 2);
-  assert.equal(stats.flushes, 2);
-  assert.ok(stats.maxFlushIntervalMs >= 0);
-  assert.ok(stats.averageFlushIntervalMs >= 0);
-});
-
-test("prevents reentrant flushes when a producer enqueues during a flush", () => {
-  const flushed: LiveRenderUpdate[][] = [];
-  let inFlush = false;
-  let scheduler: ReturnType<typeof createLiveRenderScheduler>;
-
-  scheduler = createLiveRenderScheduler({
-    assistantFlushMs: 50,
-    progressOnlyFlushMs: 50,
-    flush: (updates) => {
-      assert.equal(inFlush, false, "flush should not reenter itself");
-      inFlush = true;
-      flushed.push(updates);
-      if (flushed.length === 1) {
-        scheduler.enqueue({ type: "assistant", chunk: "queued during flush" });
-      }
-      inFlush = false;
-    },
-  });
-
-  scheduler.enqueue({ type: "assistant", chunk: "first" });
-
-  assert.equal(scheduler.flushNow(), true);
-  assert.equal(flushed.length, 2);
-  assert.equal((flushed[0]?.[0] as Extract<LiveRenderUpdate, { type: "assistant" }>).chunk, "first");
-  assert.equal((flushed[1]?.[0] as Extract<LiveRenderUpdate, { type: "assistant" }>).chunk, "queued during flush");
-});
-
-test("flushNow drains queued updates before finalization", () => {
-  const flushed: LiveRenderUpdate[][] = [];
-  const fakeTimers = createFakeTimers();
-  const scheduler = createLiveRenderScheduler({
-    assistantFlushMs: 50,
-    progressOnlyFlushMs: 50,
-    flush: (updates) => flushed.push(updates),
-    setTimer: fakeTimers.setTimer,
-    clearTimer: fakeTimers.clearTimer,
-  });
-
-  scheduler.enqueue({ type: "assistant", chunk: "final chunk" });
-
-  assert.equal(scheduler.flushNow(), true);
-  assert.equal(flushed.length, 1);
-  assert.equal(scheduler.hasPendingUpdates(), false);
-
-  assert.equal(fakeTimers.timers[0]?.cleared, true);
-  fakeTimers.timers[0]?.callback();
-  assert.equal(flushed.length, 1);
-});

package/src/session/planFlow.test.ts

@@ -1,103 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import {
-  approvePlanExecution,
-  beginPlanFeedback,
-  cancelPlanFeedback,
-  createInitialPlanFlowState,
-  finishPlanGeneration,
-  resetPlanFlow,
-  startPlanGeneration,
-  submitPlanFeedback,
-} from "./planFlow.js";
-
-test("starts a fresh plan generation flow from idle", () => {
-  const state = startPlanGeneration("Build a hello world script", "auto-edit");
-
-  assert.deepEqual(createInitialPlanFlowState(), { kind: "idle" });
-  assert.equal(state.kind, "generating");
-  assert.equal(state.originalPrompt, "Build a hello world script");
-  assert.equal(state.executionMode, "auto-edit");
-  assert.deepEqual(state.constraints, []);
-  assert.equal(state.planFilePath, null);
-  assert.equal(state.currentPlan, null);
-  assert.equal(state.pendingFeedback, null);
-});
-
-test("finishes plan generation into an awaiting-action state with a plan file path", () => {
-  const state = finishPlanGeneration(
-    startPlanGeneration("Build a hello world script", "auto-edit"),
-    "## Files\n- hello_world.py",
-    "C:\\Workspace\\.codexa\\last-plan.md",
-  );
-
-  assert.equal(state.kind, "awaiting_action");
-  assert.equal(state.currentPlan, "## Files\n- hello_world.py");
-  assert.equal(state.planFilePath, "C:\\Workspace\\.codexa\\last-plan.md");
-});
-
-test("revising the plan keeps constraints and records revision feedback", () => {
-  const awaiting = finishPlanGeneration(
-    startPlanGeneration("Build a hello world script", "auto-edit"),
-    "Plan v1",
-    "C:\\Workspace\\.codexa\\last-plan.md",
-  );
-  const collecting = beginPlanFeedback(awaiting, "revise");
-  const generating = submitPlanFeedback(collecting, "Keep it to a single file.");
-
-  assert.equal(collecting.kind, "collecting_feedback");
-  assert.equal(collecting.mode, "revise");
-  assert.equal(generating.kind, "generating");
-  assert.equal(generating.currentPlan, "Plan v1");
-  assert.equal(generating.planFilePath, "C:\\Workspace\\.codexa\\last-plan.md");
-  assert.deepEqual(generating.constraints, []);
-  assert.deepEqual(generating.pendingFeedback, {
-    mode: "revise",
-    text: "Keep it to a single file.",
-  });
-});
-
-test("adding constraints accumulates them before the next plan pass", () => {
-  const awaiting = finishPlanGeneration(
-    startPlanGeneration("Build a hello world script", "auto-edit"),
-    "Plan v1",
-    "C:\\Workspace\\.codexa\\last-plan.md",
-  );
-  const collecting = beginPlanFeedback(awaiting, "constraints");
-  const generating = submitPlanFeedback(collecting, "Do not touch any other files.");
-
-  assert.equal(generating.kind, "generating");
-  assert.deepEqual(generating.constraints, ["Do not touch any other files."]);
-  assert.deepEqual(generating.pendingFeedback, {
-    mode: "constraints",
-    text: "Do not touch any other files.",
-  });
-});
-
-test("canceling feedback returns to the action picker without losing the plan", () => {
-  const awaiting = finishPlanGeneration(
-    startPlanGeneration("Build a hello world script", "auto-edit"),
-    "Plan v1",
-    "C:\\Workspace\\.codexa\\last-plan.md",
-  );
-  const collecting = beginPlanFeedback(awaiting, "revise");
-  const canceled = cancelPlanFeedback(collecting);
-
-  assert.equal(canceled.kind, "awaiting_action");
-  assert.equal(canceled.currentPlan, "Plan v1");
-  assert.equal(canceled.planFilePath, "C:\\Workspace\\.codexa\\last-plan.md");
-});
-
-test("approving execution moves to executing and reset returns to idle", () => {
-  const awaiting = finishPlanGeneration(
-    startPlanGeneration("Build a hello world script", "auto-edit"),
-    "Plan v1",
-    "C:\\Workspace\\.codexa\\last-plan.md",
-  );
-  const executing = approvePlanExecution(awaiting);
-
-  assert.equal(executing.kind, "executing");
-  assert.equal(executing.executionMode, "auto-edit");
-  assert.equal(executing.planFilePath, "C:\\Workspace\\.codexa\\last-plan.md");
-  assert.deepEqual(resetPlanFlow(), { kind: "idle" });
-});

package/src/session/planTranscript.test.ts

@@ -1,65 +0,0 @@
-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/promptRunSchedule.test.ts

@@ -1,36 +0,0 @@
-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/ui/ActivityIndicator.test.tsx

@@ -1,58 +0,0 @@
-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/AgentBlock.test.ts

@@ -1,6 +0,0 @@
-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.
-});

package/src/ui/AnimatedStatusText.test.ts

@@ -1,16 +0,0 @@
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { dirname, join } from "node:path";
-import test from "node:test";
-
-const here = dirname(fileURLToPath(import.meta.url));
-
-test("busy status text owns the local animation timer", () => {
-  const source = readFileSync(join(here, "AnimatedStatusText.tsx"), "utf8");
-
-  assert.match(source, /setInterval/);
-  assert.match(source, /useEffect/);
-  assert.match(source, /useState/);
-  assert.doesNotMatch(source, /useAnimatedDots|useThrottledValue/);
-});