@golba98/codexa 1.0.1

package/src/config/launchArgs.test.ts

@@ -0,0 +1,158 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { parseLaunchArgs } from "./launchArgs.js";
+
+test("parses profile and repeated config overrides", () => {
+  const parsed = parseLaunchArgs([
+    "--profile",
+    "review",
+    "--config",
+    "model=\"gpt-5.4\"",
+    "-c",
+    "codexa.mode=\"suggest\"",
+  ]);
+
+  assert.equal(parsed.ok, true);
+  if (!parsed.ok) return;
+
+  assert.equal(parsed.value.help, false);
+  assert.equal(parsed.value.version, false);
+  assert.equal(parsed.value.initialPrompt, null);
+  assert.equal(parsed.value.profile, "review");
+  assert.deepEqual(parsed.value.configOverrides, [
+    "model=\"gpt-5.4\"",
+    "codexa.mode=\"suggest\"",
+  ]);
+  assert.deepEqual(parsed.value.passthroughArgs, [
+    "--profile",
+    "review",
+    "--config",
+    "model=\"gpt-5.4\"",
+    "-c",
+    "codexa.mode=\"suggest\"",
+  ]);
+});
+
+test("rejects missing profile values", () => {
+  const parsed = parseLaunchArgs(["--profile"]);
+  assert.equal(parsed.ok, false);
+  if (parsed.ok) return;
+  assert.match(parsed.error, /--profile/i);
+});
+
+test("rejects malformed config payloads", () => {
+  const parsed = parseLaunchArgs(["--config", "model"]);
+  assert.equal(parsed.ok, false);
+  if (parsed.ok) return;
+  assert.match(parsed.error, /key=value/i);
+});
+
+test("parses inline profile and config assignments", () => {
+  const parsed = parseLaunchArgs([
+    "--profile=review",
+    "--config=model=\"gpt-5.4-mini\"",
+    "-c=codexa.mode=\"auto-edit\"",
+  ]);
+
+  assert.equal(parsed.ok, true);
+  if (!parsed.ok) return;
+
+  assert.equal(parsed.value.profile, "review");
+  assert.deepEqual(parsed.value.configOverrides, [
+    "model=\"gpt-5.4-mini\"",
+    "codexa.mode=\"auto-edit\"",
+  ]);
+  assert.deepEqual(parsed.value.passthroughArgs, [
+    "--profile=review",
+    "--config=model=\"gpt-5.4-mini\"",
+    "-c=codexa.mode=\"auto-edit\"",
+  ]);
+});
+
+test("parses model flags as runtime config overrides", () => {
+  const parsed = parseLaunchArgs([
+    "--model",
+    "gpt-5.3-codex",
+    "-m",
+    "gpt-5.4-mini",
+    "Say",
+    "READY",
+    "only.",
+  ]);
+
+  assert.equal(parsed.ok, true);
+  if (!parsed.ok) return;
+
+  assert.equal(parsed.value.initialPrompt, "Say READY only.");
+  assert.deepEqual(parsed.value.configOverrides, [
+    "model=\"gpt-5.3-codex\"",
+    "model=\"gpt-5.4-mini\"",
+  ]);
+  assert.deepEqual(parsed.value.passthroughArgs, [
+    "--model",
+    "gpt-5.3-codex",
+    "-m",
+    "gpt-5.4-mini",
+  ]);
+  // Last --model flag wins (same order as layered config)
+  assert.equal(parsed.value.modelOverride, "gpt-5.4-mini");
+});
+
+test("parses inline model flag assignment", () => {
+  const parsed = parseLaunchArgs(["--model=gpt-5.5", "compare", "this"]);
+
+  assert.equal(parsed.ok, true);
+  if (!parsed.ok) return;
+
+  assert.equal(parsed.value.initialPrompt, "compare this");
+  assert.deepEqual(parsed.value.configOverrides, ["model=\"gpt-5.5\""]);
+  assert.deepEqual(parsed.value.passthroughArgs, ["--model=gpt-5.5"]);
+  assert.equal(parsed.value.modelOverride, "gpt-5.5");
+});
+
+test("modelOverride is null when no --model flag is given", () => {
+  const parsed = parseLaunchArgs(["--profile", "review", "some", "prompt"]);
+
+  assert.equal(parsed.ok, true);
+  if (!parsed.ok) return;
+
+  assert.equal(parsed.value.modelOverride, null);
+});
+
+test("rejects missing model flag values", () => {
+  const parsed = parseLaunchArgs(["--model"]);
+  assert.equal(parsed.ok, false);
+  if (parsed.ok) return;
+  assert.match(parsed.error, /--model/i);
+});
+
+test("parses help and version flags without passthrough", () => {
+  const parsed = parseLaunchArgs(["--help", "-v"]);
+  assert.equal(parsed.ok, true);
+  if (!parsed.ok) return;
+
+  assert.equal(parsed.value.help, true);
+  assert.equal(parsed.value.version, true);
+  assert.equal(parsed.value.initialPrompt, null);
+  assert.deepEqual(parsed.value.passthroughArgs, []);
+});
+
+test("parses positional arguments as an initial prompt", () => {
+  const parsed = parseLaunchArgs(["--profile", "review", "explain", "this", "repo"]);
+  assert.equal(parsed.ok, true);
+  if (!parsed.ok) return;
+
+  assert.equal(parsed.value.profile, "review");
+  assert.equal(parsed.value.initialPrompt, "explain this repo");
+  assert.deepEqual(parsed.value.passthroughArgs, ["--profile", "review"]);
+});
+
+test("parses arguments after -- as an initial prompt", () => {
+  const parsed = parseLaunchArgs(["--", "--help", "as", "text"]);
+  assert.equal(parsed.ok, true);
+  if (!parsed.ok) return;
+
+  assert.equal(parsed.value.help, false);
+  assert.equal(parsed.value.initialPrompt, "--help as text");
+  assert.deepEqual(parsed.value.passthroughArgs, []);
+});

