karajan-code 1.20.0 → 1.21.0

package/package.json

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

package/src/cli.js

@@ -97,6 +97,8 @@ program
   .option("--methodology <name>")
   .option("--no-auto-rebase")
   .option("--no-sonar")
+  .option("--enable-sonarcloud", "Enable SonarCloud scan (complementary to SonarQube)")
+  .option("--no-sonarcloud")
   .option("--checkpoint-interval <n>", "Minutes between interactive checkpoints (default: 5)")
   .option("--pg-task <cardId>", "Planning Game card ID (e.g., KJC-TSK-0042)")
   .option("--pg-project <projectId>", "Planning Game project ID")

package/src/config.js

@@ -101,6 +101,18 @@ const DEFAULTS = {
       disabled_rules: ["javascript:S1116", "javascript:S3776"]
     }
   },
+  sonarcloud: {
+    enabled: false,
+    organization: null,
+    token: null,
+    project_key: null,
+    host: "https://sonarcloud.io",
+    scanner: {
+      sources: "src,public,lib",
+      exclusions: "**/node_modules/**,**/dist/**,**/build/**,**/*.min.js",
+      test_inclusions: "**/*.test.js,**/*.spec.js,**/tests/**,**/__tests__/**"
+    }
+  },
   policies: {},
   serena: { enabled: false },
   planning_game: { enabled: false, project_id: null, codeveloper: null },
