@golba98/codexa 1.0.2 → 1.0.4

package/src/core/launchContext.test.ts

@@ -1,157 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "fs";
-import { tmpdir } from "os";
-import { join } from "path";
-import test from "node:test";
-import {
-  buildWorkspaceStatusMessage,
-  createWorkspaceRelaunchPlan,
-  guardWorkspaceRelaunch,
-  resolveLaunchContext,
-} from "./launchContext.js";
-import { normalizeWorkspaceRoot } from "./workspaceRoot.js";
-
-function createTempWorkspace(): string {
-  return mkdtempSync(join(tmpdir(), "codexa-launch-context-"));
-}
-
-test("uses installed launcher metadata when available", () => {
-  const context = resolveLaunchContext({
-    workspaceRoot: "C:/target",
-    packageRoot: "C:/repo",
-    execPath: "C:/Program Files/nodejs/node.exe",
-    env: {
-      CODEXA_LAUNCH_KIND: "installed-bin",
-      CODEXA_PACKAGE_ROOT: "C:/repo",
-      CODEXA_LAUNCHER_SCRIPT: "C:/repo/bin/codexa.js",
-      CODEXA_RELAUNCH_EXECUTABLE: "C:/Program Files/nodejs/node.exe",
-      CODEXA_RELAUNCH_ARGS: JSON.stringify(["C:/repo/bin/codexa.js", "--profile", "review"]),
-    },
-  });
-
-  assert.equal(context.launchKind, "installed-bin");
-  assert.equal(context.packageRoot, "C:\\repo");
-  assert.equal(context.launcherScriptPath, "C:/repo/bin/codexa.js");
-  assert.equal(context.relaunchExecutable, "C:/Program Files/nodejs/node.exe");
-  assert.deepEqual(context.relaunchArgs, ["C:/repo/bin/codexa.js", "--profile", "review"]);
-});
-
-test("falls back to bun repo launch metadata when no installed launcher env exists", () => {
-  const context = resolveLaunchContext({
-    workspaceRoot: "C:/repo",
-    packageRoot: "C:/repo",
-    execPath: "C:/tools/bun.exe",
-    hasBunRuntime: true,
-    forwardArgs: ["--profile", "review", "--config", "model=\"gpt-5.4\""],
-    env: {},
-  });
-
-  assert.equal(context.launchKind, "dev-run");
-  assert.equal(context.relaunchExecutable, "C:/tools/bun.exe");
-  assert.deepEqual(context.relaunchArgs, [
-    "run",
-    "--silent",
-    join("C:\\repo", "src", "index.tsx"),
-    "--",
-    "--profile",
-    "review",
-    "--config",
-    "model=\"gpt-5.4\"",
-  ]);
-});
-
-test("creates an installed-bin relaunch plan with normalized target cwd and env", () => {
-  const root = createTempWorkspace();
-  try {
-    const nextWorkspace = join(root, "next");
-    mkdirSync(nextWorkspace);
-
-    const context = resolveLaunchContext({
-      workspaceRoot: root,
-      packageRoot: "C:/repo",
-      execPath: "C:/Program Files/nodejs/node.exe",
-      env: {
-        CODEXA_LAUNCH_KIND: "installed-bin",
-        CODEXA_PACKAGE_ROOT: "C:/repo",
-        CODEXA_LAUNCHER_SCRIPT: "C:/repo/bin/codexa.js",
-        CODEXA_RELAUNCH_EXECUTABLE: "C:/Program Files/nodejs/node.exe",
-        CODEXA_RELAUNCH_ARGS: JSON.stringify(["C:/repo/bin/codexa.js", "--profile", "review"]),
-      },
-    });
-
-    const result = createWorkspaceRelaunchPlan(".\\next", context, {});
-    assert.equal(result.ok, true);
-    if (!result.ok) return;
-
-    assert.equal(result.plan.executable, "C:/Program Files/nodejs/node.exe");
-    assert.deepEqual(result.plan.args, ["C:/repo/bin/codexa.js", "--profile", "review"]);
-    assert.equal(result.plan.cwd, normalizeWorkspaceRoot(nextWorkspace));
-    assert.equal(result.plan.env.CODEX_WORKSPACE_ROOT, normalizeWorkspaceRoot(nextWorkspace));
-    assert.equal(result.plan.env.CODEXA_LAUNCH_KIND, "installed-bin");
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("rejects relaunch targets that do not exist", () => {
-  const root = createTempWorkspace();
-  try {
-    const context = resolveLaunchContext({
-      workspaceRoot: root,
-      packageRoot: root,
-      execPath: "C:/tools/bun.exe",
-      hasBunRuntime: true,
-      env: {},
-    });
-
-    const result = createWorkspaceRelaunchPlan(".\\missing", context, {});
-    assert.equal(result.ok, false);
-    if (result.ok) return;
-    assert.match(result.message, /does not exist/i);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("rejects relaunch targets that are files instead of directories", () => {
-  const root = createTempWorkspace();
-  try {
-    const fileTarget = join(root, "notes.txt");
-    writeFileSync(fileTarget, "hello", "utf8");
-    const context = resolveLaunchContext({
-      workspaceRoot: root,
-      packageRoot: root,
-      execPath: "C:/tools/bun.exe",
-      hasBunRuntime: true,
-      env: {},
-    });
-
-    const result = createWorkspaceRelaunchPlan(".\\notes.txt", context, {});
-    assert.equal(result.ok, false);
-    if (result.ok) return;
-    assert.match(result.message, /not a directory/i);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("blocks workspace relaunch while busy", () => {
-  assert.deepEqual(guardWorkspaceRelaunch(false), { allowed: true });
-  assert.equal(guardWorkspaceRelaunch(true).allowed, false);
-  assert.match(guardWorkspaceRelaunch(true).message ?? "", /finish the current run/i);
-});
-
-test("describes dev launch mode with install guidance", () => {
-  const message = buildWorkspaceStatusMessage(resolveLaunchContext({
-    workspaceRoot: "C:/repo",
-    packageRoot: "C:/repo",
-    execPath: "C:/tools/bun.exe",
-    hasBunRuntime: true,
-    env: {},
-  }));
-
-  assert.match(message, /Launch mode: dev\/repo launch/i);
-  assert.match(message, /npm link/i);
-  assert.match(message, /where codexa/i);
-  assert.match(message, /\/workspace relaunch <path>/i);
-});

package/src/core/models/codexCapabilities.test.ts

@@ -1,45 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { parseCodexCliCapabilities } from "./codexCapabilities.js";
-
-test("detects exec help flags and strips ANSI noise", () => {
-  const capabilities = parseCodexCliCapabilities(
-    "\u001B[32mOptions:\u001B[0m\n  --ask-for-approval <policy>\n  --sandbox <mode>\n  -c, --config <key=value>\n",
-    "Global options:\n  --ask-for-approval <policy>\n",
-  );
-
-  assert.deepEqual(capabilities, {
-    askForApproval: true,
-    sandbox: true,
-    config: true,
-    fullAuto: false,
-  });
-});
-
-test("does not promote top-level approval flags into exec capabilities", () => {
-  const capabilities = parseCodexCliCapabilities(
-    "Usage: codex exec [OPTIONS]\n  --sandbox <mode>\n  --full-auto\n",
-    "Global options:\n  --ask-for-approval <policy>\n  --sandbox <mode>\n  --full-auto\n",
-  );
-
-  assert.deepEqual(capabilities, {
-    askForApproval: false,
-    sandbox: true,
-    config: false,
-    fullAuto: true,
-  });
-});
-
-test("requires exact option tokens instead of prose guesses", () => {
-  const capabilities = parseCodexCliCapabilities(
-    "This build documents ask-for-approval compatibility in prose only.\nIt also mentions sandbox_mode in config docs.\n",
-    "Use full auto mode for trusted environments.\n",
-  );
-
-  assert.deepEqual(capabilities, {
-    askForApproval: false,
-    sandbox: false,
-    config: false,
-    fullAuto: false,
-  });
-});

package/src/core/models/codexModelCapabilities.test.ts

@@ -1,246 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import {
-  clearCodexModelCapabilityCache,
-  createFallbackModelCapabilities,
-  findModelCapability,
-  formatModelCapabilitiesList,
-  getCodexModelCapabilities,
-  getPreferredModelFromCapabilities,
-  normalizeCodexModelListResponses,
-  normalizeReasoningForModelCapabilities,
-} from "./codexModelCapabilities.js";
-
-const SAMPLE_RESPONSE = {
-  data: [
-    {
-      id: "gpt-5.4",
-      model: "gpt-5.4",
-      displayName: "gpt-5.4",
-      description: "Frontier model",
-      hidden: false,
-      isDefault: true,
-      defaultReasoningEffort: "medium",
-      supportedReasoningEfforts: [
-        { reasoningEffort: "low", description: "Fast" },
-        { reasoningEffort: "medium", description: "Balanced" },
-        { reasoningEffort: "high", description: "Deep" },
-        { reasoningEffort: "xhigh", description: "Deepest" },
-      ],
-    },
-    {
-      id: "gpt-5.1-codex-mini",
-      model: "gpt-5.1-codex-mini",
-      displayName: "Codex Mini",
-      description: "Small model",
-      hidden: false,
-      isDefault: false,
-      defaultReasoningEffort: "medium",
-      supportedReasoningEfforts: [
-        { reasoningEffort: "medium", description: "Dynamic" },
-        { reasoningEffort: "high", description: "Deep" },
-      ],
-    },
-  ],
-  nextCursor: null,
-};
-
-test("normalizes model/list responses with per-model reasoning metadata", () => {
-  const capabilities = normalizeCodexModelListResponses([SAMPLE_RESPONSE], {
-    discoveredAt: 123,
-    executable: "codex.cmd",
-  });
-
-  assert.equal(capabilities.status, "ready");
-  assert.equal(capabilities.source, "runtime");
-  assert.equal(capabilities.executable, "codex.cmd");
-  assert.equal(capabilities.models.length, 2);
-  assert.equal(capabilities.models[0]?.model, "gpt-5.4");
-  assert.equal(capabilities.models[0]?.reasoningLevelCount, 4);
-  assert.deepEqual(capabilities.models[0]?.supportedReasoningLevels?.map((item) => item.id), [
-    "low",
-    "medium",
-    "high",
-    "xhigh",
-  ]);
-  assert.equal(capabilities.models[1]?.label, "Codex Mini");
-  assert.equal(capabilities.models[1]?.reasoningLevelCount, 2);
-});
-
-test("normalization rejects empty or malformed discovery output", () => {
-  assert.throws(
-    () => normalizeCodexModelListResponses([{ data: [] }]),
-    /no usable models/i,
-  );
-  assert.throws(
-    () => normalizeCodexModelListResponses([{ data: [{ id: "", model: "" }] }]),
-    /no usable models/i,
-  );
-});
-
-test("fallback keeps models but does not invent reasoning support", () => {
-  const capabilities = createFallbackModelCapabilities(new Error("offline"), {
-    discoveredAt: 456,
-    executable: "codex.cmd",
-  });
-
-  assert.equal(capabilities.status, "fallback");
-  assert.equal(capabilities.error, "offline");
-  assert.ok(capabilities.models.length > 0);
-  assert.equal(capabilities.models[0]?.available, false);
-  assert.equal(capabilities.models[0]?.supportedReasoningLevels, null);
-  assert.equal(capabilities.models[0]?.reasoningLevelCount, null);
-});
-
-test("normalizes reasoning by keeping valid values and clamping invalid ones", () => {
-  const capabilities = normalizeCodexModelListResponses([SAMPLE_RESPONSE]);
-
-  assert.equal(
-    normalizeReasoningForModelCapabilities("gpt-5.4", "high", capabilities),
-    "high",
-  );
-  assert.equal(
-    normalizeReasoningForModelCapabilities("gpt-5.1-codex-mini", "xhigh", capabilities),
-    "medium",
-  );
-});
-
-test("handles unavailable selected model with runtime default", () => {
-  const capabilities = normalizeCodexModelListResponses([SAMPLE_RESPONSE]);
-
-  assert.equal(getPreferredModelFromCapabilities(capabilities, "missing-model"), "gpt-5.4");
-  assert.equal(findModelCapability(capabilities, "Codex Mini"), null);
-  assert.equal(findModelCapability(capabilities, "gpt-5.1-codex-mini")?.model, "gpt-5.1-codex-mini");
-});
-
-test("formats model list with dynamic reasoning counts", () => {
-  const capabilities = normalizeCodexModelListResponses([SAMPLE_RESPONSE]);
-  const message = formatModelCapabilitiesList(capabilities, "gpt-5.1-codex-mini");
-
-  assert.match(message, /Detected from Codex runtime/i);
-  assert.match(message, /gpt-5\.4.*4 reasoning levels/i);
-  assert.match(message, /gpt-5\.1-codex-mini.*2 reasoning levels.*\*/i);
-});
-
-test("caches successful discovery and refreshes when forced", async () => {
-  clearCodexModelCapabilityCache();
-  let calls = 0;
-
-  const discover = async () => {
-    calls += 1;
-    return normalizeCodexModelListResponses([
-      {
-        data: [
-          {
-            id: `model-${calls}`,
-            model: `model-${calls}`,
-            displayName: `Model ${calls}`,
-            hidden: false,
-            isDefault: true,
-            defaultReasoningEffort: "medium",
-            supportedReasoningEfforts: [{ reasoningEffort: "medium", description: "Default" }],
-          },
-        ],
-      },
-    ], { discoveredAt: calls, executable: "codex" });
-  };
-
-  const first = await getCodexModelCapabilities({
-    executable: "codex",
-    discover,
-    now: () => 100,
-    ttlMs: 1000,
-  });
-  const cached = await getCodexModelCapabilities({
-    executable: "codex",
-    discover,
-    now: () => 200,
-    ttlMs: 1000,
-  });
-  const refreshed = await getCodexModelCapabilities({
-    executable: "codex",
-    discover,
-    forceRefresh: true,
-    now: () => 300,
-    ttlMs: 1000,
-  });
-
-  assert.equal(calls, 2);
-  assert.equal(first.models[0]?.model, "model-1");
-  assert.equal(cached.models[0]?.model, "model-1");
-  assert.equal(refreshed.models[0]?.model, "model-2");
-  clearCodexModelCapabilityCache();
-});
-
-test("concurrent callers share a single in-flight discovery promise", async () => {
-  clearCodexModelCapabilityCache();
-  let calls = 0;
-  let resolveDiscover: (value: unknown) => void = () => {};
-  const gate = new Promise<unknown>((resolve) => {
-    resolveDiscover = resolve;
-  });
-
-  const discover = async () => {
-    calls += 1;
-    await gate;
-    return normalizeCodexModelListResponses([
-      {
-        data: [
-          {
-            id: "model-a",
-            model: "model-a",
-            displayName: "Model A",
-            hidden: false,
-            isDefault: true,
-            defaultReasoningEffort: "medium",
-            supportedReasoningEfforts: [{ reasoningEffort: "medium", description: "Default" }],
-          },
-        ],
-      },
-    ], { discoveredAt: 1, executable: "codex" });
-  };
-
-  const firstPromise = getCodexModelCapabilities({
-    executable: "codex",
-    discover,
-    now: () => 100,
-    ttlMs: 1000,
-  });
-  const secondPromise = getCodexModelCapabilities({
-    executable: "codex",
-    discover,
-    now: () => 100,
-    ttlMs: 1000,
-  });
-  const thirdPromise = getCodexModelCapabilities({
-    executable: "codex",
-    discover,
-    now: () => 100,
-    ttlMs: 1000,
-  });
-
-  resolveDiscover(undefined);
-  const [first, second, third] = await Promise.all([firstPromise, secondPromise, thirdPromise]);
-
-  assert.equal(calls, 1, "discovery should run exactly once when called concurrently");
-  assert.equal(first.models[0]?.model, "model-a");
-  assert.equal(second.models[0]?.model, "model-a");
-  assert.equal(third.models[0]?.model, "model-a");
-  clearCodexModelCapabilityCache();
-});
-
-test("falls back safely when discovery fails", async () => {
-  clearCodexModelCapabilityCache();
-  const capabilities = await getCodexModelCapabilities({
-    executable: "codex",
-    discover: async () => {
-      throw new Error("broken json");
-    },
-    now: () => 100,
-  });
-
-  assert.equal(capabilities.status, "fallback");
-  assert.match(capabilities.error ?? "", /broken json/);
-  assert.equal(capabilities.models[0]?.supportedReasoningLevels, null);
-  clearCodexModelCapabilityCache();
-});