@golba98/codexa 1.0.2 → 1.0.4

package/src/core/providers/codexTranscript.test.ts

@@ -1,284 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import type { RunToolActivity } from "../../session/types.js";
-import {
-  createCodexTranscriptStreamParser,
-  sanitizeCodexTranscript,
-  stripNonPrintableControls,
-} from "./codexTranscript.js";
-
-test("extracts the assistant reply from noisy codex transcript output", () => {
-  const raw = [
-    "Reading additional input from stdin...",
-    "OpenAI Codex v0.118.0 (research preview)",
-    "--------",
-    "workdir: C:\\Development\\1-JavaScript\\13-Custom CLI",
-    "model: gpt-5.4",
-    "provider: openai",
-    "approval: never",
-    "sandbox: read-only",
-    "reasoning effort: xhigh",
-    "reasoning summaries: none",
-    "session id: 019d4984-90c0-7402-80c9-3d55a8e0373f",
-    "--------",
-    "user",
-    "Hello",
-    "codex",
-    "Hello. What do you need help with?",
-    "tokens used",
-    "1,390",
-    "Hello. What do you need help with?",
-  ].join("\n");
-
-  assert.equal(sanitizeCodexTranscript(raw), "Hello. What do you need help with?");
-});
-
-test("falls back to filtered plain output when no labeled assistant block exists", () => {
-  const raw = [
-    "\u001b[32mOpenAI Codex v0.118.0\u001b[0m",
-    "--------",
-    "workdir: C:\\repo",
-    "",
-    "First useful line",
-    "Second useful line",
-  ].join("\n");
-
-  assert.equal(sanitizeCodexTranscript(raw), "First useful line\nSecond useful line");
-});
-
-test("filters echoed clarification-policy prompt lines from finalized transcripts", () => {
-  const raw = [
-    "default to best-effort continuation instead of stopping for clarification.",
-    "if a detail is missing but non-critical, make the most reasonable assumption and state it briefly.",
-    "if multiple paths are possible, choose one sensible path and continue.",
-    "only ask a blocking follow-up question if proceeding would likely use the wrong file, wrong command, destructive behavior, or produce fundamentally incorrect output.",
-    "if you are truly blocked on one critical missing fact, end the response with exactly one line in this format: [QUESTION]: <your question>",
-    "",
-    "Implemented the fix and assumed src/app.tsx was the target entrypoint.",
-  ].join("\n");
-
-  assert.equal(
-    sanitizeCodexTranscript(raw),
-    "Implemented the fix and assumed src/app.tsx was the target entrypoint.",
-  );
-});
-
-test("returns a readable fallback when only noise is present", () => {
-  const raw = [
-    "Reading additional input from stdin...",
-    "OpenAI Codex v0.118.0",
-    "--------",
-    "model: gpt-5.4",
-    "provider: openai",
-  ].join("\n");
-
-  assert.match(
-    sanitizeCodexTranscript(raw),
-    /no assistant response text was detected/i,
-  );
-});
-
-test("streams thinking lines separately from assistant deltas", () => {
-  const thinking: string[] = [];
-  const assistant: string[] = [];
-  const parser = createCodexTranscriptStreamParser({
-    onThinkingLine: (line) => thinking.push(line),
-    onAssistantDelta: (chunk) => assistant.push(chunk),
-  });
-
-  parser.feed([
-    "OpenAI Codex v0.118.0",
-    "Checking src/app.tsx",
-    "Task:",
-    "Refactor the CLI",
-    "",
-    "assistant",
-    "First line",
-    "Second line",
-  ].join("\n"));
-  parser.flush();
-
-  assert.deepEqual(thinking, ["Checking src/app.tsx"]);
-  assert.deepEqual(assistant, ["First line", "\nSecond line"]);
-});
-
-test("emits fenced code blocks atomically when streaming", () => {
-  const assistant: string[] = [];
-  const parser = createCodexTranscriptStreamParser({
-    onAssistantDelta: (chunk) => assistant.push(chunk),
-  });
-
-  parser.feed("assistant\n```ts\n");
-  parser.feed("const value = 1;\n");
-  parser.feed("```\n");
-  parser.flush();
-
-  // Code fences are buffered and emitted as a single atomic chunk
-  assert.deepEqual(assistant, ["```ts\nconst value = 1;\n```"]);
-});
-
-test("emits tool activity separately from assistant prose while streaming", () => {
-  const assistant: string[] = [];
-  const toolActivity: RunToolActivity[] = [];
-  const parser = createCodexTranscriptStreamParser({
-    onAssistantDelta: (chunk) => assistant.push(chunk),
-    onToolActivity: (activity) => toolActivity.push(activity),
-  });
-
-  parser.feed([
-    "assistant",
-    "$ rg --files",
-    "src/app.tsx",
-    "src/ui/BottomComposer.tsx",
-    "",
-    "I found the relevant files.",
-  ].join("\n"));
-  parser.flush();
-
-  assert.deepEqual(assistant, ["I found the relevant files."]);
-  assert.equal(toolActivity.length, 2);
-  assert.equal(toolActivity[0]?.command, "rg --files");
-  assert.equal(toolActivity[0]?.status, "running");
-  assert.equal(toolActivity[1]?.command, "rg --files");
-  assert.equal(toolActivity[1]?.status, "completed");
-  assert.equal(toolActivity[1]?.summary, "Found 2 files");
-});
-
-test("removes tool execution stdout from the finalized assistant transcript", () => {
-  const raw = [
-    "assistant",
-    "$ rg --files",
-    "src/app.tsx",
-    "src/ui/BottomComposer.tsx",
-    "",
-    "I found the relevant files and updated the composer.",
-  ].join("\n");
-
-  assert.equal(
-    sanitizeCodexTranscript(raw),
-    "I found the relevant files and updated the composer.",
-  );
-});
-
-// ─── Progressive streaming tests ──────────────────────────────────────────────
-
-test("emits partial lines after timeout when no newline arrives", async () => {
-  const assistant: string[] = [];
-  const parser = createCodexTranscriptStreamParser({
-    onAssistantDelta: (chunk) => assistant.push(chunk),
-  });
-
-  parser.feed("assistant\n");
-  parser.feed("Hello wor");
-  // No newline yet — partial flush timer should fire after ~100ms
-  assert.equal(assistant.length, 0);
-
-  await new Promise((resolve) => setTimeout(resolve, 150));
-  assert.equal(assistant.length, 1);
-  assert.equal(assistant[0], "Hello wor");
-
-  parser.flush();
-  // flush should not re-emit the already-emitted partial
-  assert.equal(assistant.length, 1);
-});
-
-test("does not duplicate content when partial is followed by complete line", async () => {
-  const assistant: string[] = [];
-  const parser = createCodexTranscriptStreamParser({
-    onAssistantDelta: (chunk) => assistant.push(chunk),
-  });
-
-  parser.feed("assistant\n");
-  parser.feed("Start of line");
-  // Wait for partial flush
-  await new Promise((resolve) => setTimeout(resolve, 150));
-  assert.equal(assistant.length, 1);
-  assert.equal(assistant[0], "Start of line");
-
-  // Now the rest of the line arrives with newline
-  parser.feed(" and the rest\n");
-  // The partial was already emitted; the remaining text appends naturally
-  // The feed should process the complete line that includes both parts
-  assert.ok(assistant.length >= 1);
-
-  parser.flush();
-});
-
-test("code fence with prose before and after emits prose immediately and fence atomically", () => {
-  const assistant: string[] = [];
-  const parser = createCodexTranscriptStreamParser({
-    onAssistantDelta: (chunk) => assistant.push(chunk),
-  });
-
-  parser.feed("assistant\nHere is the code:\n```ts\nconst x = 1;\n```\nDone.\n");
-  parser.flush();
-
-  assert.equal(assistant.length, 3);
-  assert.equal(assistant[0], "Here is the code:");
-  assert.equal(assistant[1], "\n```ts\nconst x = 1;\n```");
-  assert.equal(assistant[2], "\nDone.");
-});
-
-test("code fence safety timeout emits buffered content after 3 seconds", async () => {
-  const assistant: string[] = [];
-  const parser = createCodexTranscriptStreamParser({
-    onAssistantDelta: (chunk) => assistant.push(chunk),
-  });
-
-  parser.feed("assistant\n```ts\nconst x = 1;\n");
-  // No closing fence — wait for safety timeout (3s)
-  // We'll test that flush() force-emits instead of waiting the full 3s
-  assert.equal(assistant.length, 0);
-
-  parser.flush();
-  assert.equal(assistant.length, 1);
-  assert.equal(assistant[0], "```ts\nconst x = 1;");
-});
-
-test("auto-promotes long prose lines from preamble to assistant section", () => {
-  const thinking: string[] = [];
-  const assistant: string[] = [];
-  const parser = createCodexTranscriptStreamParser({
-    onThinkingLine: (line) => thinking.push(line),
-    onAssistantDelta: (chunk) => assistant.push(chunk),
-  });
-
-  parser.feed([
-    "I have analyzed the codebase and here is a comprehensive summary of all the changes that need to be made to fix this issue.",
-  ].join("\n"));
-  parser.flush();
-
-  // Long prose with many words should auto-promote to assistant
-  assert.equal(thinking.length, 0);
-  assert.equal(assistant.length, 1);
-  assert.match(assistant[0]!, /analyzed the codebase/);
-});
-
-test("does not auto-promote short status lines from preamble", () => {
-  const thinking: string[] = [];
-  const assistant: string[] = [];
-  const parser = createCodexTranscriptStreamParser({
-    onThinkingLine: (line) => thinking.push(line),
-    onAssistantDelta: (chunk) => assistant.push(chunk),
-  });
-
-  parser.feed("Checking src/app.tsx\n");
-  parser.flush();
-
-  assert.equal(thinking.length, 1);
-  assert.equal(assistant.length, 0);
-});
-
-test("strips control characters from streamed and finalized assistant text", () => {
-  const assistant: string[] = [];
-  const parser = createCodexTranscriptStreamParser({
-    onAssistantDelta: (chunk) => assistant.push(chunk),
-  });
-
-  parser.feed("assistant\nHello\u0007 world\u0001\n");
-  parser.flush();
-
-  assert.deepEqual(assistant, ["Hello world"]);
-  assert.equal(stripNonPrintableControls("A\u0000B\u001fC"), "ABC");
-  assert.equal(sanitizeCodexTranscript("assistant\nDone\u0007\n"), "Done");
-});

