karajan-code 2.7.4 → 2.8.0

package/src/config/role-resolver.js

@@ -0,0 +1,159 @@
+/**
+ * Role provider/model resolution + config validation.
+ *
+ * `resolveRole(config, role)` returns `{ provider, model }` for a role
+ * given the fully-overridden config, respecting legacy single-provider
+ * shortcuts (`coder: "claude"`) and per-role overrides
+ * (`roles.coder.provider`). Handles model compatibility (gemini models
+ * are dropped from a claude provider, etc.) so the agent subprocess
+ * never sees an incompatible `--model` flag.
+ *
+ * `validateConfig(config, commandName)` is the run-time guard called by
+ * every CLI command before spawning agents: it asserts every required
+ * role has a provider, otherwise throws with an actionable message
+ * ("Set 'roles.planner.provider' or pass '--planner <name>'").
+ *
+ * Extracted from `src/config.js` in TSK-0332 (Oleada 2 of the v2.7.4
+ * audit refactor). Public API: `resolveRole`, `validateConfig`. The
+ * inference helpers are internal.
+ */
+
+/**
+ * Check if a model string is compatible with an agent provider.
+ * Only returns false when the model clearly belongs to a DIFFERENT provider.
+ * Returns true if we can't determine or if the model is ambiguous.
+ */
+const AGENT_MODEL_SIGNATURES = {
+  claude: ["claude", "sonnet", "opus", "haiku"],
+  codex: ["o4-", "o3-", "gpt-", "codex"],
+  gemini: ["gemini", "flash-"]
+};
+
+function isModelCompatible(agent, model) {
+  if (!model || !agent) return true;
+  const lower = model.toLowerCase();
+
+  // Check if model clearly belongs to a different provider
+  for (const [provider, signatures] of Object.entries(AGENT_MODEL_SIGNATURES)) {
+    if (provider === agent) continue;
+    if (signatures.some(s => lower.includes(s))) {
+      // Model belongs to a different provider — incompatible
+      return false;
+    }
+  }
+
+  // Model doesn't clearly belong to any other provider — allow it
+  return true;
+}
+
+// Roles that inherit provider/model from the coder when not explicitly configured
+const CODER_INHERITED_ROLES = new Set([
+  "planner", "refactorer", "solomon", "researcher", "tester", "security",
+  "impeccable", "triage", "discover", "architect", "audit", "hu_reviewer", "hu-reviewer"
+]);
+
+function resolveProvider(roleConfig, role, roles, legacyCoder, legacyReviewer) {
+  if (roleConfig.provider) return roleConfig.provider;
+
+  // If model has "provider/model" format (e.g. "gemini/pro"), extract the provider
+  if (roleConfig.model && roleConfig.model.includes("/")) {
+    const inferredProvider = roleConfig.model.split("/")[0].toLowerCase();
+    if (AGENT_MODEL_SIGNATURES[inferredProvider]) return inferredProvider;
+  }
+
+  if (role === "coder") return legacyCoder;
+  if (role === "reviewer") return legacyReviewer;
+  if (CODER_INHERITED_ROLES.has(role)) return roles.coder?.provider || legacyCoder;
+  return null;
+}
+
+function resolveModel(roleConfig, role, config) {
+  if (roleConfig.model) {
+    // Strip "provider/" prefix from models like "gemini/pro" → "pro"
+    const model = roleConfig.model.includes("/")
+      ? roleConfig.model.split("/").slice(1).join("/")
+      : roleConfig.model;
+    return { model, inherited: false };
+  }
+  if (role === "coder") return { model: config?.coder_options?.model ?? null, inherited: false };
+  if (role === "reviewer") return { model: config?.reviewer_options?.model ?? null, inherited: false };
+  if (CODER_INHERITED_ROLES.has(role)) {
+    const model = config?.coder_options?.model ?? null;
+    return { model, inherited: !!model };
+  }
+  return { model: null, inherited: false };
+}
+
+export function resolveRole(config, role) {
+  const roles = config?.roles || {};
+  const roleConfig = roles[role] || {};
+  const legacyCoder = config?.coder || null;
+  const legacyReviewer = config?.reviewer || null;
+
+  const provider = resolveProvider(roleConfig, role, roles, legacyCoder, legacyReviewer);
+  let { model } = resolveModel(roleConfig, role, config);
+
+  // Drop model if incompatible with the resolved provider (inherited or explicit)
+  if (provider && model && !isModelCompatible(provider, model)) {
+    model = null;
+  }
+
+  return { provider, model };
+}
+
+// Pipeline roles checked when commandName is "run": [pipelineKey, roleName]
+const RUN_PIPELINE_ROLES = [
+  ["reviewer", "reviewer"], ["triage", "triage"], ["planner", "planner"],
+  ["refactorer", "refactorer"], ["researcher", "researcher"],
+  ["tester", "tester"], ["security", "security"], ["impeccable", "impeccable"]
+];
+
+// Direct command-to-role mapping for non-"run" commands
+const COMMAND_ROLE_MAP = {
+  discover: ["discover"],
+  plan: ["planner"],
+  code: ["coder"],
+  review: ["reviewer"]
+};
+
+function requiredRolesFor(commandName, config) {
+  if (commandName !== "run") {
+    return COMMAND_ROLE_MAP[commandName] || [];
+  }
+  const required = ["coder"];
+  for (const [pipelineKey, roleName] of RUN_PIPELINE_ROLES) {
+    const pipelineEntry = config?.pipeline?.[pipelineKey];
+    // reviewer defaults to enabled (only excluded if explicitly false)
+    const isEnabled = pipelineKey === "reviewer"
+      ? pipelineEntry?.enabled !== false
+      : Boolean(pipelineEntry?.enabled);
+    if (isEnabled) required.push(roleName);
+  }
+  return required;
+}
+
+export function validateConfig(config, commandName = "run") {
+  const errors = [];
+  if (!new Set(["paranoid", "strict", "standard", "relaxed", "custom"]).has(config.review_mode)) {
+    errors.push(`Invalid review_mode: ${config.review_mode}`);
+  }
+  if (!new Set(["tdd", "standard"]).has(config.development?.methodology)) {
+    errors.push(`Invalid development.methodology: ${config.development?.methodology}`);
+  }
+
+  const requiredRoles = requiredRolesFor(commandName, config);
+  for (const role of requiredRoles) {
+    const { provider } = resolveRole(config, role);
+    if (!provider) {
+      errors.push(
+        `Missing provider for required role '${role}'. Set 'roles.${role}.provider' or pass '--${role} <name>'`
+      );
+    }
+  }
+
+  if (errors.length > 0) {
+    throw new Error(errors.join("\n"));
+  }
+
+  return config;
+}

