karajan-code 1.2.2 → 1.3.0

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

@@ -0,0 +1,141 @@
+import { TesterRole } from "../roles/tester-role.js";
+import { SecurityRole } from "../roles/security-role.js";
+import { addCheckpoint, saveSession } from "../session-store.js";
+import { emitProgress, makeEvent } from "../utils/events.js";
+import { invokeSolomon } from "./solomon-escalation.js";
+
+export async function runTesterStage({ config, logger, emitter, eventBase, session, coderRole, trackBudget, iteration, task, diff, askQuestion }) {
+  logger.setContext({ iteration, stage: "tester" });
+  emitProgress(
+    emitter,
+    makeEvent("tester:start", { ...eventBase, stage: "tester" }, {
+      message: "Tester evaluating test quality"
+    })
+  );
+
+  const tester = new TesterRole({ config, logger, emitter });
+  await tester.init({ task, iteration });
+  const testerStart = Date.now();
+  const testerOutput = await tester.run({ task, diff });
+  trackBudget({
+    role: "tester",
+    provider: config?.roles?.tester?.provider || coderRole.provider,
+    model: config?.roles?.tester?.model || coderRole.model,
+    result: testerOutput,
+    duration_ms: Date.now() - testerStart
+  });
+
+  await addCheckpoint(session, { stage: "tester", iteration, ok: testerOutput.ok });
+
+  emitProgress(
+    emitter,
+    makeEvent("tester:end", { ...eventBase, stage: "tester" }, {
+      status: testerOutput.ok ? "ok" : "fail",
+      message: testerOutput.ok ? "Tester passed" : `Tester: ${testerOutput.summary}`
+    })
+  );
+
+  if (!testerOutput.ok) {
+    const maxTesterRetries = config.session?.max_tester_retries ?? 1;
+    session.tester_retry_count = (session.tester_retry_count || 0) + 1;
+    await saveSession(session);
+
+    if (session.tester_retry_count >= maxTesterRetries) {
+      const solomonResult = await invokeSolomon({
+        config, logger, emitter, eventBase, stage: "tester", askQuestion, session, iteration,
+        conflict: {
+          stage: "tester",
+          task,
+          diff,
+          iterationCount: session.tester_retry_count,
+          maxIterations: maxTesterRetries,
+          history: [{ agent: "tester", feedback: testerOutput.summary }]
+        }
+      });
+
+      if (solomonResult.action === "pause") {
+        return { action: "pause", result: { paused: true, sessionId: session.id, question: solomonResult.question, context: "tester_fail_fast" } };
+      }
+      if (solomonResult.action === "subtask") {
+        return { action: "pause", result: { paused: true, sessionId: session.id, subtask: solomonResult.subtask, context: "tester_subtask" } };
+      }
+      // Solomon approved — proceed to next stage
+      return { action: "ok" };
+    }
+
+    session.last_reviewer_feedback = `Tester feedback: ${testerOutput.summary}`;
+    await saveSession(session);
+    return { action: "continue" };
+  }
+
+  session.tester_retry_count = 0;
+  return { action: "ok", stageResult: { ok: true, summary: testerOutput.summary || "All tests passed" } };
+}
+
+export async function runSecurityStage({ config, logger, emitter, eventBase, session, coderRole, trackBudget, iteration, task, diff, askQuestion }) {
+  logger.setContext({ iteration, stage: "security" });
+  emitProgress(
+    emitter,
+    makeEvent("security:start", { ...eventBase, stage: "security" }, {
+      message: "Security auditing code"
+    })
+  );
+
+  const security = new SecurityRole({ config, logger, emitter });
+  await security.init({ task, iteration });
+  const securityStart = Date.now();
+  const securityOutput = await security.run({ task, diff });
+  trackBudget({
+    role: "security",
+    provider: config?.roles?.security?.provider || coderRole.provider,
+    model: config?.roles?.security?.model || coderRole.model,
+    result: securityOutput,
+    duration_ms: Date.now() - securityStart
+  });
+
+  await addCheckpoint(session, { stage: "security", iteration, ok: securityOutput.ok });
+
+  emitProgress(
+    emitter,
+    makeEvent("security:end", { ...eventBase, stage: "security" }, {
+      status: securityOutput.ok ? "ok" : "fail",
+      message: securityOutput.ok ? "Security audit passed" : `Security: ${securityOutput.summary}`
+    })
+  );
+
+  if (!securityOutput.ok) {
+    const maxSecurityRetries = config.session?.max_security_retries ?? 1;
+    session.security_retry_count = (session.security_retry_count || 0) + 1;
+    await saveSession(session);
+
+    if (session.security_retry_count >= maxSecurityRetries) {
+      const solomonResult = await invokeSolomon({
+        config, logger, emitter, eventBase, stage: "security", askQuestion, session, iteration,
+        conflict: {
+          stage: "security",
+          task,
+          diff,
+          iterationCount: session.security_retry_count,
+          maxIterations: maxSecurityRetries,
+          history: [{ agent: "security", feedback: securityOutput.summary }]
+        }
+      });
+
+      if (solomonResult.action === "pause") {
+        return { action: "pause", result: { paused: true, sessionId: session.id, question: solomonResult.question, context: "security_fail_fast" } };
+      }
+      if (solomonResult.action === "subtask") {
+        return { action: "pause", result: { paused: true, sessionId: session.id, subtask: solomonResult.subtask, context: "security_subtask" } };
+      }
+      // Solomon approved — proceed
+      return { action: "ok" };
+    }
+
+    session.last_reviewer_feedback = `Security feedback: ${securityOutput.summary}`;
+    await saveSession(session);
+    return { action: "continue" };
+  }
+
+  session.security_retry_count = 0;
+  return { action: "ok", stageResult: { ok: true, summary: securityOutput.summary || "No vulnerabilities found" } };
+}

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