package/src/config/launchArgs.ts

@@ -0,0 +1,186 @@
+const FLAG_HELP = "--help";
+const FLAG_HELP_SHORT = "-h";
+const FLAG_VERSION = "--version";
+const FLAG_VERSION_SHORT = "-v";
+const FLAG_PROFILE = "--profile";
+const FLAG_CONFIG = "--config";
+const FLAG_CONFIG_SHORT = "-c";
+const FLAG_MODEL = "--model";
+const FLAG_MODEL_SHORT = "-m";
+
+export interface LaunchArgs {
+  help: boolean;
+  version: boolean;
+  initialPrompt: string | null;
+  profile: string | null;
+  configOverrides: string[];
+  passthroughArgs: string[];
+  /** Explicitly set when --model / -m was passed on the command line. Null when no model flag was given. */
+  modelOverride: string | null;
+}
+
+export type LaunchArgsParseResult =
+  | { ok: true; value: LaunchArgs }
+  | { ok: false; error: string };
+
+function normalizeProfileValue(value: string | undefined): string | null {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : null;
+}
+
+function parseConfigFlagValue(raw: string | undefined): string | null {
+  const trimmed = raw?.trim();
+  if (!trimmed) {
+    return null;
+  }
+
+  // Require non-empty key and non-empty value on both sides of "="
+  const separatorIndex = trimmed.indexOf("=");
+  if (separatorIndex <= 0 || separatorIndex === trimmed.length - 1) {
+    return null;
+  }
+
+  return trimmed;
+}
+
+function quoteTomlString(value: string): string {
+  return JSON.stringify(value);
+}
+
+export function parseLaunchArgs(argv: readonly string[]): LaunchArgsParseResult {
+  const passthroughArgs: string[] = [];
+  const configOverrides: string[] = [];
+  const promptArgs: string[] = [];
+  let help = false;
+  let version = false;
+  let profile: string | null = null;
+  let modelOverride: string | null = null;
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (!arg) {
+      continue;
+    }
+
+    if (arg === "--") {
+      promptArgs.push(...argv.slice(index + 1));
+      break;
+    }
+
+    if (arg === FLAG_HELP || arg === FLAG_HELP_SHORT) {
+      help = true;
+      continue;
+    }
+
+    if (arg === FLAG_VERSION || arg === FLAG_VERSION_SHORT) {
+      version = true;
+      continue;
+    }
+
+    // --profile <value> and --profile=<value> both supported.
+    if (arg === FLAG_PROFILE) {
+      const value = normalizeProfileValue(argv[index + 1]);
+      if (!value) {
+        return { ok: false, error: `Missing value for ${FLAG_PROFILE}.` };
+      }
+      profile = value;
+      passthroughArgs.push(arg, value);
+      index += 1;
+      continue;
+    }
+
+    if (arg.startsWith(`${FLAG_PROFILE}=`)) {
+      const value = normalizeProfileValue(arg.slice(`${FLAG_PROFILE}=`.length));
+      if (!value) {
+        return { ok: false, error: `Missing value for ${FLAG_PROFILE}.` };
+      }
+      profile = value;
+      passthroughArgs.push(`${FLAG_PROFILE}=${value}`);
+      continue;
+    }
+
+    // --config / -c accept key=value pairs; both space-separated and inline = forms supported.
+    if (arg === FLAG_CONFIG_SHORT || arg === FLAG_CONFIG) {
+      const value = parseConfigFlagValue(argv[index + 1]);
+      if (!value) {
+        return { ok: false, error: `Missing key=value payload for ${arg}.` };
+      }
+      configOverrides.push(value);
+      passthroughArgs.push(arg, value);
+      index += 1;
+      continue;
+    }
+
+    if (arg.startsWith(`${FLAG_CONFIG}=`)) {
+      const value = parseConfigFlagValue(arg.slice(`${FLAG_CONFIG}=`.length));
+      if (!value) {
+        return { ok: false, error: `Missing key=value payload for ${FLAG_CONFIG}.` };
+      }
+      configOverrides.push(value);
+      passthroughArgs.push(`${FLAG_CONFIG}=${value}`);
+      continue;
+    }
+
+    if (arg.startsWith(`${FLAG_CONFIG_SHORT}=`)) {
+      const value = parseConfigFlagValue(arg.slice(`${FLAG_CONFIG_SHORT}=`.length));
+      if (!value) {
+        return { ok: false, error: `Missing key=value payload for ${FLAG_CONFIG_SHORT}.` };
+      }
+      configOverrides.push(value);
+      passthroughArgs.push(`${FLAG_CONFIG_SHORT}=${value}`);
+      continue;
+    }
+
+    // --model / -m set the model via a config override, quoted for TOML.
+    // Also captured in modelOverride so callers can distinguish "was --model given?"
+    // from "what does layered config resolve to?" (which always has a default value).
+    if (arg === FLAG_MODEL || arg === FLAG_MODEL_SHORT) {
+      const value = normalizeProfileValue(argv[index + 1]);
+      if (!value) {
+        return { ok: false, error: `Missing value for ${arg}.` };
+      }
+      configOverrides.push(`model=${quoteTomlString(value)}`);
+      passthroughArgs.push(arg, value);
+      modelOverride = value;
+      index += 1;
+      continue;
+    }
+
+    if (arg.startsWith(`${FLAG_MODEL}=`)) {
+      const value = normalizeProfileValue(arg.slice(`${FLAG_MODEL}=`.length));
+      if (!value) {
+        return { ok: false, error: `Missing value for ${FLAG_MODEL}.` };
+      }
+      configOverrides.push(`model=${quoteTomlString(value)}`);
+      passthroughArgs.push(`${FLAG_MODEL}=${value}`);
+      modelOverride = value;
+      continue;
+    }
+
+    if (!arg.startsWith("-")) {
+      promptArgs.push(arg, ...argv.slice(index + 1));
+      break;
+    }
+
+    passthroughArgs.push(arg);
+  }
+
+  const initialPrompt = promptArgs
+    .map((part) => part.trim())
+    .filter(Boolean)
+    .join(" ")
+    .trim() || null;
+
+  return {
+    ok: true,
+    value: {
+      help,
+      version,
+      initialPrompt,
+      profile,
+      configOverrides,
+      passthroughArgs,
+      modelOverride,
+    },
+  };
+}

