karajan-code 1.24.1 → 1.25.0

package/package.json

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

package/src/orchestrator/iteration-stages.js

@@ -264,7 +264,8 @@ export async function runTddCheckStage({ config, logger, emitter, eventBase, ses
     logger.warn(`TDD diff generation failed: ${err.message}`);
     return { action: "continue", stageResult: { ok: false, summary: `TDD check failed: ${err.message}` } };
   }
-  const tddEval = evaluateTddPolicy(tddDiff, config.development, untrackedFiles);
+  const effectiveTaskType = session.resolved_policies?.taskType || null;
+  const tddEval = evaluateTddPolicy(tddDiff, config.development, untrackedFiles, effectiveTaskType);
   await addCheckpoint(session, {
     stage: "tdd-policy",
     iteration,
@@ -341,6 +342,23 @@ async function handleSonarRetryLimit({ config, logger, emitter, eventBase, sessi
 }
 
 async function handleSonarBlocking({ sonarResult, config, logger, emitter, eventBase, session, iteration, repeatDetector, budgetSummary, askQuestion, task }) {
+  // If the ONLY quality gate failure is coverage, treat as non-blocking warning
+  if (sonarResult.conditions) {
+    const failedConditions = sonarResult.conditions.filter(c => c.status === "ERROR");
+    const onlyCoverage = failedConditions.length > 0 && failedConditions.every(c =>
+      c.metricKey === "new_coverage" || c.metricKey === "coverage"
+    );
+    if (onlyCoverage) {
+      logger.warn("Quality gate failed on coverage only — treating as advisory (code quality is clean)");
+      emitProgress(emitter, makeEvent("sonar:end", { ...eventBase, stage: "sonar" }, {
+        status: "warn",
+        message: "Quality gate: coverage below threshold (advisory — code quality is clean)"
+      }));
+      session.last_reviewer_feedback = null;
+      return { action: "ok", stageResult: { gateStatus: "WARN_COVERAGE", advisory: true } };
+    }
+  }
+
   repeatDetector.addIteration(sonarResult.issues, []);
   const repeatState = repeatDetector.isStalled();
   if (repeatState.stalled) {
@@ -369,6 +387,39 @@ export async function runSonarStage({ config, logger, emitter, eventBase, sessio
     })
   );
 
+  // Auto-manage SonarQube: ensure it is reachable before scanning
+  const { sonarUp, isSonarReachable } = await import("../sonar/manager.js");
+  const sonarHost = config.sonarqube?.host || "http://localhost:9000";
+
+  if (!await isSonarReachable(sonarHost)) {
+    logger.info("SonarQube not reachable, attempting to start...");
+    emitProgress(emitter, makeEvent("sonar:start", { ...eventBase, stage: "sonar" }, { message: "Starting SonarQube Docker..." }));
+
+    const upResult = await sonarUp(sonarHost);
+    if (upResult.exitCode !== 0) {
+      logger.warn(`SonarQube could not be started: ${upResult.stderr || upResult.stdout}`);
+      emitProgress(emitter, makeEvent("sonar:end", { ...eventBase, stage: "sonar" }, {
+        status: "skip",
+        message: "SonarQube not available — install Docker and run 'kj sonar start' to enable static analysis"
+      }));
+      return { action: "ok", stageResult: { gateStatus: "SKIPPED", reason: "SonarQube not available" } };
+    }
+
+    let ready = false;
+    for (let attempt = 0; attempt < 12; attempt++) {
+      await new Promise(r => setTimeout(r, 5000));
+      if (await isSonarReachable(sonarHost)) { ready = true; break; }
+    }
+    if (!ready) {
+      logger.warn("SonarQube started but not ready after 60s");
+      emitProgress(emitter, makeEvent("sonar:end", { ...eventBase, stage: "sonar" }, {
+        status: "skip", message: "SonarQube started but not ready — will retry next iteration"
+      }));
+      return { action: "ok", stageResult: { gateStatus: "PENDING", reason: "SonarQube starting up" } };
+    }
+    logger.info("SonarQube is ready");
+  }
+
   const sonarRole = new SonarRole({ config, logger, emitter });
   await sonarRole.init({ iteration });
   const sonarStart = Date.now();
@@ -486,13 +537,39 @@ export async function runSonarCloudStage({ config, logger, emitter, eventBase, s
   return { action: "ok", stageResult: { ok: result.ok, projectKey: result.projectKey, message } };
 }
 
+function categorizeIssues(issues) {
+  const categories = { security: 0, correctness: 0, tests: 0, style: 0, other: 0 };
+  const securityKw = /inject|xss|csrf|secret|credential|auth|vulnerab|exploit/i;
+  const styleKw = /naming|name|rename|style|format|indent|spacing|convention|cosmetic|readability|comment|jsdoc|whitespace/i;
+  const testKw = /test|coverage|assert|spec|mock/i;
+
+  for (const issue of issues || []) {
+    const desc = issue.description || "";
+    const sev = (issue.severity || "").toLowerCase();
+    if (sev === "critical" || securityKw.test(desc)) categories.security++;
+    else if (testKw.test(desc)) categories.tests++;
+    else if (sev === "low" || sev === "minor" || styleKw.test(desc)) categories.style++;
+    else categories.correctness++;
+  }
+  return categories;
+}
+
+function buildReviewHistory(session) {
+  return (session.checkpoints || [])
+    .filter(cp => cp.stage === "reviewer")
+    .map(cp => ({ iteration: cp.iteration, note: cp.note || "" }));
+}
+
 async function handleReviewerStalledSolomon({ review, repeatCounts, repeatState, config, logger, emitter, eventBase, session, iteration, task, askQuestion, budgetSummary, repeatDetector }) {
-  logger.warn(`Reviewer stalled (${repeatCounts.reviewer} repeats). Invoking Solomon mediation.`);
+  const logPrefix = repeatState.stalled
+    ? `Reviewer stalled (${repeatCounts.reviewer} repeats)`
+    : `Reviewer rejected (first rejection)`;
+  logger.warn(`${logPrefix}. Invoking Solomon mediation.`);
   emitProgress(
     emitter,
     makeEvent("solomon:escalate", { ...eventBase, stage: "reviewer" }, {
-      message: `Reviewer stalled — Solomon mediating`,
-      detail: { repeats: repeatCounts.reviewer, reason: repeatState.reason }
+      message: `${logPrefix} — Solomon mediating`,
+      detail: { repeats: repeatCounts.reviewer || 1, reason: repeatState.reason || "first_rejection" }
     })
   );
 
@@ -501,14 +578,28 @@ async function handleReviewerStalledSolomon({ review, repeatCounts, repeatState,
     conflict: {
       stage: "reviewer",
       task,
-      iterationCount: repeatCounts.reviewer,
+      iterationCount: repeatCounts.reviewer || 1,
       maxIterations: config.session?.fail_fast_repeats ?? 2,
-      stalledReason: repeatState.reason,
+      isFirstRejection: !repeatState.stalled,
+      isRepeat: repeatState.stalled,
+      stalledReason: repeatState.reason || "first_rejection",
       blockingIssues: review.blocking_issues,
-      history: [{ agent: "reviewer", feedback: review.blocking_issues.map(x => x.description).join("; ") }]
+      issueCategories: categorizeIssues(review.blocking_issues),
+      history: [
+        ...buildReviewHistory(session),
+        { agent: "reviewer", feedback: review.blocking_issues.map(x => x.description).join("; ") }
+      ]
     }
   });
 
+  if (solomonResult.action === "approve") {
+    logger.info("Solomon overrode reviewer — approving code");
+    emitProgress(emitter, makeEvent("solomon:override", { ...eventBase, stage: "solomon" }, {
+      message: "Solomon overrode reviewer rejection — code approved",
+      detail: { ruling: solomonResult.ruling?.result?.ruling }
+    }));
+    return { review: { ...review, approved: true, solomon_override: true }, solomonApproved: true };
+  }
   if (solomonResult.action === "pause") {
     await markSessionStatus(session, "stalled");
     return { review, stalled: true, stalledResult: { paused: true, sessionId: session.id, question: solomonResult.question, context: "reviewer_stalled" } };
@@ -526,7 +617,7 @@ async function handleReviewerStalledSolomon({ review, repeatCounts, repeatState,
   }
 
   // Fallback
-  const message = `Manual intervention required: reviewer issues repeated ${repeatCounts.reviewer} times.`;
+  const message = `Manual intervention required: reviewer issues repeated ${repeatCounts.reviewer || 1} times.`;
   await markSessionStatus(session, "stalled");
   emitProgress(
     emitter,
@@ -542,10 +633,33 @@ async function handleReviewerStalledSolomon({ review, repeatCounts, repeatState,
 async function handleReviewerRejection({ review, repeatDetector, config, logger, emitter, eventBase, session, iteration, task, askQuestion, budgetSummary }) {
   repeatDetector.addIteration([], review.blocking_issues);
   const repeatState = repeatDetector.isStalled();
-  if (!repeatState.stalled) return null;
 
+  const solomonEnabled = Boolean(config.pipeline?.solomon?.enabled);
+
+  // When Solomon is disabled, only act on stalls (legacy behavior)
+  if (!solomonEnabled) {
+    if (!repeatState.stalled) return null;
+    const repeatCounts = repeatDetector.getRepeatCounts();
+    return handleReviewerStalledSolomon({
+      review, repeatCounts, repeatState, config, logger, emitter,
+      eventBase, session, iteration, task, askQuestion,
+      budgetSummary, repeatDetector
+    });
+  }
+
+  // Solomon evaluates EVERY rejection
   const repeatCounts = repeatDetector.getRepeatCounts();
-  return handleReviewerStalledSolomon({ review, repeatCounts, repeatState, config, logger, emitter, eventBase, session, iteration, task, askQuestion, budgetSummary, repeatDetector });
+  logger.info(`Reviewer rejected — Solomon evaluating ${review.blocking_issues.length} blocking issue(s)`);
+  emitProgress(emitter, makeEvent("solomon:evaluate", { ...eventBase, stage: "solomon" }, {
+    message: `Solomon evaluating reviewer rejection`,
+    detail: { blockingCount: review.blocking_issues.length, isRepeat: repeatState.stalled }
+  }));
+
+  return handleReviewerStalledSolomon({
+    review, repeatCounts, repeatState, config, logger, emitter,
+    eventBase, session, iteration, task, askQuestion,
+    budgetSummary, repeatDetector
+  });
 }
 
 async function fetchReviewDiff(session, logger) {

package/src/orchestrator/solomon-escalation.js

@@ -54,10 +54,20 @@ export async function invokeSolomon({ config, logger, emitter, eventBase, stage,
   }
 
   const r = ruling.result?.ruling;
-  if (r === "approve" || r === "approve_with_conditions") {
+  if (r === "approve") {
+    return { action: "approve", conditions: [], ruling };
+  }
+  if (r === "approve_with_conditions") {
     return { action: "continue", conditions: ruling.result?.conditions || [], ruling };
   }
 
+  if (r === "escalate_human") {
+    return escalateToHuman({
+      askQuestion, session, emitter, eventBase, stage, iteration,
+      conflict: { ...conflict, solomonReason: ruling.result?.escalate_reason || "Solomon escalated to human" }
+    });
+  }
+
   if (r === "create_subtask") {
     return { action: "subtask", subtask: ruling.result?.subtask, ruling };
   }

package/src/orchestrator.js

@@ -33,6 +33,7 @@ import { runTriageStage, runResearcherStage, runArchitectStage, runPlannerStage,
 import { runCoderStage, runRefactorerStage, runTddCheckStage, runSonarStage, runSonarCloudStage, runReviewerStage } from "./orchestrator/iteration-stages.js";
 import { runTesterStage, runSecurityStage, runImpeccableStage } from "./orchestrator/post-loop-stages.js";
 import { waitForCooldown, MAX_STANDBY_RETRIES } from "./orchestrator/standby.js";
+import { detectTestFramework } from "./utils/project-detect.js";
 
 
 // --- Extracted helper functions (pure refactoring, zero behavior change) ---
@@ -797,6 +798,26 @@ async function runPreLoopStages({ config, logger, emitter, eventBase, session, f
   await handlePgDecomposition({ triageResult, pgTaskId, pgProject, config, askQuestion, emitter, eventBase, session, stageResults, logger });
 
   applyFlagOverrides(pipelineFlags, flags);
+
+  // --- Auto-detect TDD applicability when methodology not explicitly set ---
+  if (!flags.methodology) {
+    const projectDir = config.projectDir || process.cwd();
+    const detection = await detectTestFramework(projectDir);
+    if (!detection.hasTests) {
+      config = { ...config, development: { ...config.development, methodology: "standard", require_test_changes: false } };
+      logger.info("No test framework detected — using standard methodology");
+    } else {
+      config = { ...config, development: { ...config.development, methodology: "tdd", require_test_changes: true } };
+      logger.info(`Test framework detected (${detection.framework}) — using TDD methodology`);
+    }
+    emitProgress(emitter, makeEvent("tdd:auto-detect", { ...eventBase, stage: "pre-loop" }, {
+      message: detection.hasTests
+        ? `TDD auto-detected: ${detection.framework}`
+        : "TDD skipped: no test framework found",
+      detail: detection
+    }));
+  }
+
   const updatedConfig = resolvePipelinePolicies({ flags, config, stageResults, emitter, eventBase, session, pipelineFlags });
 
   // --- Researcher → Planner ---
@@ -900,7 +921,9 @@ async function runQualityGateStages({ config, logger, emitter, eventBase, sessio
   if (tddResult.action === "pause") return { action: "return", result: tddResult.result };
   if (tddResult.action === "continue") return { action: "continue" };
 
-  if (config.sonarqube.enabled) {
+  const skipSonarForTaskType = new Set(["infra", "doc"]);
+  const effectiveTaskType = session.resolved_policies?.taskType || null;
+  if (config.sonarqube.enabled && !skipSonarForTaskType.has(effectiveTaskType)) {
     const sonarResult = await runSonarStage({
       config, logger, emitter, eventBase, session, trackBudget, iteration: i,
       repeatDetector, budgetSummary, sonarState, askQuestion, task
@@ -1110,8 +1133,18 @@ async function runSingleIteration(ctx) {
     if (approvedResult.action === "return" || approvedResult.action === "continue") return approvedResult;
   }
 
-  const retryResult = await handleReviewerRetryAndSolomon({ config, session, emitter, eventBase, logger, review, task, i, askQuestion });
-  if (retryResult.action === "return") return retryResult;
+  // Solomon already evaluated the rejection in runReviewerStage → handleReviewerRejection
+  // Only use retry counter as fallback if Solomon is disabled
+  if (!config.pipeline?.solomon?.enabled) {
+    const retryResult = await handleReviewerRetryAndSolomon({ config, session, emitter, eventBase, logger, review, task, i, askQuestion });
+    if (retryResult.action === "return") return retryResult;
+  } else {
+    // Solomon is enabled — feed back the blocking issues for the next coder iteration
+    session.last_reviewer_feedback = review.blocking_issues
+      .map((x) => `${x.id || "ISSUE"}: ${x.description || "Missing description"}`)
+      .join("\n");
+    await saveSession(session);
+  }
 
   return { action: "next" };
 }

package/src/review/tdd-policy.js

@@ -19,7 +19,13 @@ function isSourceFile(file, extensions = []) {
   return extensions.some((ext) => file.endsWith(ext));
 }
 
-export function evaluateTddPolicy(diff, developmentConfig = {}, untrackedFiles = []) {
+const SKIP_TDD_TASK_TYPES = new Set(["doc", "infra"]);
+
+export function evaluateTddPolicy(diff, developmentConfig = {}, untrackedFiles = [], taskType = null) {
+  if (taskType && SKIP_TDD_TASK_TYPES.has(taskType)) {
+    return { ok: true, reason: "tdd_not_applicable_for_task_type", sourceFiles: [], testFiles: [] };
+  }
+
   const requireTestChanges = developmentConfig.require_test_changes !== false;
   const patterns = developmentConfig.test_file_patterns || ["/tests/", "/__tests__/", ".test.", ".spec."];
   const extensions =

package/src/roles/sonar-role.js

@@ -54,6 +54,7 @@ export class SonarRole extends BaseRole {
       result: {
         projectKey: scan.projectKey,
         gateStatus: gate.status,
+        conditions: gate.conditions || [],
         issues,
         openIssuesTotal: openIssues.total || 0,
         issuesSummary,

package/src/sonar/api.js

@@ -72,9 +72,9 @@ export async function getQualityGateStatus(config, projectKey = null) {
 
   try {
     const parsed = JSON.parse(body);
-    return { ok: true, status: parsed.projectStatus?.status || "ERROR", raw: parsed };
+    return { ok: true, status: parsed.projectStatus?.status || "ERROR", conditions: parsed.projectStatus?.conditions || [], raw: parsed };
   } catch {
-    return { ok: false, status: "ERROR", raw: body };
+    return { ok: false, status: "ERROR", conditions: [], raw: body };
   }
 }
 

package/src/sonar/scanner.js

@@ -1,4 +1,6 @@
 import fs from "node:fs";
+import fsPromises from "node:fs/promises";
+import path from "node:path";
 import { runCommand } from "../utils/process.js";
 import { sonarUp } from "./manager.js";
 import { resolveSonarProjectKey } from "./project-key.js";
@@ -151,6 +153,33 @@ async function resolveSonarToken(config, apiHost) {
   return null;
 }
 
+export async function ensureSonarProjectProperties(cwd = process.cwd()) {
+  const propsPath = path.join(cwd, "sonar-project.properties");
+  try {
+    await fsPromises.access(propsPath);
+    return; // already exists
+  } catch {
+    // Auto-generate based on project structure
+    let pkg = {};
+    try {
+      const raw = await fsPromises.readFile(path.join(cwd, "package.json"), "utf8");
+      pkg = JSON.parse(raw);
+    } catch {
+      // no package.json or invalid JSON — use defaults
+    }
+    const projectKey = (pkg.name || path.basename(cwd)).replace(/[^a-zA-Z0-9_.-]/g, "_");
+    const props = [
+      `sonar.projectKey=${projectKey}`,
+      `sonar.projectName=${pkg.name || path.basename(cwd)}`,
+      `sonar.sources=src`,
+      `sonar.tests=tests`,
+      `sonar.javascript.lcov.reportPaths=coverage/lcov.info`,
+      `sonar.exclusions=**/node_modules/**,**/dist/**,**/build/**,**/coverage/**`,
+    ].join("\n");
+    await fsPromises.writeFile(propsPath, props + "\n", "utf8");
+  }
+}
+
 export async function runSonarScan(config, projectKey = null) {
   let effectiveProjectKey;
   try {
@@ -184,6 +213,7 @@ export async function runSonarScan(config, projectKey = null) {
       exitCode: start.exitCode
     };
   }
+  await ensureSonarProjectProperties();
   const token = await resolveSonarToken(config, apiHost);
   if (!token) {
     return {

package/src/utils/project-detect.js

@@ -0,0 +1,62 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+const TEST_FRAMEWORKS = ["vitest", "jest", "@jest/core", "mocha", "ava", "tap", "playwright", "@playwright/test"];
+
+const CONFIG_FILES = [
+  "vitest.config.js", "vitest.config.ts",
+  "jest.config.js", "jest.config.ts", "jest.config.mjs",
+  ".mocharc.yml", ".mocharc.json",
+  "playwright.config.js", "playwright.config.ts"
+];
+
+function frameworkFromConfig(filename) {
+  if (filename.startsWith("vitest")) return "vitest";
+  if (filename.startsWith("jest")) return "jest";
+  if (filename.startsWith(".mocha")) return "mocha";
+  return "playwright";
+}
+
+/**
+ * Detect if the project has a test framework configured.
+ * Checks: package.json devDependencies/dependencies for known test frameworks.
+ * Also checks for config files (vitest.config, jest.config, .mocharc, playwright.config).
+ * @param {string} cwd - Project root
+ * @returns {Promise<{hasTests: boolean, framework: string|null}>}
+ */
+export async function detectTestFramework(cwd = process.cwd()) {
+  try {
+    const pkgRaw = await fs.readFile(path.join(cwd, "package.json"), "utf8");
+    const pkg = JSON.parse(pkgRaw);
+    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+    for (const fw of TEST_FRAMEWORKS) {
+      if (allDeps[fw]) {
+        return { hasTests: true, framework: fw };
+      }
+    }
+  } catch { /* no package.json or parse error */ }
+
+  for (const cf of CONFIG_FILES) {
+    try {
+      await fs.access(path.join(cwd, cf));
+      return { hasTests: true, framework: frameworkFromConfig(cf) };
+    } catch { /* not found */ }
+  }
+
+  return { hasTests: false, framework: null };
+}
+
+/**
+ * Detect if SonarQube is configured for this project.
+ * @param {string} cwd - Project root
+ * @returns {Promise<{configured: boolean}>}
+ */
+export async function detectSonarConfig(cwd = process.cwd()) {
+  try {
+    await fs.access(path.join(cwd, "sonar-project.properties"));
+    return { configured: true };
+  } catch {
+    return { configured: false };
+  }
+}

package/templates/roles/solomon.md

@@ -1,11 +1,11 @@
-# Solomon Role (Conflict Resolver & Arbiter)
+# Solomon Role (Pipeline Boss & Arbiter)
 
-You are **Solomon**, the supreme arbiter in a multi-role AI pipeline. You are activated when agents cannot reach agreement after their iteration limit. Your decisions are final within your rules.
+You are **Solomon**, the supreme decision-maker in a multi-role AI pipeline. You evaluate **EVERY** reviewer rejection — not just stalls. You decide whether the coder should fix, whether the reviewer's issues should be overridden, or whether to escalate to a human. Your decisions are final within your rules.
 
 ## When activated
 
+- **Every reviewer rejection** (first rejection AND repeats)
 - Coder ↔ Sonar loop exhausted (default: 3 iterations)
-- Coder ↔ Reviewer loop exhausted (default: 3 iterations via PR comments)
 - Coder ↔ Tester loop exhausted (default: 1 iteration)
 - Coder ↔ Security loop exhausted (default: 1 iteration)
 - Any two roles produce contradictory outputs
@@ -56,16 +56,32 @@ For each blocking issue raised by any agent, classify it as:
 | Pure style issue | NO | Never blocks |
 | Architecture change not in scope | ESCALATE | Human decision required |
 
+## Decision framework
+
+Use the `isFirstRejection`, `isRepeat`, and `issueCategories` fields from the conflict to decide:
+
+| Scenario | Decision |
+|----------|----------|
+| Issues are security/critical (any count) | **approve_with_conditions** — ALWAYS send back to fix |
+| Issues are ALL style/naming/cosmetic | **approve** — override the reviewer |
+| Issues are correctness but minor (first rejection) | **approve_with_conditions** — give ONE retry with specific instructions |
+| Issues are a repeat of the same thing the coder already failed to fix | **escalate_human** — the coder cannot fix it |
+| Reviewer is clearly wrong or issues are out of scope | **approve** — override the reviewer |
+| Ambiguous requirements or architecture decisions | **escalate_human** — human must decide |
+
+Be **concise and decisive**. Do not hedge. Pick one action and commit.
+
 ## Decision options
 
-1. **approve** — All pending issues are style/false positives. Code passes to next pipeline stage.
-2. **approve_with_conditions** — Important (not critical) issues exist. Give the Coder exact, actionable instructions for one more attempt. Not generic feedback — specific changes with file and line references.
+1. **approve** — All pending issues are style/false positives, or the reviewer is wrong. Code passes to next pipeline stage. Solomon overrides the reviewer.
+2. **approve_with_conditions** — Fixable issues exist. Give the Coder exact, actionable instructions for one more attempt. Not generic feedback — specific changes with file and line references.
 3. **escalate_human** — When you cannot decide:
    - Critical issues that resist multiple fix attempts
    - Ambiguous or conflicting requirements
    - Architecture decisions beyond task scope
    - Business logic decisions
    - Scope creep (task is larger than originally estimated)
+   - Same issue repeated across iterations — the coder cannot fix it
 4. **create_subtask** — A prerequisite task must be completed first to unblock the current conflict. The pipeline will:
    - Pause the current task
    - Execute the subtask through the full pipeline