@golba98/codexa 1.0.1 → 1.0.3

package/src/core/providerRuntime/registry.test.ts

@@ -1,233 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import {
-  discoverProviderModels,
-  getProviderRouteSetupMessage,
-  getProviderRuntime,
-  isProviderRouteConfigured,
-  resolveActiveProviderRoute,
-} from "./registry.js";
-import { resetGeminiRouteValidationCacheForTests } from "./gemini.js";
-import { resetAnthropicRouteValidationCacheForTests } from "./anthropic.js";
-import { checkLocalProvider, resetLocalProviderStateForTests } from "./local.js";
-
-test("google runtime exposes configured Gemini models for in-Codexa routing", () => {
-  const runtime = getProviderRuntime("google");
-  const discovery = discoverProviderModels("google");
-
-  assert.equal(runtime.routeAvailable, true);
-  assert.equal(runtime.backendKind, "gemini-cli-auth");
-  assert.equal(discovery.status, "ready");
-  assert.ok(discovery.models.length > 0);
-});
-
-test("anthropic runtime exposes configured Claude models for in-Codexa routing", () => {
-  const runtime = getProviderRuntime("anthropic");
-  const discovery = discoverProviderModels("anthropic");
-
-  assert.equal(runtime.routeAvailable, true);
-  assert.equal(runtime.backendKind, "claude-code-auth");
-  assert.equal(discovery.status, "ready");
-  assert.ok(discovery.models.length > 0);
-});
-
-test("active route resolution preserves routable google routes", () => {
-  const route = resolveActiveProviderRoute({
-    workspaceConfigActiveRoute: {
-      providerId: "google",
-      modelId: "gemini-2.5-pro",
-      backendKind: "gemini-cli-auth",
-      reasoning: "medium",
-    },
-    currentModel: "gpt-5.4",
-    currentReasoning: "high",
-  });
-
-  assert.deepEqual(route, {
-    providerId: "google",
-    modelId: "gemini-2.5-pro",
-    backendKind: "gemini-cli-auth",
-    reasoning: "medium",
-  });
-});
-
-test("active route resolution normalizes legacy Gemini 3 Flash routes to preview", () => {
-  const route = resolveActiveProviderRoute({
-    workspaceConfigActiveRoute: {
-      providerId: "google",
-      modelId: "gemini-3-flash",
-      backendKind: "gemini-cli-auth",
-      reasoning: "high",
-    },
-    currentModel: "gpt-5.4",
-    currentReasoning: "medium",
-  });
-
-  assert.deepEqual(route, {
-    providerId: "google",
-    modelId: "gemini-3-flash-preview",
-    backendKind: "gemini-cli-auth",
-    reasoning: "high",
-  });
-});
-
-test("active route resolution preserves routable anthropic routes", () => {
-  const route = resolveActiveProviderRoute({
-    workspaceConfigActiveRoute: {
-      providerId: "anthropic",
-      modelId: "claude-sonnet-4-20250514",
-      backendKind: "anthropic-api-key",
-      reasoning: "high",
-    },
-    currentModel: "gpt-5.4",
-    currentReasoning: "medium",
-  });
-
-  assert.deepEqual(route, {
-    providerId: "anthropic",
-    modelId: "claude-sonnet-4-20250514",
-    backendKind: "anthropic-api-key",
-    reasoning: "high",
-  });
-});
-
-test("active route resolution preserves routable local routes", async () => {
-  resetLocalProviderStateForTests();
-  await checkLocalProvider({
-    fetchImpl: (async () => new Response(JSON.stringify({
-      data: [{ id: "llama-local" }],
-    }), { status: 200 })) as typeof fetch,
-  });
-  const route = resolveActiveProviderRoute({
-    workspaceConfigActiveRoute: {
-      providerId: "local",
-      modelId: "llama-local",
-      backendKind: "local-openai-compatible",
-    },
-    currentModel: "gpt-5.4",
-    currentReasoning: "high",
-  });
-
-  assert.deepEqual(route, {
-    providerId: "local",
-    modelId: "llama-local",
-    backendKind: "local-openai-compatible",
-  });
-  resetLocalProviderStateForTests();
-});
-
-// ─── CLI --model override precedence ─────────────────────────────────────────
-// These tests mirror the app-level logic: when --model is given on the CLI,
-// the caller constructs effectiveRoute = { ...savedRoute, modelId: cliModel }
-// before passing it to resolveActiveProviderRoute. The tests verify the resolver
-// honours that override correctly.
-
-test("CLI model override wins over persisted OpenAI activeRoute model", () => {
-  // Simulate: providers.json has gpt-5.4-mini, but user ran --model gpt-5.5
-  const cliModel = "gpt-5.5";
-  const savedRoute = {
-    providerId: "openai" as const,
-    modelId: "gpt-5.4-mini",
-    backendKind: "codex-cli-auth" as const,
-    reasoning: "low",
-  };
-  const effectiveRoute = { ...savedRoute, modelId: cliModel };
-
-  const route = resolveActiveProviderRoute({
-    workspaceConfigActiveRoute: effectiveRoute,
-    currentModel: "gpt-5.5",
-    currentReasoning: "low",
-  });
-
-  assert.equal(route.modelId, "gpt-5.5", "CLI model must be used for the run, not providers.json model");
-  assert.equal(route.providerId, "openai");
-});
-
-test("without CLI model override the persisted providers.json activeRoute model is used", () => {
-  const savedRoute = {
-    providerId: "openai" as const,
-    modelId: "gpt-5.4-mini",
-    backendKind: "codex-cli-auth" as const,
-    reasoning: "low",
-  };
-
-  const route = resolveActiveProviderRoute({
-    workspaceConfigActiveRoute: savedRoute,
-    currentModel: "gpt-5.4",
-    currentReasoning: "high",
-  });
-
-  assert.equal(route.modelId, "gpt-5.4-mini", "Without CLI override, persisted model must win over layered-config default");
-});
-
-test("CLI model override preserves provider from providers.json activeRoute", () => {
-  // --model on the CLI should not change the provider, only the modelId
-  const cliModel = "gpt-5.5";
-  const savedRoute = {
-    providerId: "openai" as const,
-    modelId: "gpt-5.4-mini",
-    backendKind: "codex-cli-auth" as const,
-    reasoning: "low",
-  };
-  const effectiveRoute = { ...savedRoute, modelId: cliModel };
-
-  const route = resolveActiveProviderRoute({
-    workspaceConfigActiveRoute: effectiveRoute,
-    currentModel: cliModel,
-    currentReasoning: "low",
-  });
-
-  assert.equal(route.providerId, "openai", "Provider from providers.json must be preserved");
-  assert.equal(route.modelId, cliModel);
-  assert.equal(route.reasoning, "low", "Reasoning from providers.json must be preserved");
-});
-
-// ─── Authentication and setup gates ──────────────────────────────────────────
-
-test("anthropic route configuration is gated by ANTHROPIC_API_KEY or Claude Code", () => {
-  const original = process.env.ANTHROPIC_API_KEY;
-
-  try {
-    delete process.env.ANTHROPIC_API_KEY;
-    resetAnthropicRouteValidationCacheForTests();
-    assert.equal(isProviderRouteConfigured("anthropic"), false);
-    assert.match(getProviderRouteSetupMessage("anthropic"), /set ANTHROPIC_API_KEY/);
-  } finally {
-    if (original) process.env.ANTHROPIC_API_KEY = original;
-  }
-});
-
-test("google route configuration is gated by Gemini API key or validated headless CLI", () => {
-  const originalGemini = process.env.GEMINI_API_KEY;
-  const originalGoogle = process.env.GOOGLE_API_KEY;
-
-  try {
-    delete process.env.GEMINI_API_KEY;
-    delete process.env.GOOGLE_API_KEY;
-    resetGeminiRouteValidationCacheForTests();
-    assert.equal(isProviderRouteConfigured("google"), false);
-    assert.match(getProviderRouteSetupMessage("google"), /GEMINI_API_KEY \/ GOOGLE_API_KEY/);
-  } finally {
-    if (originalGemini) process.env.GEMINI_API_KEY = originalGemini;
-    if (originalGoogle) process.env.GOOGLE_API_KEY = originalGoogle;
-  }
-});
-
-test("local route configuration is gated by endpoint model discovery", async () => {
-  resetLocalProviderStateForTests();
-  assert.equal(isProviderRouteConfigured("local"), false);
-
-  await checkLocalProvider({
-    fetchImpl: (async (input) => {
-      if (String(input).includes("/api/v0/")) {
-        return new Response(null, { status: 404 });
-      }
-      return new Response(JSON.stringify({
-        data: [{ id: "google/gemma-4-26b-a4b" }],
-      }), { status: 200 });
-    }) as typeof fetch,
-  });
-
-  assert.equal(isProviderRouteConfigured("local"), true);
-  resetLocalProviderStateForTests();
-});

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