package/src/config/layeredConfig.test.ts

@@ -0,0 +1,143 @@
+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";
+
+function writeText(filePath: string, contents: string): void {
+  mkdirSync(join(filePath, ".."), { recursive: true });
+  writeFileSync(filePath, contents, "utf-8");
+}
+
+test("resolves user config, trusted project config, profiles, and CLI overrides deterministically", async () => {
+  const tempRoot = mkdtempSync(join(tmpdir(), "codexa-layered-config-"));
+  const tempHome = join(tempRoot, "home");
+  const workspaceRoot = join(tempRoot, "repo", "packages", "app");
+  const projectRoot = join(tempRoot, "repo");
+  const previousCodexHome = process.env.CODEX_HOME;
+  process.env.CODEX_HOME = tempHome;
+
+  try {
+    mkdirSync(join(projectRoot, ".git"), { recursive: true });
+    mkdirSync(join(workspaceRoot, ".codex"), { recursive: true });
+    mkdirSync(join(projectRoot, ".codex"), { recursive: true });
+    mkdirSync(tempHome, { recursive: true });
+
+    writeFileSync(join(tempHome, "config.toml"), [
+      "model = \"gpt-5.2\"",
+      "[codexa]",
+      "backend = \"openai-native\"",
+      "",
+      "[profiles.review]",
+      "service_tier = \"fast\"",
+    ].join("\n"), "utf-8");
+
+    writeFileSync(join(projectRoot, ".codex", "config.toml"), [
+      "model = \"gpt-5.4\"",
+      "profile = \"review\"",
+      "[codexa]",
+      "mode = \"suggest\"",
+      "",
+      "[profiles.review]",
+      "approval_policy = \"never\"",
+      "",
+      "[profiles.review.sandbox_workspace_write]",
+      "network_access = true",
+      "writable_roots = [\"./roots/project\"]",
+    ].join("\n"), "utf-8");
+
+    writeFileSync(join(workspaceRoot, ".codex", "config.toml"), [
+      "personality = \"pragmatic\"",
+      "",
+      "[profiles.review]",
+      "model_reasoning_effort = \"high\"",
+    ].join("\n"), "utf-8");
+
+    const trustStore = await import(`./trustStore.js?layered-trust=${Date.now()}`);
+    trustStore.setProjectTrust(projectRoot, true);
+
+    const layeredConfig = await import(`./layeredConfig.js?layered=${Date.now()}`);
+    const result = layeredConfig.resolveLayeredConfig({
+      workspaceRoot,
+      launchArgs: {
+        help: false,
+        version: false,
+        initialPrompt: null,
+        profile: null,
+        configOverrides: [
+          "model=\"gpt-5.4-mini\"",
+          "codexa.mode=\"full-auto\"",
+          "mcp.enabled=true",
+        ],
+        passthroughArgs: [],
+        modelOverride: "gpt-5.4-mini",
+      },
+    });
+
+    assert.equal(result.runtime.provider, "openai-native");
+    assert.equal(result.runtime.model, "gpt-5.4-mini");
+    assert.equal(result.runtime.reasoningLevel, "high");
+    assert.equal(result.runtime.mode, "full-auto");
+    assert.equal(result.runtime.policy.approvalPolicy, "never");
+    assert.equal(result.runtime.policy.networkAccess, "enabled");
+    assert.equal(result.runtime.policy.serviceTier, "fast");
+    assert.equal(result.runtime.policy.personality, "pragmatic");
+    assert.equal(result.diagnostics.selectedProfile, "review");
+    assert.equal(result.diagnostics.selectedProfileSource, "Project config");
+    assert.equal(result.diagnostics.projectTrusted, true);
+    assert.match(result.runtime.policy.writableRoots[0] ?? "", /roots[\\/]project/i);
+    assert.match(result.diagnostics.fieldSources.model, /CLI override/i);
+    assert.match(result.diagnostics.fieldSources["policy.approvalPolicy"], /Profile review from Project config/i);
+    assert.ok(result.diagnostics.ignoredEntries.some((entry: string) => /mcp\.enabled/i.test(entry)));
+  } finally {
+    if (previousCodexHome === undefined) {
+      delete process.env.CODEX_HOME;
+    } else {
+      process.env.CODEX_HOME = previousCodexHome;
+    }
+    rmSync(tempRoot, { recursive: true, force: true });
+  }
+});
+
+test("blocks project config when the detected project root is untrusted", async () => {
+  const tempRoot = mkdtempSync(join(tmpdir(), "codexa-layered-untrusted-"));
+  const tempHome = join(tempRoot, "home");
+  const workspaceRoot = join(tempRoot, "repo", "app");
+  const projectRoot = join(tempRoot, "repo");
+  const previousCodexHome = process.env.CODEX_HOME;
+  process.env.CODEX_HOME = tempHome;
+
+  try {
+    mkdirSync(join(projectRoot, ".git"), { recursive: true });
+    mkdirSync(join(projectRoot, ".codex"), { recursive: true });
+    mkdirSync(tempHome, { recursive: true });
+
+    writeFileSync(join(tempHome, "config.toml"), "model = \"gpt-5.2\"\n", "utf-8");
+    writeFileSync(join(projectRoot, ".codex", "config.toml"), "model = \"gpt-5.4-mini\"\n", "utf-8");
+
+    const layeredConfig = await import(`./layeredConfig.js?untrusted=${Date.now()}`);
+    const result = layeredConfig.resolveLayeredConfig({
+      workspaceRoot,
+      launchArgs: {
+        help: false,
+        version: false,
+        initialPrompt: null,
+        profile: null,
+        configOverrides: [],
+        passthroughArgs: [],
+        modelOverride: null,
+      },
+    });
+
+    assert.equal(result.runtime.model, "gpt-5.2");
+    assert.equal(result.diagnostics.projectTrusted, false);
+    assert.ok(result.diagnostics.layers.some((layer: { status: string }) => layer.status === "blocked"));
+  } finally {
+    if (previousCodexHome === undefined) {
+      delete process.env.CODEX_HOME;
+    } else {
+      process.env.CODEX_HOME = previousCodexHome;
+    }
+    rmSync(tempRoot, { recursive: true, force: true });
+  }
+});