karajan-code 1.49.0 → 1.50.0

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

@@ -0,0 +1,176 @@
+/**
+ * Architect stage logic.
+ * Extracted from pre-loop-stages.js for maintainability.
+ */
+
+import { ArchitectRole } from "../../roles/architect-role.js";
+import { createAgent } from "../../agents/index.js";
+import { createArchitectADRs } from "../../planning-game/architect-adrs.js";
+import { addCheckpoint } from "../../session-store.js";
+import { emitProgress, makeEvent } from "../../utils/events.js";
+import { createStallDetector } from "../../utils/stall-detector.js";
+
+async function handleArchitectClarification({ architectOutput, askQuestion, config, logger, emitter, eventBase, session, architectOnOutput, architectProvider, coderRole, researchContext, discoverResult, triageLevel, trackBudget }) {
+  if (!architectOutput.ok
+    || architectOutput.result?.verdict !== "needs_clarification"
+    || !architectOutput.result?.questions?.length) {
+    return architectOutput;
+  }
+
+  const questions = architectOutput.result.questions;
+  if (!askQuestion) {
+    logger.warn("Architect returned needs_clarification but no interactive input available — continuing with best-effort decisions");
+    return architectOutput;
+  }
+
+  const formatted = "The architect needs clarification before proceeding:\n\n"
+    + questions.map((q, i) => `${i + 1}. ${q}`).join("\n")
+    + "\n\nPlease provide your answers:";
+
+  emitProgress(
+    emitter,
+    makeEvent("architect:clarification", { ...eventBase, stage: "architect" }, {
+      message: "Architect needs clarification — pausing for human input",
+      detail: { questions }
+    })
+  );
+
+  const answer = await askQuestion(formatted, { iteration: 0, stage: "architect" });
+  if (!answer) return architectOutput;
+
+  const architect2 = new ArchitectRole({ config, logger, emitter, createAgentFn: createAgent });
+  await architect2.init({ task: session.task, sessionId: session.id, iteration: 0 });
+  const rerunStart = Date.now();
+  const rerunStall = createStallDetector({
+    onOutput: architectOnOutput, emitter, eventBase, stage: "architect", provider: architectProvider
+  });
+  let result;
+  try {
+    result = await architect2.execute({
+      task: session.task,
+      onOutput: rerunStall.onOutput,
+      researchContext,
+      discoverResult,
+      triageLevel,
+      humanAnswers: answer
+    });
+  } finally {
+    rerunStall.stop();
+  }
+  trackBudget({
+    role: "architect",
+    provider: architectProvider,
+    model: config?.roles?.architect?.model || coderRole.model,
+    result,
+    duration_ms: Date.now() - rerunStart
+  });
+  return result;
+}
+
+export async function runArchitectStage({ config, logger, emitter, eventBase, session, coderRole, trackBudget, researchContext = null, discoverResult = null, triageLevel = null, askQuestion = null }) {
+  logger.setContext({ iteration: 0, stage: "architect" });
+  const architectProvider = config?.roles?.architect?.provider || coderRole.provider;
+  emitProgress(
+    emitter,
+    makeEvent("architect:start", { ...eventBase, stage: "architect" }, {
+      message: "Architect designing solution architecture",
+      detail: { architect: architectProvider, provider: architectProvider, executorType: "agent" }
+    })
+  );
+  const architectOnOutput = ({ stream, line }) => {
+    emitProgress(emitter, makeEvent("agent:output", { ...eventBase, stage: "architect" }, {
+      message: line,
+      detail: { stream, agent: architectProvider }
+    }));
+  };
+  const architectStall = createStallDetector({
+    onOutput: architectOnOutput, emitter, eventBase, stage: "architect", provider: architectProvider
+  });
+
+  const architect = new ArchitectRole({ config, logger, emitter, createAgentFn: createAgent });
+  await architect.init({ task: session.task, sessionId: session.id, iteration: 0 });
+  const architectStart = Date.now();
+  let architectOutput;
+  try {
+    architectOutput = await architect.execute({
+      task: session.task,
+      onOutput: architectStall.onOutput,
+      researchContext,
+      discoverResult,
+      triageLevel
+    });
+  } catch (err) {
+    logger.warn(`Architect threw: ${err.message}`);
+    architectOutput = { ok: false, summary: `Architect error: ${err.message}`, result: { error: err.message } };
+  } finally {
+    architectStall.stop();
+  }
+  trackBudget({
+    role: "architect",
+    provider: architectProvider,
+    model: config?.roles?.architect?.model || coderRole.model,
+    result: architectOutput,
+    duration_ms: Date.now() - architectStart
+  });
+
+  await addCheckpoint(session, {
+    stage: "architect",
+    iteration: 0,
+    ok: architectOutput.ok,
+    provider: architectProvider,
+    model: config?.roles?.architect?.model || coderRole.model || null
+  });
+
+  // --- Interactive clarification loop ---
+  architectOutput = await handleArchitectClarification({
+    architectOutput, askQuestion, config, logger, emitter, eventBase, session,
+    architectOnOutput, architectProvider, coderRole, researchContext, discoverResult, triageLevel, trackBudget
+  });
+
+  const stageResult = {
+    ok: architectOutput.ok,
+    verdict: architectOutput.result?.verdict || null,
+    architecture: architectOutput.result?.architecture || null,
+    questions: architectOutput.result?.questions || []
+  };
+
+  emitProgress(
+    emitter,
+    makeEvent("architect:end", { ...eventBase, stage: "architect" }, {
+      status: architectOutput.ok ? "ok" : "fail",
+      message: architectOutput.ok ? "Architecture completed" : `Architecture failed: ${architectOutput.summary}`,
+      detail: { ...stageResult, provider: architectProvider, executorType: "agent" }
+    })
+  );
+
+  const architectContext = architectOutput.ok ? architectOutput.result : null;
+
+  // TODO: Move ADR creation to planning-game/pipeline-adapter.js (PG coupling still here because
+  // stageResult.adrs is consumed synchronously within runArchitectStage's return value).
+  // Generate ADRs from architect tradeoffs when PG is linked
+  const tradeoffs = architectOutput.result?.architecture?.tradeoffs;
+  if (architectOutput.ok
+    && architectOutput.result?.verdict === "ready"
+    && tradeoffs?.length > 0
+    && session.pg_task_id
+    && session.pg_project_id) {
+    try {
+      const pgClient = await import("../../planning-game/client.js");
+      const adrResult = await createArchitectADRs({
+        tradeoffs,
+        pgTaskId: session.pg_task_id,
+        pgProject: session.pg_project_id,
+        taskTitle: session.task,
+        mcpClient: pgClient
+      });
+      stageResult.adrs = adrResult;
+      if (adrResult.created > 0) {
+        logger.info(`Architect: created ${adrResult.created} ADR(s) in Planning Game`);
+      }
+    } catch (err) {
+      logger.warn(`Architect: failed to create ADRs: ${err.message}`);
+    }
+  }
+
+  return { architectContext, stageResult };
+}

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