package/src/core/terminal/startupClear.test.ts

@@ -1,55 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { performStartupClear } from "./startupClear.js";
-
-function makeCapture(): { written: string[]; write: (chunk: string) => boolean } {
-  const written: string[] = [];
-  return { written, write: (chunk) => { written.push(chunk); return true; } };
-}
-
-const TRANSCRIPT_CLEAR = "\x1b[2J\x1b[3J\x1b[H";
-
-test("emits full transcript clear in normal interactive mode", () => {
-  const cap = makeCapture();
-  performStartupClear({ write: cap.write, noClear: false, env: {} });
-  assert.deepEqual(cap.written, [TRANSCRIPT_CLEAR]);
-});
-
-test("skips clear when noClear flag is true (--no-clear)", () => {
-  const cap = makeCapture();
-  performStartupClear({ write: cap.write, noClear: true, env: {} });
-  assert.equal(cap.written.length, 0);
-});
-
-test("skips clear when CODEXA_NO_CLEAR=1 env var is set", () => {
-  const cap = makeCapture();
-  performStartupClear({ write: cap.write, noClear: false, env: { CODEXA_NO_CLEAR: "1" } });
-  assert.equal(cap.written.length, 0);
-});
-
-test("noClear flag takes precedence over unset env var", () => {
-  const cap = makeCapture();
-  performStartupClear({ write: cap.write, noClear: true, env: { CODEXA_NO_CLEAR: "0" } });
-  assert.equal(cap.written.length, 0);
-});
-
-test("emits clear when CODEXA_NO_CLEAR is not '1'", () => {
-  const cap = makeCapture();
-  performStartupClear({ write: cap.write, noClear: false, env: { CODEXA_NO_CLEAR: "0" } });
-  assert.deepEqual(cap.written, [TRANSCRIPT_CLEAR]);
-});
-
-test("emits clear when CODEXA_NO_CLEAR is undefined", () => {
-  const cap = makeCapture();
-  performStartupClear({ write: cap.write, noClear: false, env: { CODEXA_NO_CLEAR: undefined } });
-  assert.deepEqual(cap.written, [TRANSCRIPT_CLEAR]);
-});
-
-test("clear sequence includes viewport clear, scrollback clear, and cursor home", () => {
-  const cap = makeCapture();
-  performStartupClear({ write: cap.write, noClear: false, env: {} });
-  const seq = cap.written[0] ?? "";
-  assert.ok(seq.includes("\x1b[2J"), "must include viewport clear");
-  assert.ok(seq.includes("\x1b[3J"), "must include scrollback clear");
-  assert.ok(seq.includes("\x1b[H"), "must include cursor home");
-});