@@ -0,0 +1,149 @@
+import { TriageRole } from "../roles/triage-role.js";
+import { ResearcherRole } from "../roles/researcher-role.js";
+import { PlannerRole } from "../roles/planner-role.js";
+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";
+
+export async function runTriageStage({ config, logger, emitter, eventBase, session, coderRole, trackBudget }) {
+  logger.setContext({ iteration: 0, stage: "triage" });
+  emitProgress(
+    emitter,
+    makeEvent("triage:start", { ...eventBase, stage: "triage" }, {
+      message: "Triage classifying task complexity"
+    })
+  );
+
+  const triage = new TriageRole({ config, logger, emitter });
+  await triage.init({ task: session.task, sessionId: session.id, iteration: 0 });
+  const triageStart = Date.now();
+  const triageOutput = await triage.run({ task: session.task });
+  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 });
+
+  const recommendedRoles = new Set(triageOutput.result?.roles || []);
+  const roleOverrides = {};
+  if (triageOutput.ok) {
+    roleOverrides.plannerEnabled = recommendedRoles.has("planner");
+    roleOverrides.researcherEnabled = recommendedRoles.has("researcher");
+    roleOverrides.refactorerEnabled = recommendedRoles.has("refactorer");
+    roleOverrides.reviewerEnabled = recommendedRoles.has("reviewer");
+    roleOverrides.testerEnabled = recommendedRoles.has("tester");
+    roleOverrides.securityEnabled = recommendedRoles.has("security");
+  }
+
+  const stageResult = {
+    ok: triageOutput.ok,
+    level: triageOutput.result?.level || null,
+    roles: Array.from(recommendedRoles),
+    reasoning: triageOutput.result?.reasoning || null
+  };
+
+  emitProgress(
+    emitter,
+    makeEvent("triage:end", { ...eventBase, stage: "triage" }, {
+      status: triageOutput.ok ? "ok" : "fail",
+      message: triageOutput.ok ? "Triage completed" : `Triage failed: ${triageOutput.summary}`,
+      detail: stageResult
+    })
+  );
+
+  return { roleOverrides, stageResult };
+}
+
+export async function runResearcherStage({ config, logger, emitter, eventBase, session, coderRole, trackBudget }) {
+  logger.setContext({ iteration: 0, stage: "researcher" });
+  emitProgress(
+    emitter,
+    makeEvent("researcher:start", { ...eventBase, stage: "researcher" }, {
+      message: "Researcher investigating codebase"
+    })
+  );
+
+  const researcher = new ResearcherRole({ config, logger, emitter });
+  await researcher.init({ task: session.task });
+  const researchStart = Date.now();
+  const researchOutput = await researcher.run({ task: session.task });
+  trackBudget({
+    role: "researcher",
+    provider: config?.roles?.researcher?.provider || coderRole.provider,
+    model: config?.roles?.researcher?.model || coderRole.model,
+    result: researchOutput,
+    duration_ms: Date.now() - researchStart
+  });
+
+  await addCheckpoint(session, { stage: "researcher", iteration: 0, ok: researchOutput.ok });
+
+  emitProgress(
+    emitter,
+    makeEvent("researcher:end", { ...eventBase, stage: "researcher" }, {
+      status: researchOutput.ok ? "ok" : "fail",
+      message: researchOutput.ok ? "Research completed" : `Research failed: ${researchOutput.summary}`
+    })
+  );
+
+  const stageResult = { ok: researchOutput.ok, summary: researchOutput.summary || null };
+  const researchContext = researchOutput.ok ? researchOutput.result : null;
+
+  return { researchContext, stageResult };
+}
+
+export async function runPlannerStage({ config, logger, emitter, eventBase, session, plannerRole, researchContext, trackBudget }) {
+  const task = session.task;
+  logger.setContext({ iteration: 0, stage: "planner" });
+  emitProgress(
+    emitter,
+    makeEvent("planner:start", { ...eventBase, stage: "planner" }, {
+      message: `Planner (${plannerRole.provider}) running`,
+      detail: { planner: plannerRole.provider }
+    })
+  );
+
+  const planRole = new PlannerRole({ config, logger, emitter, createAgentFn: createAgent });
+  planRole.context = { task, research: researchContext };
+  await planRole.init();
+  const plannerStart = Date.now();
+  const planResult = await planRole.execute(task);
+  trackBudget({ role: "planner", provider: plannerRole.provider, model: plannerRole.model, result: planResult.result, duration_ms: Date.now() - plannerStart });
+
+  if (!planResult.ok) {
+    await markSessionStatus(session, "failed");
+    const details = planResult.result?.error || planResult.summary || "unknown error";
+    emitProgress(
+      emitter,
+      makeEvent("planner:end", { ...eventBase, stage: "planner" }, {
+        status: "fail",
+        message: `Planner failed: ${details}`
+      })
+    );
+    throw new Error(`Planner failed: ${details}`);
+  }
+
+  const planOutput = planResult.result?.plan || "";
+  const plannedTask = planOutput ? `${task}\n\nExecution plan:\n${planOutput}` : task;
+  const parsedPlan = parsePlannerOutput(planOutput);
+  const stageResult = {
+    ok: true,
+    title: parsedPlan?.title || null,
+    approach: parsedPlan?.approach || null,
+    steps: parsedPlan?.steps || [],
+    completedSteps: []
+  };
+
+  emitProgress(
+    emitter,
+    makeEvent("planner:end", { ...eventBase, stage: "planner" }, {
+      message: "Planner completed"
+    })
+  );
+
+  return { plannedTask, stageResult };
+}

