karajan-code 1.48.0 → 1.50.0

package/src/orchestrator/stages/triage-stage.js

@@ -0,0 +1,137 @@
+/**
+ * Triage stage logic.
+ * Extracted from pre-loop-stages.js for maintainability.
+ */
+
+import { TriageRole } from "../../roles/triage-role.js";
+import { addCheckpoint } from "../../session-store.js";
+import { emitProgress, makeEvent } from "../../utils/events.js";
+import { selectModelsForRoles } from "../../utils/model-selector.js";
+import { createStallDetector } from "../../utils/stall-detector.js";
+
+const ROLE_NAMES = ["planner", "researcher", "architect", "refactorer", "reviewer", "tester", "security", "impeccable"];
+
+function buildRoleOverrides(recommendedRoles, pipelineConfig) {
+  const overrides = {};
+  for (const role of ROLE_NAMES) {
+    overrides[`${role}Enabled`] = recommendedRoles.has(role) || Boolean(pipelineConfig[role]?.enabled);
+  }
+  return overrides;
+}
+
+function applyModelSelection(triageOutput, config, emitter, eventBase) {
+  if (!triageOutput.ok || !config?.model_selection?.enabled) return null;
+  const level = triageOutput.result?.level;
+  if (!level) return null;
+
+  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;
+    }
+  }
+  const modelSelection = { modelOverrides, reasoning };
+  emitProgress(
+    emitter,
+    makeEvent("model-selection:applied", { ...eventBase, stage: "triage" }, {
+      message: "Smart model selection applied",
+      detail: modelSelection
+    })
+  );
+  return modelSelection;
+}
+
+export async function runTriageStage({ config, logger, emitter, eventBase, session, coderRole, trackBudget }) {
+  logger.setContext({ iteration: 0, stage: "triage" });
+
+  const triageProvider = config?.roles?.triage?.provider || coderRole.provider;
+  emitProgress(
+    emitter,
+    makeEvent("triage:start", { ...eventBase, stage: "triage" }, {
+      message: "Triage classifying task complexity",
+      detail: { provider: triageProvider, executorType: "agent" }
+    })
+  );
+
+  const triageOnOutput = ({ stream, line }) => {
+    emitProgress(emitter, makeEvent("agent:output", { ...eventBase, stage: "triage" }, {
+      message: line,
+      detail: { stream, agent: triageProvider }
+    }));
+  };
+  const triageStall = createStallDetector({
+    onOutput: triageOnOutput, emitter, eventBase, stage: "triage", provider: triageProvider
+  });
+
+  const triage = new TriageRole({ config, logger, emitter });
+  await triage.init({ task: session.task, sessionId: session.id, iteration: 0 });
+  const triageStart = Date.now();
+  let triageOutput;
+  try {
+    triageOutput = await triage.run({ task: session.task, onOutput: triageStall.onOutput });
+  } catch (err) {
+    logger.warn(`Triage threw: ${err.message}`);
+    triageOutput = { ok: false, summary: `Triage error: ${err.message}`, result: { error: err.message } };
+  } finally {
+    triageStall.stop();
+  }
+  trackBudget({
+    role: "triage",
+    provider: config?.roles?.triage?.provider || coderRole.provider,
+    model: config?.roles?.triage?.model || coderRole.model,
+    result: triageOutput,
+    duration_ms: Date.now() - triageStart
+  });
+
+  await addCheckpoint(session, {
+    stage: "triage",
+    iteration: 0,
+    ok: triageOutput.ok,
+    provider: config?.roles?.triage?.provider || coderRole.provider,
+    model: config?.roles?.triage?.model || coderRole.model || null
+  });
+
+  const recommendedRoles = new Set(triageOutput.result?.roles || []);
+  const roleOverrides = triageOutput.ok
+    ? buildRoleOverrides(recommendedRoles, config.pipeline || {})
+    : {};
+
+  const shouldDecompose = triageOutput.result?.shouldDecompose || false;
+  const subtasks = triageOutput.result?.subtasks || [];
+
+  const stageResult = {
+    ok: triageOutput.ok,
+    level: triageOutput.result?.level || null,
+    roles: Array.from(recommendedRoles),
+    reasoning: triageOutput.result?.reasoning || null,
+    taskType: triageOutput.result?.taskType || "sw",
+    shouldDecompose,
+    subtasks
+  };
+
+  const modelSelection = applyModelSelection(triageOutput, config, emitter, eventBase);
+  if (modelSelection) {
+    stageResult.modelSelection = modelSelection;
+  }
+
+  if (shouldDecompose && subtasks.length > 0) {
+    emitProgress(
+      emitter,
+      makeEvent("triage:decompose", { ...eventBase, stage: "triage" }, {
+        message: `Task decomposition recommended: ${subtasks.length} subtask${subtasks.length === 1 ? "" : "s"}`,
+        detail: { shouldDecompose, subtasks }
+      })
+    );
+  }
+
+  emitProgress(
+    emitter,
+    makeEvent("triage:end", { ...eventBase, stage: "triage" }, {
+      status: triageOutput.ok ? "ok" : "fail",
+      message: triageOutput.ok ? "Triage completed" : `Triage failed: ${triageOutput.summary}`,
+      detail: { ...stageResult, provider: triageProvider, executorType: "agent" }
+    })
+  );
+
+  return { roleOverrides, stageResult };
+}