package/src/core/terminal/terminalCapabilities.test.ts

@@ -1,93 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { getTerminalCapability } from "./terminalCapabilities.js";
-
-test("allows Windows Terminal", () => {
-  const result = getTerminalCapability({
-    stdinIsTTY: true,
-    stdoutIsTTY: true,
-    platform: "win32",
-    env: { WT_SESSION: "1" },
-  });
-
-  assert.equal(result.supported, true);
-  assert.equal(result.reason, "supported");
-  assert.equal(result.warning, undefined);
-});
-
-test("allows the VS Code terminal", () => {
-  const result = getTerminalCapability({
-    stdinIsTTY: true,
-    stdoutIsTTY: true,
-    platform: "win32",
-    env: { TERM_PROGRAM: "vscode" },
-  });
-
-  assert.equal(result.supported, true);
-  assert.equal(result.reason, "supported");
-  assert.equal(result.warning, undefined);
-});
-
-test("allows modern Windows TTY when TERM is missing but warns", () => {
-  const result = getTerminalCapability({
-    stdinIsTTY: true,
-    stdoutIsTTY: true,
-    platform: "win32",
-    env: {},
-  });
-
-  assert.equal(result.supported, true);
-  assert.equal(result.reason, "supported");
-  assert.match(result.warning ?? "", /continue/i);
-});
-
-test("CODEXA_FORCE_VT bypasses VT compatibility detection", () => {
-  const result = getTerminalCapability({
-    stdinIsTTY: true,
-    stdoutIsTTY: true,
-    platform: "win32",
-    env: { CODEXA_FORCE_VT: "1", TERM: "dumb" },
-  });
-
-  assert.equal(result.supported, true);
-  assert.equal(result.reason, "supported");
-  assert.equal(result.warning, undefined);
-});
-
-test("CODEXA_REQUIRE_VT hard-fails when Windows VT support is not detected", () => {
-  const result = getTerminalCapability({
-    stdinIsTTY: true,
-    stdoutIsTTY: true,
-    platform: "win32",
-    env: { CODEXA_REQUIRE_VT: "1" },
-  });
-
-  assert.equal(result.supported, false);
-  assert.equal(result.reason, "unsupported-terminal");
-  assert.match(result.message, /CODEXA_FORCE_VT=1/i);
-});
-
-test("rejects a dumb terminal even when it is interactive", () => {
-  const result = getTerminalCapability({
-    stdinIsTTY: true,
-    stdoutIsTTY: true,
-    platform: "linux",
-    env: { TERM: "dumb" },
-  });
-
-  assert.equal(result.supported, false);
-  assert.equal(result.reason, "unsupported-terminal");
-});
-
-test("rejects redirected or non-interactive output", () => {
-  const result = getTerminalCapability({
-    stdinIsTTY: true,
-    stdoutIsTTY: false,
-    platform: "linux",
-    env: { TERM: "xterm-256color" },
-  });
-
-  assert.equal(result.supported, false);
-  assert.equal(result.reason, "notty");
-  assert.match(result.message, /interactive terminal/i);
-});