@@ -1,148 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import type { BackendProgressUpdate } from "./types.js";
-import type { RunToolActivity } from "../../session/types.js";
-import { createCodexJsonStreamParser } from "./codexJsonStream.js";
-
-test("streams incremental agent_message growth as assistant deltas", () => {
-  const assistant: string[] = [];
-  const observedFinalAnswers: string[] = [];
-  const parser = createCodexJsonStreamParser({
-    onAssistantDelta: (chunk) => assistant.push(chunk),
-    onFinalAnswerObserved: (response) => observedFinalAnswers.push(response),
-  });
-
-  assert.equal(parser.feedLine(JSON.stringify({
-    type: "item.started",
-    item: { id: "msg-1", type: "agent_message", text: "Hello" },
-  })), true);
-  assert.equal(parser.feedLine(JSON.stringify({
-    type: "item.updated",
-    item: { id: "msg-1", type: "agent_message", text: "Hello world" },
-  })), true);
-  assert.equal(parser.feedLine(JSON.stringify({
-    type: "item.completed",
-    item: { id: "msg-1", type: "agent_message", text: "Hello world!" },
-  })), true);
-  assert.equal(parser.feedLine(JSON.stringify({
-    type: "turn.completed",
-  })), true);
-
-  assert.deepEqual(assistant, ["Hello", " world", "!"]);
-  assert.deepEqual(observedFinalAnswers, ["Hello world!"]);
-  assert.equal(parser.getFinalResponse(), "Hello world!");
-});
-
-test("surfaces command execution lifecycle as tool activity", () => {
-  const toolActivities: RunToolActivity[] = [];
-  const parser = createCodexJsonStreamParser({
-    onToolActivity: (activity) => toolActivities.push(activity),
-  });
-
-  parser.feedLine(JSON.stringify({
-    type: "item.started",
-    item: {
-      id: "cmd-1",
-      type: "command_execution",
-      command: "rg --files",
-      status: "in_progress",
-      aggregated_output: "",
-    },
-  }));
-  parser.feedLine(JSON.stringify({
-    type: "item.completed",
-    item: {
-      id: "cmd-1",
-      type: "command_execution",
-      command: "rg --files",
-      status: "completed",
-      aggregated_output: "src/app.tsx\nsrc/ui/Timeline.tsx\n",
-      exit_code: 0,
-    },
-  }));
-
-  assert.equal(toolActivities.length, 2);
-  assert.equal(toolActivities[0]?.status, "running");
-  assert.equal(toolActivities[0]?.command, "rg --files");
-  assert.equal(toolActivities[1]?.status, "completed");
-  assert.match(toolActivities[1]?.summary ?? "", /src\/app\.tsx/i);
-});
-
-test("emits progress updates for todo_list and reasoning items", () => {
-  const progress: BackendProgressUpdate[] = [];
-  const parser = createCodexJsonStreamParser({
-    onProgress: (update) => progress.push(update),
-  });
-
-  parser.feedLine(JSON.stringify({
-    type: "item.updated",
-    item: {
-      id: "todo-1",
-      type: "todo_list",
-      items: [
-        { text: "Inspect workspace", completed: true },
-        { text: "Write file", completed: false },
-      ],
-    },
-  }));
-  parser.feedLine(JSON.stringify({
-    type: "item.updated",
-    item: {
-      id: "reason-1",
-      type: "reasoning",
-      text: "Verifying the generated output\n\nChecking edge cases",
-    },
-  }));
-
-  assert.deepEqual(progress, [
-    { id: "todo-1", source: "todo", text: "Todo 1/2: Write file" },
-    { id: "reason-1", source: "reasoning", text: "Verifying the generated output\n\nChecking edge cases" },
-  ]);
-});
-
-test("reuses the same progress id when a structured update grows", () => {
-  const progress: BackendProgressUpdate[] = [];
-  const parser = createCodexJsonStreamParser({
-    onProgress: (update) => progress.push(update),
-  });
-
-  parser.feedLine(JSON.stringify({
-    type: "item.updated",
-    item: {
-      id: "reason-7",
-      type: "reasoning",
-      text: "Inspecting the config",
-    },
-  }));
-  parser.feedLine(JSON.stringify({
-    type: "item.updated",
-    item: {
-      id: "reason-7",
-      type: "reasoning",
-      text: "Inspecting the config\n\nComparing runtime defaults",
-    },
-  }));
-
-  assert.deepEqual(progress, [
-    { id: "reason-7", source: "reasoning", text: "Inspecting the config" },
-    { id: "reason-7", source: "reasoning", text: "Inspecting the config\n\nComparing runtime defaults" },
-  ]);
-});
-
-test("captures turn failures from structured events", () => {
-  const parser = createCodexJsonStreamParser({});
-
-  parser.feedLine(JSON.stringify({
-    type: "turn.failed",
-    error: { message: "Permission denied" },
-  }));
-
-  assert.equal(parser.getFailureMessage(), "Permission denied");
-});
-
-test("returns false for non-json lines so callers can fall back to transcript parsing", () => {
-  const parser = createCodexJsonStreamParser({});
-
-  assert.equal(parser.feedLine("assistant"), false);
-  assert.equal(parser.hasStructuredEvents(), false);
-});

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