package/src/plugins/loader.js

@@ -21,7 +21,7 @@ async function listPluginFiles(dir) {
     return entries
       .filter((e) => e.isFile() && e.name.endsWith(".js"))
       .map((e) => path.join(dir, e.name));
-  } catch {
+  } catch { /* plugin dir does not exist */
     return [];
   }
 }

package/src/prompts/architect.js

@@ -69,7 +69,7 @@ export function parseArchitectOutput(raw) {
   let parsed;
   try {
     parsed = JSON.parse(jsonMatch[0]);
-  } catch {
+  } catch { /* architect output is not valid JSON */
     return null;
   }
 

package/src/review/parser.js

@@ -47,7 +47,7 @@ export function parseJsonOutput(raw) {
   try {
     const parsed = JSON.parse(cleaned);
     return normalizeReviewPayload(parsed);
-  } catch {
+  } catch { /* not a single JSON blob */
     const lines = cleaned
       .split("\n")
       .map((x) => x.trim())
@@ -57,7 +57,7 @@ export function parseJsonOutput(raw) {
     for (const line of lines) {
       try {
         parsedLines.push(JSON.parse(line));
-      } catch {
+      } catch { /* line is not JSON */
         continue;
       }
     }
@@ -71,7 +71,7 @@ export function parseJsonOutput(raw) {
       try {
         const parsed = JSON.parse(lines[i]);
         return normalizeReviewPayload(parsed);
-      } catch {
+      } catch { /* line is not JSON */
         continue;
       }
     }

package/src/roles/architect-role.js

@@ -104,7 +104,7 @@ export class ArchitectRole extends BaseRole {
         summary: buildSummary(parsed),
         usage: result.usage
       };
-    } catch {
+    } catch { /* agent output is not structured JSON */
       return {
         ok: true,
         result: {

package/src/roles/audit-role.js

@@ -63,7 +63,7 @@ export class AuditRole extends BaseRole {
     let growthDelta = null;
     try {
       basalCost = await measureBasalCost(projectDir);
-      const previous = loadPreviousAudit(projectDir);
+      const previous = await loadPreviousAudit(projectDir);
       growthDelta = computeGrowthDelta(basalCost, previous);
     } catch {
       // basal cost is best-effort, don't fail the audit
@@ -95,7 +95,7 @@ export class AuditRole extends BaseRole {
       }
 
       if (basalCost) {
-        try { saveAuditSnapshot(projectDir, basalCost); } catch { /* best-effort */ }
+        try { await saveAuditSnapshot(projectDir, basalCost); } catch { /* best-effort */ }
       }
 
       return {
@@ -111,7 +111,7 @@ export class AuditRole extends BaseRole {
         summary: buildSummary(parsed),
         usage: result.usage
       };
-    } catch {
+    } catch { /* agent output is not structured JSON */
       return {
         ok: true,
         result: { raw: result.output, provider },

package/src/roles/base-role.js

@@ -35,7 +35,7 @@ async function loadFirstExisting(paths) {
   for (const p of paths) {
     try {
       return await fs.readFile(p, "utf8");
-    } catch {
+    } catch { /* file not found */
       continue;
     }
   }

package/src/roles/discover-role.js

@@ -115,7 +115,7 @@ export class DiscoverRole extends BaseRole {
         summary: buildSummary(parsed, mode),
         usage: result.usage
       };
-    } catch {
+    } catch { /* agent output is not structured JSON */
       return buildUnstructuredResult(result.output, mode, provider, result.usage);
     }
   }

package/src/roles/hu-reviewer-role.js

@@ -95,7 +95,7 @@ export class HuReviewerRole extends BaseRole {
         summary: buildSummary(parsed),
         usage: result.usage
       };
-    } catch {
+    } catch { /* agent output is not structured JSON */
       return {
         ok: true,
         result: {

package/src/roles/researcher-role.js

@@ -116,7 +116,7 @@ export class ResearcherRole extends BaseRole {
         },
         summary: buildSummary(parsed)
       };
-    } catch {
+    } catch { /* agent output is not structured JSON */
       return {
         ok: true,
         result: {

package/src/roles/triage-role.js

@@ -112,7 +112,7 @@ export class TriageRole extends BaseRole {
         summary: `Triage: ${level} (${roles.length} role${roles.length === 1 ? "" : "s"})${decomposeNote}`,
         usage: result.usage
       };
-    } catch {
+    } catch { /* agent output is not structured JSON */
       return {
         ok: true,
         result: {

package/src/session-cleanup.js

@@ -71,7 +71,7 @@ export async function cleanupExpiredSessions({ logger } = {}) {
   let entries;
   try {
     entries = await fs.readdir(sessionRoot, { withFileTypes: true });
-  } catch {
+  } catch { /* session root does not exist */
     return { removed: 0, errors: [] };
   }
 

package/src/session-store.js

@@ -67,14 +67,14 @@ export async function loadMostRecentSession() {
   let entries;
   try {
     entries = await fs.readdir(SESSION_ROOT, { withFileTypes: true });
-  } catch {
+  } catch { /* session root does not exist yet */
     return null;
   }
   const dirs = entries.filter(e => e.isDirectory()).map(e => e.name).sort();
   for (let i = dirs.length - 1; i >= 0; i--) {
     try {
       return await loadSession(dirs[i]);
-    } catch {
+    } catch { /* session.json missing or malformed */
       continue;
     }
   }

package/src/skills/openskills-client.js

@@ -22,7 +22,7 @@ export async function isOpenSkillsAvailable() {
       timeout: 15_000
     });
     return result.exitCode === 0;
-  } catch {
+  } catch { /* openskills CLI not available */
     return false;
   }
 }

package/src/skills/skill-detector.js

@@ -149,7 +149,7 @@ export async function autoInstallSkills(neededSkills, projectDir) {
       } else {
         result.failed.push(skillName);
       }
-    } catch {
+    } catch { /* skill install threw */
       result.failed.push(skillName);
     }
   }
@@ -178,7 +178,7 @@ export async function cleanupAutoInstalledSkills(skillNames, projectDir) {
       } else {
         result.failed.push(name);
       }
-    } catch {
+    } catch { /* skill removal threw */
       result.failed.push(name);
     }
   }

package/src/sonar/api.js

@@ -1,6 +1,7 @@
 import { runCommand } from "../utils/process.js";
 import { withRetry } from "../utils/retry.js";
 import { resolveSonarProjectKey } from "./project-key.js";
+import { resolveSonarToken } from "./config-resolver.js";
 
 export class SonarApiError extends Error {
   constructor(message, { url, httpStatus, hint } = {}) {
@@ -13,7 +14,7 @@ export class SonarApiError extends Error {
 }
 
 function tokenFromConfig(config) {
-  return process.env.KJ_SONAR_TOKEN || config.sonarqube.token || "";
+  return resolveSonarToken(config) || "";
 }
 
 function parseHttpResponse(stdout) {
@@ -73,7 +74,7 @@ export async function getQualityGateStatus(config, projectKey = null) {
   try {
     const parsed = JSON.parse(body);
     return { ok: true, status: parsed.projectStatus?.status || "ERROR", conditions: parsed.projectStatus?.conditions || [], raw: parsed };
-  } catch {
+  } catch { /* SonarQube response is not valid JSON */
     return { ok: false, status: "ERROR", conditions: [], raw: body };
   }
 }
@@ -85,7 +86,7 @@ export async function getOpenIssues(config, projectKey = null) {
   try {
     const parsed = JSON.parse(body);
     return { total: parsed.total || 0, issues: parsed.issues || [], raw: parsed };
-  } catch {
+  } catch { /* SonarQube response is not valid JSON */
     return { total: 0, issues: [], raw: body };
   }
 }

package/src/sonar/config-resolver.js

@@ -0,0 +1,69 @@
+/**
+ * Centralized SonarQube configuration resolution.
+ *
+ * Single source of truth for host URL, token, and admin credentials.
+ * Consumers: scanner.js, preflight-checks.js, api.js.
+ */
+
+import { loadSonarCredentials } from "./credentials.js";
+
+const DEFAULT_HOST = "http://localhost:9000";
+
+/**
+ * Normalize SonarQube host URL for API calls (replace Docker-internal hostname).
+ * @param {string|undefined} rawHost - Raw host from config or env
+ * @returns {string} Normalized host URL without trailing slash
+ */
+export function resolveSonarHost(rawHost) {
+  const host = String(rawHost || DEFAULT_HOST)
+    .replace(/host\.docker\.internal/g, "localhost")
+    .replace(/\/+$/, "");
+  return host;
+}
+
+/**
+ * Resolve SonarQube auth token from (in priority order):
+ *   1. KJ_SONAR_TOKEN env var
+ *   2. config.sonarqube.token
+ *   3. SONAR_TOKEN env var
+ *
+ * @param {object} [config={}] - Karajan config object
+ * @returns {string|null} Token string or null if none found
+ */
+export function resolveSonarToken(config = {}) {
+  const token =
+    process.env.KJ_SONAR_TOKEN ||
+    config.sonarqube?.token ||
+    process.env.SONAR_TOKEN ||
+    null;
+  return token || null;
+}
+
+/**
+ * Resolve SonarQube admin credentials from (in priority order):
+ *   1. Env vars: KJ_SONAR_ADMIN_USER / KJ_SONAR_ADMIN_PASSWORD
+ *   2. Config: sonarqube.admin_user / sonarqube.admin_password
+ *   3. Credentials file: ~/.karajan/sonar-credentials.json
+ *
+ * Returns all candidate passwords (de-duped) so callers can try each.
+ *
+ * @param {object} [config={}] - Karajan config object
+ * @returns {Promise<{ user: string|null, passwords: string[] }>}
+ */
+export async function resolveSonarCredentials(config = {}) {
+  const fileCreds = (await loadSonarCredentials()) || {};
+
+  const user =
+    process.env.KJ_SONAR_ADMIN_USER ||
+    config.sonarqube?.admin_user ||
+    fileCreds.user ||
+    null;
+
+  const candidates = [
+    process.env.KJ_SONAR_ADMIN_PASSWORD,
+    config.sonarqube?.admin_password,
+    fileCreds.password,
+  ].filter(Boolean);
+
+  return { user, passwords: [...new Set(candidates)] };
+}

package/src/sonar/credentials.js

@@ -25,7 +25,7 @@ export async function loadSonarCredentials() {
       user: data.user || null,
       password: data.password || null
     };
-  } catch {
+  } catch { /* credentials file may not exist */
     return { user: null, password: null };
   }
 }

package/src/sonar/project-key.js

@@ -30,7 +30,7 @@ function parseUrlLikeRemote(remoteUrl) {
   try {
     const parsed = new URL(String(remoteUrl || "").trim());
     return { host: parsed.hostname, path: parsed.pathname.replace(/^\/+/, "") };
-  } catch {
+  } catch { /* not a valid URL */
     return null;
   }
 }

package/src/sonar/scanner.js

@@ -4,7 +4,11 @@ import path from "node:path";
 import { runCommand } from "../utils/process.js";
 import { sonarUp } from "./manager.js";
 import { resolveSonarProjectKey } from "./project-key.js";
-import { loadSonarCredentials } from "./credentials.js";
+import {
+  resolveSonarHost,
+  resolveSonarToken as resolveToken,
+  resolveSonarCredentials,
+} from "./config-resolver.js";
 
 export function buildScannerOpts(projectKey, scanner = {}) {
   const opts = [`-Dsonar.projectKey=${projectKey}`];
@@ -45,15 +49,11 @@ function normalizeScannerConfig(scanner = {}) {
 function parseJsonSafe(text) {
   try {
     return JSON.parse(text);
-  } catch {
+  } catch { /* invalid JSON */
     return null;
   }
 }
 
-function normalizeApiHost(rawHost) {
-  return String(rawHost || "http://localhost:9000").replaceAll("host.docker.internal", "localhost");
-}
-
 async function validateAdminCredentials(host, user, password) {
   const res = await runCommand("curl", [
     "-sS",
@@ -133,22 +133,14 @@ async function maybeRunCoverage(config) {
   return checkLcovExists(lcovPath, blockOnFailure, run.stdout || "");
 }
 
-async function resolveSonarToken(config, apiHost) {
-  const explicitToken = process.env.KJ_SONAR_TOKEN || process.env.SONAR_TOKEN || config.sonarqube.token;
+async function resolveSonarTokenWithFallback(config, apiHost) {
+  const explicitToken = resolveToken(config);
   if (explicitToken) return explicitToken;
 
-  // Resolve admin credentials from: env vars → config → ~/.karajan/sonar-credentials.json
-  const fileCreds = await loadSonarCredentials() || {};
-  const adminUser = process.env.KJ_SONAR_ADMIN_USER || config.sonarqube.admin_user || fileCreds.user;
-  const candidates = [
-    process.env.KJ_SONAR_ADMIN_PASSWORD,
-    config.sonarqube.admin_password,
-    fileCreds.password
-  ].filter(Boolean);
-
-  if (!adminUser || candidates.length === 0) return null;
+  const { user: adminUser, passwords } = await resolveSonarCredentials(config);
+  if (!adminUser || passwords.length === 0) return null;
 
-  for (const password of new Set(candidates)) {
+  for (const password of passwords) {
     const valid = await validateAdminCredentials(apiHost, adminUser, password);
     if (!valid) continue;
     const token = await generateUserToken(apiHost, adminUser, password);
@@ -205,7 +197,7 @@ export async function runSonarScan(config, projectKey = null) {
     ? Number(sonarConfig.timeouts.scanner_ms)
     : 15 * 60 * 1000;
   const sonarNetwork = sonarConfig.network || "karajan_sonar_net";
-  const apiHost = normalizeApiHost(rawHost);
+  const apiHost = resolveSonarHost(rawHost);
   const isLocalHost = /localhost|127\.0\.0\.1/.test(rawHost);
   const host = isLocalHost ? rawHost.replaceAll(/localhost|127\.0\.0\.1/g, "host.docker.internal") : rawHost;
 
@@ -219,7 +211,7 @@ export async function runSonarScan(config, projectKey = null) {
     };
   }
   await ensureSonarProjectProperties();
-  const token = await resolveSonarToken(config, apiHost);
+  const token = await resolveSonarTokenWithFallback(config, apiHost);
   if (!token) {
     return {
       ok: false,

package/src/utils/fs.js

@@ -9,7 +9,7 @@ export async function exists(filePath) {
   try {
     await fs.access(filePath);
     return true;
-  } catch {
+  } catch { /* file does not exist */
     return false;
   }
 }

package/src/utils/json-extract.js

@@ -54,7 +54,7 @@ export function extractFirstJson(raw) {
     if (depth === 0) {
       try {
         return JSON.parse(str.substring(start, i + 1));
-      } catch {
+      } catch { /* matched braces but not valid JSON */
         return null;
       }
     }

package/src/utils/project-detect.js

@@ -120,7 +120,7 @@ export async function detectSonarConfig(cwd = process.cwd()) {
   try {
     await fs.access(path.join(cwd, "sonar-project.properties"));
     return { configured: true };
-  } catch {
+  } catch { /* sonar-project.properties does not exist */
     return { configured: false };
   }
 }

package/src/utils/rtk-detect.js

@@ -12,7 +12,7 @@ export async function detectRtk() {
       return { available: true, version };
     }
     return { available: false, version: null };
-  } catch {
+  } catch { /* rtk binary not found */
     return { available: false, version: null };
   }
 }