package/src/config/test-harness.js

@@ -0,0 +1,79 @@
+/**
+ * Test-harness-visible config knobs — resolved once per run, then read
+ * everywhere via `config.testHarness.*`.
+ *
+ * Pre-v2.7.5 these defaults were read from `globalThis.__KJ_*` directly
+ * in production code paths — `flow-runner.js` read
+ * `globalThis.__KJ_DEFAULT_BRAIN_DECISOR`, `preflight-checks.js` read
+ * `globalThis.__KJ_DISABLE_SONAR_STAGE`, etc. The audit flagged this as
+ * spooky-action-at-a-distance: a stray test-harness leftover could flip
+ * a production default, and tests did not exercise the same path
+ * production users would.
+ *
+ * TSK-0334 isolates the globalThis lookup to a single site (this module,
+ * run during config load) and exposes the resolved knobs under
+ * `config.testHarness`. Production code reads only from `config.*`,
+ * never from `globalThis`. Tests can set either `globalThis.__KJ_*`
+ * (back-compat for the ~10 existing test files that already do) or pass
+ * `config.testHarness = { ... }` explicitly.
+ *
+ * The `tests/architecture/no-globalThis-kj.test.js` invariant fails CI
+ * if a `globalThis.__KJ_` read reappears anywhere under `src/` outside
+ * this module.
+ *
+ * Resolution order (first defined wins):
+ *   1. `config.testHarness.<key>` (explicit test or user config)
+ *   2. `globalThis.__KJ_<MACRO>`  (existing test-harness global, back-compat)
+ *   3. Documented default (second column below)
+ *
+ * | config.testHarness key         | globalThis key                  | prod default |
+ * |--------------------------------|----------------------------------|--------------|
+ * | disableSonarStage              | __KJ_DISABLE_SONAR_STAGE        | false        |
+ * | defaultSkillsMode              | __KJ_DEFAULT_SKILLS_MODE        | "auto"       |
+ * | defaultPreflightExtended       | __KJ_DEFAULT_PREFLIGHT_EXTENDED | true         |
+ * | defaultBrainDecisor            | __KJ_DEFAULT_BRAIN_DECISOR      | true         |
+ * | defaultAddyosmaniEnabled       | __KJ_DEFAULT_ADDYOSMANI_ENABLED | true         |
+ */
+
+const GLOBAL_KEYS = {
+  disableSonarStage:        "__KJ_DISABLE_SONAR_STAGE",
+  defaultSkillsMode:        "__KJ_DEFAULT_SKILLS_MODE",
+  defaultPreflightExtended: "__KJ_DEFAULT_PREFLIGHT_EXTENDED",
+  defaultBrainDecisor:      "__KJ_DEFAULT_BRAIN_DECISOR",
+  defaultAddyosmaniEnabled: "__KJ_DEFAULT_ADDYOSMANI_ENABLED",
+};
+
+const PROD_DEFAULTS = Object.freeze({
+  disableSonarStage:        false,
+  defaultSkillsMode:        "auto",
+  defaultPreflightExtended: true,
+  defaultBrainDecisor:      true,
+  defaultAddyosmaniEnabled: true,
+});
+
+/**
+ * Resolve the testHarness slice of config. Safe to call multiple times;
+ * each call re-reads globalThis so test-harness overrides applied after
+ * config load still take effect on the next resolution.
+ *
+ * @param {Partial<typeof PROD_DEFAULTS>} [explicit] - typically `config.testHarness` passed in
+ * @returns {Readonly<typeof PROD_DEFAULTS>}
+ */
+export function resolveTestHarness(explicit = {}) {
+  const out = {};
+  for (const [key, globalName] of Object.entries(GLOBAL_KEYS)) {
+    if (explicit && Object.prototype.hasOwnProperty.call(explicit, key) && explicit[key] !== undefined) {
+      out[key] = explicit[key];
+      continue;
+    }
+    const g = globalThis[globalName];
+    if (g !== undefined) {
+      out[key] = g;
+      continue;
+    }
+    out[key] = PROD_DEFAULTS[key];
+  }
+  return Object.freeze(out);
+}
+
+export { PROD_DEFAULTS, GLOBAL_KEYS };