@@ -0,0 +1,307 @@
+/**
+ * Coder stage logic.
+ * Extracted from iteration-stages.js for maintainability.
+ */
+
+import { createAgent } from "../../agents/index.js";
+import { CoderRole } from "../../roles/coder-role.js";
+import { RefactorerRole } from "../../roles/refactorer-role.js";
+import { addCheckpoint, markSessionStatus, saveSession } from "../../session-store.js";
+import { generateDiff, getUntrackedFiles } from "../../review/diff-generator.js";
+import { evaluateTddPolicy } from "../../review/tdd-policy.js";
+import { buildDeferredContext } from "../../review/scope-filter.js";
+import { emitProgress, makeEvent } from "../../utils/events.js";
+import { runCoderWithFallback } from "../agent-fallback.js";
+import { invokeSolomon } from "../solomon-escalation.js";
+import { detectRateLimit } from "../../utils/rate-limit-detector.js";
+import { createStallDetector } from "../../utils/stall-detector.js";
+
+export async function runCoderStage({ coderRoleInstance, coderRole, config, logger, emitter, eventBase, session, plannedTask, trackBudget, iteration }) {
+  logger.setContext({ iteration, stage: "coder" });
+  emitProgress(
+    emitter,
+    makeEvent("coder:start", { ...eventBase, stage: "coder" }, {
+      message: `Coder (${coderRole.provider}) running`,
+      detail: { coder: coderRole.provider, provider: coderRole.provider, executorType: "agent" }
+    })
+  );
+
+  const coderOnOutput = ({ stream, line }) => {
+    emitProgress(emitter, makeEvent("agent:output", { ...eventBase, stage: "coder" }, {
+      message: line,
+      detail: { stream, agent: coderRole.provider }
+    }));
+  };
+  const coderStall = createStallDetector({
+    onOutput: coderOnOutput, emitter, eventBase, stage: "coder", provider: coderRole.provider
+  });
+  const coderStart = Date.now();
+  let coderExecResult;
+  try {
+    coderExecResult = await coderRoleInstance.execute({
+      task: plannedTask,
+      reviewerFeedback: session.last_reviewer_feedback,
+      sonarSummary: session.last_sonar_summary,
+      deferredContext: buildDeferredContext(session.deferred_issues),
+      onOutput: coderStall.onOutput
+    });
+  } finally {
+    coderStall.stop();
+  }
+  trackBudget({ role: "coder", provider: coderRole.provider, model: coderRole.model, result: coderExecResult.result, duration_ms: Date.now() - coderStart });
+
+  if (!coderExecResult.ok) {
+    const details = coderExecResult.result?.error || coderExecResult.summary || "unknown error";
+    const rateLimitCheck = detectRateLimit({
+      stderr: coderExecResult.result?.error || "",
+      stdout: coderExecResult.result?.output || ""
+    });
+
+    if (rateLimitCheck.isRateLimit) {
+      // Try fallback agent if configured
+      const fallbackCoder = config.coder_options?.fallback_coder;
+      if (fallbackCoder && fallbackCoder !== coderRole.provider) {
+        logger.warn(`Coder ${coderRole.provider} hit rate limit, falling back to ${fallbackCoder}`);
+        emitProgress(
+          emitter,
+          makeEvent("coder:fallback", { ...eventBase, stage: "coder" }, {
+            message: `Coder ${coderRole.provider} rate-limited, switching to ${fallbackCoder}`,
+            detail: { primary: coderRole.provider, fallback: fallbackCoder }
+          })
+        );
+
+        const fallbackResult = await runCoderWithFallback({
+          coderName: fallbackCoder,
+          fallbackCoder: null,
+          config,
+          logger,
+          emitter,
+          RoleClass: CoderRole,
+          roleInput: { task: plannedTask, reviewerFeedback: session.last_reviewer_feedback, sonarSummary: session.last_sonar_summary, onOutput: coderOnOutput },
+          session,
+          iteration,
+          onAttemptResult: ({ coder, result }) => {
+            trackBudget({ role: "coder", provider: coder, model: coderRole.model, result, duration_ms: Date.now() - coderStart });
+          }
+        });
+
+        if (fallbackResult.execResult?.ok) {
+          await addCheckpoint(session, { stage: "coder", iteration, note: `Coder completed via fallback (${fallbackCoder})`, provider: fallbackCoder, model: null });
+          emitProgress(
+            emitter,
+            makeEvent("coder:end", { ...eventBase, stage: "coder" }, {
+              message: `Coder completed (fallback: ${fallbackCoder})`,
+              detail: { provider: fallbackCoder, executorType: "agent" }
+            })
+          );
+          return;
+        }
+      }
+
+      // No fallback or fallback also failed — enter standby
+      return {
+        action: "standby",
+        standbyInfo: {
+          agent: coderRole.provider,
+          cooldownMs: rateLimitCheck.cooldownMs || (rateLimitCheck.isProviderOutage ? 30000 : null),
+          cooldownUntil: rateLimitCheck.cooldownUntil,
+          message: rateLimitCheck.message,
+          isProviderOutage: rateLimitCheck.isProviderOutage || false
+        }
+      };
+    }
+
+    await markSessionStatus(session, "failed");
+    emitProgress(
+      emitter,
+      makeEvent("coder:end", { ...eventBase, stage: "coder" }, {
+        status: "fail",
+        message: `Coder failed: ${details}`,
+        detail: { provider: coderRole.provider, executorType: "agent" }
+      })
+    );
+    throw new Error(`Coder failed: ${details}`);
+  }
+
+  await addCheckpoint(session, { stage: "coder", iteration, note: "Coder applied changes", provider: coderRole.provider, model: coderRole.model || null });
+  emitProgress(
+    emitter,
+    makeEvent("coder:end", { ...eventBase, stage: "coder" }, {
+      message: "Coder completed",
+      detail: { provider: coderRole.provider, executorType: "agent" }
+    })
+  );
+}
+
+export async function runRefactorerStage({ refactorerRole, config, logger, emitter, eventBase, session, plannedTask, trackBudget, iteration }) {
+  logger.setContext({ iteration, stage: "refactorer" });
+  emitProgress(
+    emitter,
+    makeEvent("refactorer:start", { ...eventBase, stage: "refactorer" }, {
+      message: `Refactorer (${refactorerRole.provider}) running`,
+      detail: { refactorer: refactorerRole.provider, provider: refactorerRole.provider, executorType: "agent" }
+    })
+  );
+  const refactorerOnOutput = ({ stream, line }) => {
+    emitProgress(emitter, makeEvent("agent:output", { ...eventBase, stage: "refactorer" }, {
+      message: line,
+      detail: { stream, agent: refactorerRole.provider }
+    }));
+  };
+  const refactorerStall = createStallDetector({
+    onOutput: refactorerOnOutput, emitter, eventBase, stage: "refactorer", provider: refactorerRole.provider
+  });
+
+  const refRole = new RefactorerRole({ config, logger, emitter, createAgentFn: createAgent });
+  await refRole.init();
+  const refactorerStart = Date.now();
+  let refResult;
+  try {
+    refResult = await refRole.execute({ task: plannedTask, onOutput: refactorerStall.onOutput });
+  } finally {
+    refactorerStall.stop();
+  }
+  trackBudget({ role: "refactorer", provider: refactorerRole.provider, model: refactorerRole.model, result: refResult.result, duration_ms: Date.now() - refactorerStart });
+  if (!refResult.ok) {
+    const details = refResult.result?.error || refResult.summary || "unknown error";
+    const rateLimitCheck = detectRateLimit({
+      stderr: refResult.result?.error || "",
+      stdout: refResult.result?.output || ""
+    });
+
+    if (rateLimitCheck.isRateLimit) {
+      // Enter standby instead of pausing
+      return {
+        action: "standby",
+        standbyInfo: {
+          agent: refactorerRole.provider,
+          cooldownMs: rateLimitCheck.cooldownMs || (rateLimitCheck.isProviderOutage ? 30000 : null),
+          cooldownUntil: rateLimitCheck.cooldownUntil,
+          message: rateLimitCheck.message,
+          isProviderOutage: rateLimitCheck.isProviderOutage || false
+        }
+      };
+    }
+
+    await markSessionStatus(session, "failed");
+    emitProgress(
+      emitter,
+      makeEvent("refactorer:end", { ...eventBase, stage: "refactorer" }, {
+        status: "fail",
+        message: `Refactorer failed: ${details}`,
+        detail: { provider: refactorerRole.provider, executorType: "agent" }
+      })
+    );
+    throw new Error(`Refactorer failed: ${details}`);
+  }
+  await addCheckpoint(session, { stage: "refactorer", iteration, note: "Refactorer applied cleanups", provider: refactorerRole.provider, model: refactorerRole.model || null });
+  emitProgress(
+    emitter,
+    makeEvent("refactorer:end", { ...eventBase, stage: "refactorer" }, {
+      message: "Refactorer completed",
+      detail: { provider: refactorerRole.provider, executorType: "agent" }
+    })
+  );
+}
+
+function handleSolomonAction(solomonResult, session, contextPrefix) {
+  if (solomonResult.action === "pause") {
+    return { action: "pause", result: { paused: true, sessionId: session.id, question: solomonResult.question, context: `${contextPrefix}_fail_fast` } };
+  }
+  if (solomonResult.action === "subtask") {
+    return { action: "pause", result: { paused: true, sessionId: session.id, subtask: solomonResult.subtask, context: `${contextPrefix}_subtask` } };
+  }
+  return null;
+}
+
+async function handleSolomonContinue(solomonResult, session, counterField) {
+  if (solomonResult.action !== "continue") return false;
+  if (solomonResult.humanGuidance) {
+    session.last_reviewer_feedback += `\nUser guidance: ${solomonResult.humanGuidance}`;
+  }
+  session[counterField] = 0;
+  await saveSession(session);
+  return true;
+}
+
+async function handleTddFailure({ tddEval, config, logger, emitter, eventBase, session, iteration, askQuestion }) {
+  session.last_reviewer_feedback = tddEval.message;
+  session.repeated_issue_count += 1;
+  await saveSession(session);
+
+  if (session.repeated_issue_count < config.session.fail_fast_repeats) {
+    return { action: "continue" };
+  }
+
+  emitProgress(
+    emitter,
+    makeEvent("solomon:escalate", { ...eventBase, stage: "tdd" }, {
+      message: `TDD sub-loop limit reached (${session.repeated_issue_count}/${config.session.fail_fast_repeats})`,
+      detail: { subloop: "tdd", retryCount: session.repeated_issue_count, reason: tddEval.reason }
+    })
+  );
+
+  const solomonResult = await invokeSolomon({
+    config, logger, emitter, eventBase, stage: "tdd", askQuestion, session, iteration,
+    conflict: {
+      stage: "tdd",
+      task: session.task,
+      iterationCount: session.repeated_issue_count,
+      maxIterations: config.session.fail_fast_repeats,
+      reason: tddEval.reason,
+      sourceFiles: tddEval.sourceFiles,
+      testFiles: tddEval.testFiles,
+      history: [{ agent: "tdd-policy", feedback: tddEval.message }]
+    }
+  });
+
+  const actionResult = handleSolomonAction(solomonResult, session, "tdd");
+  if (actionResult) return actionResult;
+  const continued = await handleSolomonContinue(solomonResult, session, "repeated_issue_count");
+  if (continued) return { action: "continue" };
+
+  return { action: "continue" };
+}
+
+export async function runTddCheckStage({ config, logger, emitter, eventBase, session, trackBudget, iteration, askQuestion }) {
+  logger.setContext({ iteration, stage: "tdd" });
+  let tddDiff, untrackedFiles;
+  try {
+    tddDiff = await generateDiff({ baseRef: session.session_start_sha });
+    untrackedFiles = await getUntrackedFiles();
+  } catch (err) {
+    logger.warn(`TDD diff generation failed: ${err.message}`);
+    return { action: "continue", stageResult: { ok: false, summary: `TDD check failed: ${err.message}` } };
+  }
+  const effectiveTaskType = session.resolved_policies?.taskType || null;
+  const tddEval = evaluateTddPolicy(tddDiff, config.development, untrackedFiles, effectiveTaskType);
+  await addCheckpoint(session, {
+    stage: "tdd-policy",
+    iteration,
+    ok: tddEval.ok,
+    reason: tddEval.reason,
+    source_files: tddEval.sourceFiles?.length || 0,
+    test_files: tddEval.testFiles?.length || 0
+  });
+
+  emitProgress(
+    emitter,
+    makeEvent("tdd:result", { ...eventBase, stage: "tdd" }, {
+      status: tddEval.ok ? "ok" : "fail",
+      message: tddEval.ok ? "TDD policy passed" : `TDD policy failed: ${tddEval.reason}`,
+      detail: {
+        ok: tddEval.ok,
+        reason: tddEval.reason,
+        sourceFiles: tddEval.sourceFiles?.length || 0,
+        testFiles: tddEval.testFiles?.length || 0,
+        executorType: "local"
+      }
+    })
+  );
+
+  if (!tddEval.ok) {
+    return handleTddFailure({ tddEval, config, logger, emitter, eventBase, session, iteration, askQuestion });
+  }
+
+  return { action: "ok" };
+}