package/src/orchestrator/reviewer-fallback.js

@@ -0,0 +1,39 @@
+import { ReviewerRole } from "../roles/reviewer-role.js";
+import { createAgent } from "../agents/index.js";
+import { addCheckpoint } from "../session-store.js";
+
+export async function runReviewerWithFallback({ reviewerName, config, logger, emitter, reviewInput, session, iteration, onAttemptResult }) {
+  const fallbackReviewer = config.reviewer_options?.fallback_reviewer;
+  const retries = Math.max(0, Number(config.reviewer_options?.retries ?? 1));
+  const candidates = [reviewerName];
+  if (fallbackReviewer && fallbackReviewer !== reviewerName) {
+    candidates.push(fallbackReviewer);
+  }
+
+  const attempts = [];
+  for (const name of candidates) {
+    const reviewerConfig = { ...config, roles: { ...config.roles, reviewer: { ...config.roles?.reviewer, provider: name } } };
+    const role = new ReviewerRole({ config: reviewerConfig, logger, emitter, createAgentFn: createAgent });
+    await role.init();
+    for (let attempt = 1; attempt <= retries + 1; attempt += 1) {
+      const execResult = await role.execute(reviewInput);
+      if (onAttemptResult) {
+        await onAttemptResult({ reviewer: name, result: execResult.result });
+      }
+      attempts.push({ reviewer: name, attempt, ok: execResult.ok, result: execResult.result, execResult });
+      await addCheckpoint(session, {
+        stage: "reviewer-attempt",
+        iteration,
+        reviewer: name,
+        attempt,
+        ok: execResult.ok
+      });
+
+      if (execResult.ok) {
+        return { execResult, attempts };
+      }
+    }
+  }
+
+  return { execResult: null, attempts };
+}

