karajan-code 1.4.0 → 1.5.0

package/README.md

@@ -38,6 +38,7 @@ Instead of running one AI agent and manually reviewing its output, `kj` chains a
 - **Git automation** — auto-commit, auto-push, auto-PR after approval
 - **Session management** — pause/resume with fail-fast detection and automatic cleanup of expired sessions
 - **Plugin system** — extend with custom agents via `.karajan/plugins/`
+- **Smart model selection** — auto-selects optimal model per role based on triage complexity (lighter models for trivial tasks, powerful models for complex ones)
 - **Retry with backoff** — automatic recovery from transient API errors (429, 5xx) with exponential backoff and jitter
 - **Planning Game integration** — optionally pair with [Planning Game](https://github.com/AgenteIA-Geniova/planning-game) for agile project management (tasks, sprints, estimation) — like Jira, but open-source and XP-native
 
@@ -195,6 +196,8 @@ kj run "Fix the login bug" [options]
 | `--auto-pr` | Create PR after push |
 | `--no-auto-rebase` | Disable auto-rebase before push |
 | `--branch-prefix <prefix>` | Branch naming prefix (default: `feat/`) |
+| `--smart-models` | Enable smart model selection based on triage complexity |
+| `--no-smart-models` | Disable smart model selection |
 | `--no-sonar` | Skip SonarQube analysis |
 | `--pg-task <cardId>` | Planning Game card ID for task context |
 | `--pg-project <projectId>` | Planning Game project ID |
@@ -354,6 +357,16 @@ budget:
   currency: usd                # usd | eur
   exchange_rate_eur: 0.92
 
+# Smart model selection (requires --enable-triage)
+model_selection:
+  enabled: true                # Auto-select models based on triage complexity
+  tiers:                       # Override default tier map per provider
+    claude:
+      simple: claude/sonnet    # Use sonnet even for simple tasks
+  role_overrides:              # Override level mapping per role
+    reviewer:
+      trivial: medium          # Reviewer always at least medium tier
+
 # Output
 output:
   report_dir: ./.reviews
@@ -430,7 +443,7 @@ Use `kj roles show <role>` to inspect any template. Create a project override to
 git clone https://github.com/manufosela/karajan-code.git
 cd karajan-code
 npm install
-npm test              # Run 899+ tests with Vitest
+npm test              # Run 964+ tests with Vitest
 npm run test:watch    # Watch mode
 npm run validate      # Lint + test
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "karajan-code",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "Local multi-agent coding orchestrator with TDD, SonarQube, and code review pipeline",
   "type": "module",
   "license": "AGPL-3.0",

package/src/cli.js

@@ -24,7 +24,7 @@ async function withConfig(commandName, flags, fn) {
 }
 
 const program = new Command();
-program.name("kj").description("Karajan Code CLI").version("1.2.1");
+program.name("kj").description("Karajan Code CLI").version("1.5.0");
 
 program
   .command("init")
@@ -83,6 +83,8 @@ program
   .option("--no-sonar")
   .option("--pg-task <cardId>", "Planning Game card ID (e.g., KJC-TSK-0042)")
   .option("--pg-project <projectId>", "Planning Game project ID")
+  .option("--smart-models", "Enable smart model selection based on triage complexity")
+  .option("--no-smart-models", "Disable smart model selection")
   .option("--dry-run", "Show what would be executed without running anything")
   .option("--json", "Output JSON only (no styled display)")
   .action(async (task, flags) => {

package/src/config.js

@@ -106,6 +106,11 @@ const DEFAULTS = {
     currency: "usd",
     exchange_rate_eur: 0.92
   },
+  model_selection: {
+    enabled: true,
+    tiers: {},
+    role_overrides: {}
+  },
   session: {
     max_iteration_minutes: 15,
     max_total_minutes: 120,
@@ -260,6 +265,9 @@ export function applyRunOverrides(config, flags) {
   out.planning_game = out.planning_game || {};
   if (flags.pgTask) out.planning_game.enabled = true;
   if (flags.pgProject) out.planning_game.project_id = flags.pgProject;
+  out.model_selection = out.model_selection || { enabled: true, tiers: {}, role_overrides: {} };
+  if (flags.smartModels === true) out.model_selection.enabled = true;
+  if (flags.smartModels === false || flags.noSmartModels === true) out.model_selection.enabled = false;
   return out;
 }
 

package/src/mcp/run-kj.js

@@ -49,6 +49,8 @@ export async function runKjCommand({ command, commandArgs = [], options = {}, en
   normalizeBoolFlag(options.autoPr, "--auto-pr", args);
   if (options.autoRebase === false) args.push("--no-auto-rebase");
   normalizeBoolFlag(options.noSonar, "--no-sonar", args);
+  if (options.smartModels === true) args.push("--smart-models");
+  if (options.smartModels === false) args.push("--no-smart-models");
   addOptionalValue(args, "--pg-task", options.pgTask);
   addOptionalValue(args, "--pg-project", options.pgProject);
 

package/src/mcp/tools.js

@@ -85,6 +85,7 @@ export const tools = [
         autoPr: { type: "boolean" },
         autoRebase: { type: "boolean" },
         branchPrefix: { type: "string" },
+        smartModels: { type: "boolean", description: "Enable/disable smart model selection based on triage complexity" },
         noSonar: { type: "boolean" },
         kjHome: { type: "string" },
         sonarToken: { type: "string" },

package/src/orchestrator/pre-loop-stages.js

@@ -5,6 +5,7 @@ import { createAgent } from "../agents/index.js";
 import { addCheckpoint, markSessionStatus } from "../session-store.js";
 import { emitProgress, makeEvent } from "../utils/events.js";
 import { parsePlannerOutput } from "../prompts/planner.js";
+import { selectModelsForRoles } from "../utils/model-selector.js";
 
 export async function runTriageStage({ config, logger, emitter, eventBase, session, coderRole, trackBudget }) {
   logger.setContext({ iteration: 0, stage: "triage" });
@@ -47,6 +48,31 @@ export async function runTriageStage({ config, logger, emitter, eventBase, sessi
     reasoning: triageOutput.result?.reasoning || null
   };
 
+  let modelSelection = null;
+  if (triageOutput.ok && config?.model_selection?.enabled) {
+    const level = triageOutput.result?.level;
+    if (level) {
+      const { modelOverrides, reasoning } = selectModelsForRoles({ level, config });
+      for (const [role, model] of Object.entries(modelOverrides)) {
+        if (config.roles?.[role] && !config.roles[role].model) {
+          config.roles[role].model = model;
+        }
+      }
+      modelSelection = { modelOverrides, reasoning };
+      emitProgress(
+        emitter,
+        makeEvent("model-selection:applied", { ...eventBase, stage: "triage" }, {
+          message: "Smart model selection applied",
+          detail: modelSelection
+        })
+      );
+    }
+  }
+
+  if (modelSelection) {
+    stageResult.modelSelection = modelSelection;
+  }
+
   emitProgress(
     emitter,
     makeEvent("triage:end", { ...eventBase, stage: "triage" }, {

package/src/utils/model-selector.js

@@ -0,0 +1,107 @@
+const DEFAULT_MODEL_TIERS = {
+  claude: { trivial: "claude/haiku", simple: "claude/haiku", medium: "claude/sonnet", complex: "claude/opus" },
+  codex: { trivial: "codex/o4-mini", simple: "codex/o4-mini", medium: "codex/o4-mini", complex: "codex/o3" },
+  gemini: { trivial: "gemini/flash", simple: "gemini/flash", medium: "gemini/pro", complex: "gemini/pro" },
+  aider: { trivial: null, simple: null, medium: null, complex: null }
+};
+
+const DEFAULT_ROLE_OVERRIDES = {
+  reviewer: { trivial: "medium", simple: "medium" },
+  triage: { medium: "simple", complex: "simple" }
+};
+
+const VALID_LEVELS = new Set(["trivial", "simple", "medium", "complex"]);
+
+export function getDefaultModelTiers() {
+  return JSON.parse(JSON.stringify(DEFAULT_MODEL_TIERS));
+}
+
+export function getDefaultRoleOverrides() {
+  return JSON.parse(JSON.stringify(DEFAULT_ROLE_OVERRIDES));
+}
+
+export function resolveModelForRole({ role, provider, level, tierMap, roleOverrides }) {
+  if (!provider || !level || !VALID_LEVELS.has(level)) return null;
+
+  const tiers = tierMap || DEFAULT_MODEL_TIERS;
+  const providerTiers = tiers[provider];
+  if (!providerTiers) return null;
+
+  const overrides = roleOverrides || DEFAULT_ROLE_OVERRIDES;
+  const roleOvr = overrides[role];
+
+  let effectiveLevel = level;
+  if (roleOvr && roleOvr[level]) {
+    const mappedLevel = roleOvr[level];
+    if (VALID_LEVELS.has(mappedLevel)) {
+      effectiveLevel = mappedLevel;
+    }
+  }
+
+  return providerTiers[effectiveLevel] || null;
+}
+
+export function selectModelsForRoles({ level, config, roles }) {
+  if (!level || !VALID_LEVELS.has(level)) {
+    return { modelOverrides: {}, reasoning: "No valid triage level provided" };
+  }
+
+  const modelSelection = config?.model_selection || {};
+  const userTiers = modelSelection.tiers || {};
+  const userRoleOverrides = modelSelection.role_overrides || {};
+
+  const mergedTiers = { ...getDefaultModelTiers() };
+  for (const [provider, levels] of Object.entries(userTiers)) {
+    mergedTiers[provider] = { ...(mergedTiers[provider] || {}), ...levels };
+  }
+
+  const mergedRoleOverrides = { ...getDefaultRoleOverrides() };
+  for (const [role, levels] of Object.entries(userRoleOverrides)) {
+    mergedRoleOverrides[role] = { ...(mergedRoleOverrides[role] || {}), ...levels };
+  }
+
+  const allRoles = roles || Object.keys(config?.roles || {});
+  const modelOverrides = {};
+  const details = [];
+
+  for (const role of allRoles) {
+    const roleConfig = config?.roles?.[role];
+    if (!roleConfig) continue;
+
+    if (roleConfig.model) {
+      details.push(`${role}: skipped (explicit model "${roleConfig.model}")`);
+      continue;
+    }
+
+    if (roleConfig.disabled) {
+      details.push(`${role}: skipped (disabled)`);
+      continue;
+    }
+
+    const provider = roleConfig.provider;
+    if (!provider) {
+      details.push(`${role}: skipped (no provider)`);
+      continue;
+    }
+
+    const model = resolveModelForRole({
+      role,
+      provider,
+      level,
+      tierMap: mergedTiers,
+      roleOverrides: mergedRoleOverrides
+    });
+
+    if (model) {
+      modelOverrides[role] = model;
+      details.push(`${role}: ${model} (level=${level}, provider=${provider})`);
+    } else {
+      details.push(`${role}: no model for provider "${provider}"`);
+    }
+  }
+
+  return {
+    modelOverrides,
+    reasoning: `Smart model selection (level=${level}): ${details.join("; ")}`
+  };
+}