package/src/core/terminal/terminalControl.test.ts

@@ -1,75 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { createTerminalModeController, setTerminalControlUIState, TERMINAL_SEQUENCES, writeTerminalControl } from "./terminalControl.js";
-
-test("mouse reporting enables only normal mouse tracking with SGR coordinates", () => {
-  let writes = "";
-  const controller = createTerminalModeController((chunk) => {
-    writes += chunk;
-  });
-
-  controller.setMouseReporting(true, "test");
-
-  assert.equal(writes, "\x1b[?1000h\x1b[?1006h");
-  assert.equal(TERMINAL_SEQUENCES.mouseEnable, "\x1b[?1000h\x1b[?1006h");
-  assert.doesNotMatch(writes, /\x1b\[\?1002h|\x1b\[\?1003h|\x1b\[\?1004h|\x1b\[\?1005h|\x1b\[\?1015h/);
-  assert.doesNotMatch(writes, /\x1b\[\?1049h|\x1b\[\?1049l|\x1b\[3J/);
-});
-
-test("mouse reporting cleanup disables broad modes defensively", () => {
-  let writes = "";
-  const controller = createTerminalModeController((chunk) => {
-    writes += chunk;
-  });
-
-  controller.setMouseReporting(false, "test");
-
-  assert.match(writes, /\x1b\[\?1000l/);
-  assert.match(writes, /\x1b\[\?1002l/);
-  assert.match(writes, /\x1b\[\?1003l/);
-  assert.match(writes, /\x1b\[\?1006l/);
-  assert.match(writes, /\x1b\[\?1015l/);
-});
-
-test("post-startup viewport clears are blocked except for transcript clear", () => {
-  let writes = "";
-  const write = (chunk: string) => {
-    writes += chunk;
-  };
-
-  writeTerminalControl(write, "stdout", "test:resize", TERMINAL_SEQUENCES.viewportClear);
-  assert.equal(writes, "");
-
-  writeTerminalControl(write, "stdout", "test:transcriptClear", TERMINAL_SEQUENCES.transcriptClear);
-  assert.equal(writes, TERMINAL_SEQUENCES.transcriptClear);
-  assert.match(writes, /\x1b\[3J/);
-});
-
-test("terminal controller exposes an intentional transcript clear with scrollback erase", () => {
-  let writes = "";
-  const controller = createTerminalModeController((chunk) => {
-    writes += chunk;
-  });
-
-  controller.clearTranscript("test");
-
-  assert.equal(writes, TERMINAL_SEQUENCES.transcriptClear);
-  assert.match(writes, /\x1b\[2J/);
-  assert.match(writes, /\x1b\[3J/);
-  assert.match(writes, /\x1b\[H/);
-});
-
-test("transcript clear is allowed while streaming state is active", () => {
-  let writes = "";
-  setTerminalControlUIState("RESPONDING");
-
-  try {
-    writeTerminalControl((chunk) => {
-      writes += chunk;
-    }, "stdout", "test:transcriptClear", TERMINAL_SEQUENCES.transcriptClear);
-  } finally {
-    setTerminalControlUIState("IDLE");
-  }
-
-  assert.equal(writes, TERMINAL_SEQUENCES.transcriptClear);
-});

package/src/core/terminal/terminalSanitize.test.ts

@@ -1,22 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import {
-  sanitizeTerminalInput,
-  sanitizeTerminalLines,
-  sanitizeTerminalOutput,
-} from "./terminalSanitize.js";
-
-test("sanitizeTerminalOutput strips ANSI/OSC/control bytes and normalizes line breaks", () => {
-  const raw = "A\u001B[31mred\u001B[0m\u001B]0;title\u0007\r\nB\rC\u0007";
-  assert.equal(sanitizeTerminalOutput(raw), "Ared\nB\nC");
-});
-
-test("sanitizeTerminalInput removes layout-breaking escapes", () => {
-  const raw = "hello\u001B[2J\u001B[H\tworld";
-  assert.equal(sanitizeTerminalInput(raw), "hello  world");
-});
-
-test("sanitizeTerminalLines sanitizes and drops empty lines", () => {
-  const lines = ["\u001B[32mok\u001B[0m", " \u0007", "next\rline"];
-  assert.deepEqual(sanitizeTerminalLines(lines), ["ok", "next\nline"]);
-});

package/src/core/terminal/terminalSelection.test.ts

@@ -1,42 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { getTerminalSelectionProfile } from "./terminalSelection.js";
-
-test("detects Windows Terminal selection override", () => {
-  const profile = getTerminalSelectionProfile({ WT_SESSION: "abc", TERM_PROGRAM: "vscode" }, "win32");
-
-  assert.equal(profile.id, "windows-terminal");
-  assert.equal(profile.shortHint, "Shift+drag selects");
-  assert.match(profile.selectionHint, /Shift\+drag to select instantly/i);
-});
-
-test("detects VS Code selection override on Windows and Linux", () => {
-  const windows = getTerminalSelectionProfile({ TERM_PROGRAM: "vscode" }, "win32");
-  const linux = getTerminalSelectionProfile({ TERM_PROGRAM: "vscode" }, "linux");
-
-  assert.equal(windows.id, "vscode");
-  assert.equal(windows.shortHint, "Alt+drag selects");
-  assert.equal(linux.shortHint, "Alt+drag selects");
-});
-
-test("detects VS Code macOS option-drag wording", () => {
-  const profile = getTerminalSelectionProfile({ TERM_PROGRAM: "vscode" }, "darwin");
-
-  assert.equal(profile.id, "vscode");
-  assert.equal(profile.shortHint, "Option+drag selects");
-});
-
-test("falls back to xterm-compatible Shift selection", () => {
-  const profile = getTerminalSelectionProfile({ TERM: "xterm-256color" }, "linux");
-
-  assert.equal(profile.id, "xterm-like");
-  assert.equal(profile.shortHint, "Shift+drag selects");
-});
-
-test("unknown VT terminals get a practical default hint", () => {
-  const profile = getTerminalSelectionProfile({}, "linux");
-
-  assert.equal(profile.id, "unknown-vt");
-  assert.equal(profile.shortHint, "Shift+drag selects");
-  assert.match(profile.selectionHint, /terminal mouse-selection override/i);
-});