package/src/orchestrator/solomon-escalation.js

@@ -0,0 +1,84 @@
+import { SolomonRole } from "../roles/solomon-role.js";
+import { addCheckpoint, pauseSession } from "../session-store.js";
+import { emitProgress, makeEvent } from "../utils/events.js";
+
+export async function invokeSolomon({ config, logger, emitter, eventBase, stage, conflict, askQuestion, session, iteration }) {
+  const solomonEnabled = Boolean(config.pipeline?.solomon?.enabled);
+
+  if (!solomonEnabled) {
+    return escalateToHuman({ askQuestion, session, emitter, eventBase, stage, conflict, iteration });
+  }
+
+  emitProgress(
+    emitter,
+    makeEvent("solomon:start", { ...eventBase, stage: "solomon" }, {
+      message: `Solomon arbitrating ${stage} conflict`,
+      detail: { conflictStage: stage }
+    })
+  );
+
+  const solomon = new SolomonRole({ config, logger, emitter });
+  await solomon.init({ task: conflict.task || session.task, iteration });
+  const ruling = await solomon.run({ conflict });
+
+  emitProgress(
+    emitter,
+    makeEvent("solomon:end", { ...eventBase, stage: "solomon" }, {
+      message: `Solomon ruling: ${ruling.result?.ruling || "unknown"}`,
+      detail: ruling.result
+    })
+  );
+
+  await addCheckpoint(session, {
+    stage: "solomon",
+    iteration,
+    ruling: ruling.result?.ruling,
+    escalate: ruling.result?.escalate,
+    subtask: ruling.result?.subtask?.title || null
+  });
+
+  if (!ruling.ok) {
+    return escalateToHuman({
+      askQuestion, session, emitter, eventBase, stage, iteration,
+      conflict: { ...conflict, solomonReason: ruling.result?.escalate_reason }
+    });
+  }
+
+  const r = ruling.result?.ruling;
+  if (r === "approve" || r === "approve_with_conditions") {
+    return { action: "continue", conditions: ruling.result?.conditions || [], ruling };
+  }
+
+  if (r === "create_subtask") {
+    return { action: "subtask", subtask: ruling.result?.subtask, ruling };
+  }
+
+  return { action: "continue", conditions: [], ruling };
+}
+
+export async function escalateToHuman({ askQuestion, session, emitter, eventBase, stage, conflict, iteration }) {
+  const reason = conflict?.solomonReason || `${stage} conflict unresolved`;
+  const question = `${stage} conflict requires human intervention: ${reason}\nDetails: ${JSON.stringify(conflict?.history?.slice(-2) || [], null, 2)}\n\nHow should we proceed?`;
+
+  if (askQuestion) {
+    const answer = await askQuestion(question, { iteration, stage });
+    if (answer) {
+      return { action: "continue", humanGuidance: answer };
+    }
+  }
+
+  await pauseSession(session, {
+    question,
+    context: { iteration, stage, conflict }
+  });
+  emitProgress(
+    emitter,
+    makeEvent("question", { ...eventBase, stage }, {
+      status: "paused",
+      message: question,
+      detail: { question, sessionId: session.id }
+    })
+  );
+
+  return { action: "pause", question };
+}