@@ -347,6 +359,9 @@ function applyBecariaOverride(out, flags) {
 
 function applyMiscOverrides(out, flags) {
   if (flags.noSonar || flags.sonar === false) out.sonarqube.enabled = false;
+  out.sonarcloud = out.sonarcloud || {};
+  if (flags.enableSonarcloud === true) out.sonarcloud.enabled = true;
+  if (flags.noSonarcloud === true || flags.sonarcloud === false) out.sonarcloud.enabled = false;
 
   out.planning_game = out.planning_game || {};
   if (flags.pgTask) out.planning_game.enabled = true;

package/src/mcp/server-handlers.js

@@ -469,6 +469,138 @@ export async function handleDiscoverDirect(a, server, extra) {
   return { ok: true, ...result.result, summary: result.summary };
 }
 
+export async function handleTriageDirect(a, server, extra) {
+  const config = await buildConfig(a, "triage");
+  const logger = createLogger(config.output.log_level, "mcp");
+
+  const triageRole = resolveRole(config, "triage");
+  await assertAgentsAvailable([triageRole.provider]);
+
+  const projectDir = await resolveProjectDir(server);
+  const runLog = createRunLog(projectDir);
+  runLog.logText(`[kj_triage] started`);
+  const emitter = buildDirectEmitter(server, runLog, extra);
+  const eventBase = { sessionId: null, iteration: 0, startedAt: Date.now() };
+  const onOutput = ({ stream, line }) => {
+    emitter.emit("progress", { type: "agent:output", stage: "triage", message: line, detail: { stream, agent: triageRole.provider } });
+  };
+  const stallDetector = createStallDetector({
+    onOutput, emitter, eventBase, stage: "triage", provider: triageRole.provider
+  });
+
+  const { TriageRole } = await import("../roles/triage-role.js");
+  const triage = new TriageRole({ config, logger, emitter });
+  await triage.init({ task: a.task });
+
+  sendTrackerLog(server, "triage", "running", triageRole.provider);
+  runLog.logText(`[triage] agent launched, waiting for response...`);
+  let result;
+  try {
+    result = await triage.run({ task: a.task, onOutput: stallDetector.onOutput });
+  } finally {
+    stallDetector.stop();
+    const stats = stallDetector.stats();
+    runLog.logText(`[triage] finished — lines=${stats.lineCount}, bytes=${stats.bytesReceived}, elapsed=${Math.round(stats.elapsedMs / 1000)}s`);
+    runLog.close();
+  }
+
+  if (!result.ok) {
+    sendTrackerLog(server, "triage", "failed");
+    throw new Error(result.result?.error || result.summary || "Triage failed");
+  }
+
+  sendTrackerLog(server, "triage", "done");
+  return { ok: true, ...result.result, summary: result.summary };
+}
+
+export async function handleResearcherDirect(a, server, extra) {
+  const config = await buildConfig(a, "researcher");
+  const logger = createLogger(config.output.log_level, "mcp");
+
+  const researcherRole = resolveRole(config, "researcher");
+  await assertAgentsAvailable([researcherRole.provider]);
+
+  const projectDir = await resolveProjectDir(server);
+  const runLog = createRunLog(projectDir);
+  runLog.logText(`[kj_researcher] started`);
+  const emitter = buildDirectEmitter(server, runLog, extra);
+  const eventBase = { sessionId: null, iteration: 0, startedAt: Date.now() };
+  const onOutput = ({ stream, line }) => {
+    emitter.emit("progress", { type: "agent:output", stage: "researcher", message: line, detail: { stream, agent: researcherRole.provider } });
+  };
+  const stallDetector = createStallDetector({
+    onOutput, emitter, eventBase, stage: "researcher", provider: researcherRole.provider
+  });
+
+  const { ResearcherRole } = await import("../roles/researcher-role.js");
+  const researcher = new ResearcherRole({ config, logger, emitter });
+  await researcher.init({ task: a.task });
+
+  sendTrackerLog(server, "researcher", "running", researcherRole.provider);
+  runLog.logText(`[researcher] agent launched, waiting for response...`);
+  let result;
+  try {
+    result = await researcher.run({ task: a.task, onOutput: stallDetector.onOutput });
+  } finally {
+    stallDetector.stop();
+    const stats = stallDetector.stats();
+    runLog.logText(`[researcher] finished — lines=${stats.lineCount}, bytes=${stats.bytesReceived}, elapsed=${Math.round(stats.elapsedMs / 1000)}s`);
+    runLog.close();
+  }
+
+  if (!result.ok) {
+    sendTrackerLog(server, "researcher", "failed");
+    throw new Error(result.result?.error || result.summary || "Researcher failed");
+  }
+
+  sendTrackerLog(server, "researcher", "done");
+  return { ok: true, ...result.result, summary: result.summary };
+}
+
+export async function handleArchitectDirect(a, server, extra) {
+  const config = await buildConfig(a, "architect");
+  const logger = createLogger(config.output.log_level, "mcp");
+
+  const architectRole = resolveRole(config, "architect");
+  await assertAgentsAvailable([architectRole.provider]);
+
+  const projectDir = await resolveProjectDir(server);
+  const runLog = createRunLog(projectDir);
+  runLog.logText(`[kj_architect] started`);
+  const emitter = buildDirectEmitter(server, runLog, extra);
+  const eventBase = { sessionId: null, iteration: 0, startedAt: Date.now() };
+  const onOutput = ({ stream, line }) => {
+    emitter.emit("progress", { type: "agent:output", stage: "architect", message: line, detail: { stream, agent: architectRole.provider } });
+  };
+  const stallDetector = createStallDetector({
+    onOutput, emitter, eventBase, stage: "architect", provider: architectRole.provider
+  });
+
+  const { ArchitectRole } = await import("../roles/architect-role.js");
+  const architect = new ArchitectRole({ config, logger, emitter });
+  await architect.init({ task: a.task });
+
+  sendTrackerLog(server, "architect", "running", architectRole.provider);
+  runLog.logText(`[architect] agent launched, waiting for response...`);
+  let result;
+  try {
+    result = await architect.run({ task: a.task, researchContext: a.context || null, onOutput: stallDetector.onOutput });
+  } finally {
+    stallDetector.stop();
+    const stats = stallDetector.stats();
+    runLog.logText(`[architect] finished — lines=${stats.lineCount}, bytes=${stats.bytesReceived}, elapsed=${Math.round(stats.elapsedMs / 1000)}s`);
+    runLog.close();
+  }
+
+  if (!result.ok) {
+    sendTrackerLog(server, "architect", "failed");
+    throw new Error(result.result?.error || result.summary || "Architect failed");
+  }
+
+  sendTrackerLog(server, "architect", "done");
+  return { ok: true, ...result.result, summary: result.summary };
+}
+
 /* ── Preflight helpers ─────────────────────────────────────────────── */
 
 const AGENT_ROLES = new Set(["coder", "reviewer", "tester", "security", "solomon"]);
@@ -662,6 +794,27 @@ async function handleDiscover(a, server, extra) {
   return handleDiscoverDirect(a, server, extra);
 }
 
+async function handleTriage(a, server, extra) {
+  if (!a.task) {
+    return failPayload("Missing required field: task");
+  }
+  return handleTriageDirect(a, server, extra);
+}
+
+async function handleResearcher(a, server, extra) {
+  if (!a.task) {
+    return failPayload("Missing required field: task");
+  }
+  return handleResearcherDirect(a, server, extra);
+}
+
+async function handleArchitect(a, server, extra) {
+  if (!a.task) {
+    return failPayload("Missing required field: task");
+  }
+  return handleArchitectDirect(a, server, extra);
+}
+
 /* ── Handler dispatch map ─────────────────────────────────────────── */
 
 const toolHandlers = {
@@ -679,7 +832,10 @@ const toolHandlers = {
   kj_code:      (a, server, extra) => handleCode(a, server, extra),
   kj_review:    (a, server, extra) => handleReview(a, server, extra),
   kj_plan:      (a, server, extra) => handlePlan(a, server, extra),
-  kj_discover:  (a, server, extra) => handleDiscover(a, server, extra)
+  kj_discover:    (a, server, extra) => handleDiscover(a, server, extra),
+  kj_triage:      (a, server, extra) => handleTriage(a, server, extra),
+  kj_researcher:  (a, server, extra) => handleResearcher(a, server, extra),
+  kj_architect:   (a, server, extra) => handleArchitect(a, server, extra)
 };
 
 export async function handleToolCall(name, args, server, extra) {

package/src/mcp/tools.js

@@ -93,6 +93,7 @@ export const tools = [
         checkpointInterval: { type: "number", description: "Minutes between interactive checkpoints (default: 5). Set 0 to disable." },
         taskType: { type: "string", enum: ["sw", "infra", "doc", "add-tests", "refactor"], description: "Explicit task type for policy resolution. Overrides triage classification." },
         noSonar: { type: "boolean" },
+        enableSonarcloud: { type: "boolean", description: "Enable SonarCloud scan (complementary to SonarQube)" },
         kjHome: { type: "string" },
         sonarToken: { type: "string" },
         timeoutMs: { type: "number" }
@@ -242,5 +243,42 @@ export const tools = [
         kjHome: { type: "string" }
       }
     }
+  },
+  {
+    name: "kj_triage",
+    description: "Classify task complexity and recommend which pipeline roles to activate. Returns level (trivial/simple/medium/complex), taskType, recommended roles, and optional decomposition.",
+    inputSchema: {
+      type: "object",
+      required: ["task"],
+      properties: {
+        task: { type: "string", description: "Task description to classify" },
+        kjHome: { type: "string" }
+      }
+    }
+  },
+  {
+    name: "kj_researcher",
+    description: "Research the codebase for a task. Identifies affected files, patterns, constraints, prior decisions, risks, and test coverage.",
+    inputSchema: {
+      type: "object",
+      required: ["task"],
+      properties: {
+        task: { type: "string", description: "Task description to research" },
+        kjHome: { type: "string" }
+      }
+    }
+  },
+  {
+    name: "kj_architect",
+    description: "Design solution architecture for a task. Returns layers, patterns, data model, API contracts, tradeoffs, and a verdict (ready/needs_clarification).",
+    inputSchema: {
+      type: "object",
+      required: ["task"],
+      properties: {
+        task: { type: "string", description: "Task description to architect" },
+        context: { type: "string", description: "Additional context (e.g., researcher output)" },
+        kjHome: { type: "string" }
+      }
+    }
   }
 ];

package/src/orchestrator/iteration-stages.js

@@ -427,6 +427,47 @@ export async function runSonarStage({ config, logger, emitter, eventBase, sessio
   return { action: "ok", stageResult };
 }
 
+export async function runSonarCloudStage({ config, logger, emitter, eventBase, session, trackBudget, iteration }) {
+  logger.setContext({ iteration, stage: "sonarcloud" });
+  emitProgress(
+    emitter,
+    makeEvent("sonarcloud:start", { ...eventBase, stage: "sonarcloud" }, {
+      message: "SonarCloud scanning"
+    })
+  );
+
+  const { runSonarCloudScan } = await import("../sonar/cloud-scanner.js");
+  const scanStart = Date.now();
+  const result = await runSonarCloudScan(config);
+  trackBudget({ role: "sonarcloud", provider: "sonarcloud", result: { ok: result.ok }, duration_ms: Date.now() - scanStart });
+
+  await addCheckpoint(session, {
+    stage: "sonarcloud",
+    iteration,
+    project_key: result.projectKey,
+    exitCode: result.exitCode,
+    provider: "sonarcloud",
+    model: null
+  });
+
+  const status = result.ok ? "ok" : "warn";
+  const message = result.ok
+    ? `SonarCloud scan passed (project: ${result.projectKey})`
+    : `SonarCloud scan issue: ${(result.stderr || "").slice(0, 200)}`;
+
+  emitProgress(
+    emitter,
+    makeEvent("sonarcloud:end", { ...eventBase, stage: "sonarcloud" }, {
+      status,
+      message,
+      detail: { projectKey: result.projectKey, exitCode: result.exitCode }
+    })
+  );
+
+  // SonarCloud is advisory — never blocks the pipeline
+  return { action: "ok", stageResult: { ok: result.ok, projectKey: result.projectKey, message } };
+}
+
 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.`);
   emitProgress(

package/src/orchestrator.js

@@ -30,7 +30,7 @@ import { resolveReviewProfile } from "./review/profiles.js";
 import { CoderRole } from "./roles/coder-role.js";
 import { invokeSolomon } from "./orchestrator/solomon-escalation.js";
 import { runTriageStage, runResearcherStage, runArchitectStage, runPlannerStage, runDiscoverStage } from "./orchestrator/pre-loop-stages.js";
-import { runCoderStage, runRefactorerStage, runTddCheckStage, runSonarStage, runReviewerStage } from "./orchestrator/iteration-stages.js";
+import { runCoderStage, runRefactorerStage, runTddCheckStage, runSonarStage, runSonarCloudStage, runReviewerStage } from "./orchestrator/iteration-stages.js";
 import { runTesterStage, runSecurityStage } from "./orchestrator/post-loop-stages.js";
 import { waitForCooldown, MAX_STANDBY_RETRIES } from "./orchestrator/standby.js";
 
@@ -910,6 +910,15 @@ async function runQualityGateStages({ config, logger, emitter, eventBase, sessio
     }
   }
 
+  if (config.sonarcloud?.enabled) {
+    const cloudResult = await runSonarCloudStage({
+      config, logger, emitter, eventBase, session, trackBudget, iteration: i
+    });
+    if (cloudResult.stageResult) {
+      stageResults.sonarcloud = cloudResult.stageResult;
+    }
+  }
+
   return { action: "ok" };
 }
 

package/src/sonar/cloud-scanner.js

@@ -0,0 +1,76 @@
+import { runCommand } from "../utils/process.js";
+import { resolveSonarProjectKey } from "./project-key.js";
+
+function buildCloudScannerArgs(projectKey, config) {
+  const sc = config.sonarcloud || {};
+  const scanner = sc.scanner || {};
+  const host = sc.host || "https://sonarcloud.io";
+  const token = process.env.KJ_SONARCLOUD_TOKEN || sc.token;
+  const organization = process.env.KJ_SONARCLOUD_ORG || sc.organization;
+
+  const args = [
+    `-Dsonar.host.url=${host}`,
+    `-Dsonar.projectKey=${projectKey}`
+  ];
+
+  if (token) args.push(`-Dsonar.token=${token}`);
+  if (organization) args.push(`-Dsonar.organization=${organization}`);
+  if (scanner.sources) args.push(`-Dsonar.sources=${scanner.sources}`);
+  if (scanner.exclusions) args.push(`-Dsonar.exclusions=${scanner.exclusions}`);
+  if (scanner.test_inclusions) args.push(`-Dsonar.test.inclusions=${scanner.test_inclusions}`);
+
+  return args;
+}
+
+export async function runSonarCloudScan(config, projectKey = null) {
+  const sc = config.sonarcloud || {};
+  const token = process.env.KJ_SONARCLOUD_TOKEN || sc.token;
+  const organization = sc.organization || process.env.KJ_SONARCLOUD_ORG;
+
+  if (!token) {
+    return {
+      ok: false,
+      projectKey: null,
+      stdout: "",
+      stderr: "SonarCloud token not configured. Set sonarcloud.token in kj.config.yml or KJ_SONARCLOUD_TOKEN env var.",
+      exitCode: 1
+    };
+  }
+
+  if (!organization) {
+    return {
+      ok: false,
+      projectKey: null,
+      stdout: "",
+      stderr: "SonarCloud organization not configured. Set sonarcloud.organization in kj.config.yml or KJ_SONARCLOUD_ORG env var.",
+      exitCode: 1
+    };
+  }
+
+  let effectiveProjectKey;
+  try {
+    effectiveProjectKey = projectKey || sc.project_key || await resolveSonarProjectKey(config, { projectKey });
+  } catch (error) {
+    return {
+      ok: false,
+      projectKey: null,
+      stdout: "",
+      stderr: error?.message || String(error),
+      exitCode: 1
+    };
+  }
+
+  const scannerTimeout = 15 * 60 * 1000;
+  const args = buildCloudScannerArgs(effectiveProjectKey, config);
+
+  // Use npx @sonar/scan (no Docker needed)
+  const result = await runCommand("npx", ["@sonar/scan", ...args], { timeout: scannerTimeout });
+
+  return {
+    ok: result.exitCode === 0,
+    projectKey: effectiveProjectKey,
+    stdout: result.stdout,
+    stderr: result.stderr,
+    exitCode: result.exitCode
+  };
+}