@@ -1,68 +0,0 @@
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import test from "node:test";
-
-test("codex subprocess attaches output handlers before writing stdin", () => {
-  const source = readFileSync(fileURLToPath(new URL("./codexSubprocess.ts", import.meta.url)), "utf8");
-  const spawnIndex = source.indexOf("proc = spawnCodexProcess");
-  const stdoutIndex = source.indexOf('proc.stdout?.on("data"', spawnIndex);
-  const stderrIndex = source.indexOf('proc.stderr?.on("data"', spawnIndex);
-  const closeIndex = source.indexOf('proc.on("close"', spawnIndex);
-  const errorIndex = source.indexOf('proc.on("error"', spawnIndex);
-  const stdinWriteIndex = source.indexOf("proc.stdin?.write", spawnIndex);
-
-  assert.notEqual(spawnIndex, -1);
-  assert.notEqual(stdoutIndex, -1);
-  assert.notEqual(stderrIndex, -1);
-  assert.notEqual(closeIndex, -1);
-  assert.notEqual(errorIndex, -1);
-  assert.notEqual(stdinWriteIndex, -1);
-  assert.ok(stdoutIndex < stdinWriteIndex);
-  assert.ok(stderrIndex < stdinWriteIndex);
-  assert.ok(closeIndex < stdinWriteIndex);
-  assert.ok(errorIndex < stdinWriteIndex);
-});
-
-test("codex subprocess supports raw prompt passthrough before wrapped prompt fallback", () => {
-  const source = readFileSync(fileURLToPath(new URL("./codexSubprocess.ts", import.meta.url)), "utf8");
-
-  assert.match(source, /const promptPolicy = options\.promptPolicy \?\? "wrapped"/);
-  assert.match(source, /promptPolicy === "raw"\s+\?\s+prompt\s+:\s+buildCodexPrompt/s);
-});
-
-test("codex subprocess cleanup skips kill after process close", () => {
-  const source = readFileSync(fileURLToPath(new URL("./codexSubprocess.ts", import.meta.url)), "utf8");
-  const closeIndex = source.indexOf('proc.on("close"', source.indexOf("proc = spawnCodexProcess"));
-  const exitedIndex = source.indexOf("procExited = true", closeIndex);
-  const cleanupIndex = source.indexOf("return () =>", exitedIndex);
-  const skipIndex = source.indexOf("!proc || procExited || proc.killed", cleanupIndex);
-  const killIndex = source.indexOf("proc.kill()", cleanupIndex);
-
-  assert.notEqual(closeIndex, -1);
-  assert.notEqual(exitedIndex, -1);
-  assert.notEqual(cleanupIndex, -1);
-  assert.notEqual(skipIndex, -1);
-  assert.notEqual(killIndex, -1);
-  assert.ok(exitedIndex < cleanupIndex);
-  assert.ok(skipIndex < killIndex);
-});
-
-test("codex subprocess reports lifecycle boundaries for terminal title reassertion", () => {
-  const source = readFileSync(fileURLToPath(new URL("./codexSubprocess.ts", import.meta.url)), "utf8");
-  const beforeSpawnIndex = source.indexOf('handlers.onProcessLifecycle?.("before-spawn")');
-  const spawnIndex = source.indexOf("proc = spawnCodexProcess");
-  const spawnedIndex = source.indexOf('handlers.onProcessLifecycle?.("spawned")', spawnIndex);
-  const closeIndex = source.indexOf('proc.on("close"', spawnIndex);
-  const exitIndex = source.indexOf('handlers.onProcessLifecycle?.("exit")', closeIndex);
-  const errorIndex = source.indexOf('proc.on("error"', spawnIndex);
-  const lifecycleErrorIndex = source.indexOf('handlers.onProcessLifecycle?.("error")', errorIndex);
-  const cleanupIndex = source.indexOf("return () =>", spawnedIndex);
-  const lifecycleCleanupIndex = source.indexOf('handlers.onProcessLifecycle?.("cleanup")', cleanupIndex);
-
-  assert.ok(beforeSpawnIndex >= 0 && beforeSpawnIndex < spawnIndex);
-  assert.ok(spawnedIndex > spawnIndex);
-  assert.ok(exitIndex > closeIndex);
-  assert.ok(lifecycleErrorIndex > errorIndex);
-  assert.ok(lifecycleCleanupIndex > cleanupIndex);
-});