karajan-code 1.13.1 → 1.14.0

package/bin/karajan-mcp.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../src/mcp/server.js";

package/bin/kj.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../src/cli.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "karajan-code",
-  "version": "1.13.1",
+  "version": "1.14.0",
   "description": "Local multi-agent coding orchestrator with TDD, SonarQube, and code review pipeline",
   "type": "module",
   "license": "AGPL-3.0",
@@ -37,8 +37,8 @@
     "README.md"
   ],
   "bin": {
-    "kj": "./src/cli.js",
-    "karajan-mcp": "./src/mcp/server.js"
+    "kj": "bin/kj.js",
+    "karajan-mcp": "bin/karajan-mcp.js"
   },
   "scripts": {
     "postinstall": "node scripts/postinstall.js",

package/src/config.js

@@ -97,6 +97,7 @@ const DEFAULTS = {
       disabled_rules: ["javascript:S1116", "javascript:S3776"]
     }
   },
+  policies: {},
   serena: { enabled: false },
   planning_game: { enabled: false, project_id: null, codeveloper: null },
   becaria: { enabled: false, review_event: "becaria-review", comment_event: "becaria-comment", comment_prefix: true },
@@ -285,6 +286,7 @@ export function applyRunOverrides(config, flags) {
     out.development.methodology = methodology;
     out.development.require_test_changes = methodology === "tdd";
   }
+  if (flags.taskType) out.taskType = String(flags.taskType);
   if (flags.noSonar || flags.sonar === false) out.sonarqube.enabled = false;
   out.serena = out.serena || { enabled: false };
   if (flags.enableSerena !== undefined) out.serena.enabled = Boolean(flags.enableSerena);

package/src/guards/policy-resolver.js

@@ -0,0 +1,37 @@
+export const VALID_TASK_TYPES = ["sw", "infra", "doc", "add-tests", "refactor"];
+
+export const DEFAULT_POLICIES = {
+  sw:        { tdd: true,  sonar: true,  reviewer: true, testsRequired: true  },
+  infra:     { tdd: false, sonar: false, reviewer: true, testsRequired: false },
+  doc:       { tdd: false, sonar: false, reviewer: true, testsRequired: false },
+  "add-tests": { tdd: false, sonar: true,  reviewer: true, testsRequired: true  },
+  refactor:  { tdd: true,  sonar: true,  reviewer: true, testsRequired: false },
+};
+
+const FALLBACK_TYPE = "sw";
+
+/**
+ * Resolve pipeline policies for a given taskType.
+ * Unknown / null / undefined taskType falls back to "sw" (conservative).
+ * configOverrides optionally merges over defaults per taskType.
+ */
+export function resolvePolicies(taskType, configOverrides) {
+  const resolvedType = VALID_TASK_TYPES.includes(taskType) ? taskType : FALLBACK_TYPE;
+  const base = { ...DEFAULT_POLICIES[resolvedType] };
+  const overrides = configOverrides?.[resolvedType];
+  if (overrides && typeof overrides === "object") {
+    Object.assign(base, overrides);
+  }
+  return base;
+}
+
+/**
+ * Resolve policies for a taskType and return a flat object with the resolved
+ * taskType plus all policy flags. This is the main entry point for the
+ * orchestrator to determine which pipeline stages to enable/disable.
+ */
+export function applyPolicies({ taskType, policies } = {}) {
+  const resolvedType = VALID_TASK_TYPES.includes(taskType) ? taskType : FALLBACK_TYPE;
+  const resolved = resolvePolicies(taskType, policies);
+  return { taskType: resolvedType, ...resolved };
+}

package/src/orchestrator/iteration-stages.js

@@ -3,7 +3,7 @@ import { CoderRole } from "../roles/coder-role.js";
 import { RefactorerRole } from "../roles/refactorer-role.js";
 import { SonarRole } from "../roles/sonar-role.js";
 import { addCheckpoint, markSessionStatus, saveSession, pauseSession } from "../session-store.js";
-import { generateDiff } from "../review/diff-generator.js";
+import { generateDiff, getUntrackedFiles } from "../review/diff-generator.js";
 import { evaluateTddPolicy } from "../review/tdd-policy.js";
 import { validateReviewResult } from "../review/schema.js";
 import { filterReviewScope, buildDeferredContext } from "../review/scope-filter.js";
@@ -198,7 +198,8 @@ export async function runRefactorerStage({ refactorerRole, config, logger, emitt
 export async function runTddCheckStage({ config, logger, emitter, eventBase, session, trackBudget, iteration, askQuestion }) {
   logger.setContext({ iteration, stage: "tdd" });
   const tddDiff = await generateDiff({ baseRef: session.session_start_sha });
-  const tddEval = evaluateTddPolicy(tddDiff, config.development);
+  const untrackedFiles = await getUntrackedFiles();
+  const tddEval = evaluateTddPolicy(tddDiff, config.development, untrackedFiles);
   await addCheckpoint(session, {
     stage: "tdd-policy",
     iteration,
@@ -227,34 +228,42 @@ export async function runTddCheckStage({ config, logger, emitter, eventBase, ses
     session.repeated_issue_count += 1;
     await saveSession(session);
     if (session.repeated_issue_count >= config.session.fail_fast_repeats) {
-      const question = `TDD policy has failed ${session.repeated_issue_count} times. The coder is not creating tests. How should we proceed? Issue: ${tddEval.reason}`;
-      if (askQuestion) {
-        const answer = await askQuestion(question, { iteration, stage: "tdd" });
-        if (answer) {
-          session.last_reviewer_feedback += `\nUser guidance: ${answer}`;
-          session.repeated_issue_count = 0;
-          await saveSession(session);
-          return { action: "continue" };
-        }
-      }
-      await pauseSession(session, {
-        question,
-        context: {
-          iteration,
-          stage: "tdd",
-          lastFeedback: tddEval.message,
-          repeatedCount: session.repeated_issue_count
-        }
-      });
       emitProgress(
         emitter,
-        makeEvent("question", { ...eventBase, stage: "tdd" }, {
-          status: "paused",
-          message: question,
-          detail: { question, sessionId: session.id }
+        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 }
         })
       );
-      return { action: "pause", result: { paused: true, sessionId: session.id, question, context: "tdd_fail_fast" } };
+
+      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 }]
+        }
+      });
+
+      if (solomonResult.action === "pause") {
+        return { action: "pause", result: { paused: true, sessionId: session.id, question: solomonResult.question, context: "tdd_fail_fast" } };
+      }
+      if (solomonResult.action === "continue") {
+        if (solomonResult.humanGuidance) {
+          session.last_reviewer_feedback += `\nUser guidance: ${solomonResult.humanGuidance}`;
+        }
+        session.repeated_issue_count = 0;
+        await saveSession(session);
+        return { action: "continue" };
+      }
+      if (solomonResult.action === "subtask") {
+        return { action: "pause", result: { paused: true, sessionId: session.id, subtask: solomonResult.subtask, context: "tdd_subtask" } };
+      }
     }
     return { action: "continue" };
   }

package/src/orchestrator.js

@@ -22,6 +22,7 @@ import {
   incrementalPush
 } from "./git/automation.js";
 import { resolveRoleMdPath, loadFirstExisting } from "./roles/base-role.js";
+import { applyPolicies } from "./guards/policy-resolver.js";
 import { resolveReviewProfile } from "./review/profiles.js";
 import { CoderRole } from "./roles/coder-role.js";
 import { invokeSolomon } from "./orchestrator/solomon-escalation.js";
@@ -47,6 +48,10 @@ export async function runFlow({ task, config, logger, flags = {}, emitter = null
 
   // --- Dry-run: return summary without executing anything ---
   if (flags.dryRun) {
+    const dryRunPolicies = applyPolicies({
+      taskType: flags.taskType || config.taskType || null,
+      policies: config.policies,
+    });
     const projectDir = config.projectDir || process.cwd();
     const { rules: reviewRules } = await resolveReviewProfile({ mode: config.review_mode, projectDir });
     const coderRules = await loadFirstExisting(resolveRoleMdPath("coder", projectDir));
@@ -56,6 +61,7 @@ export async function runFlow({ task, config, logger, flags = {}, emitter = null
     const summary = {
       dry_run: true,
       task,
+      policies: dryRunPolicies,
       roles: {
         planner: plannerRole,
         coder: coderRole,
@@ -275,6 +281,32 @@ export async function runFlow({ task, config, logger, flags = {}, emitter = null
   if (flags.enableTester !== undefined) testerEnabled = Boolean(flags.enableTester);
   if (flags.enableSecurity !== undefined) securityEnabled = Boolean(flags.enableSecurity);
 
+  // --- Policy resolver: gate stages by taskType ---
+  const resolvedPolicies = applyPolicies({
+    taskType: flags.taskType || config.taskType || null,
+    policies: config.policies,
+  });
+  session.resolved_policies = resolvedPolicies;
+
+  // Apply policy gates on shallow copies (never mutate the caller's config)
+  if (!resolvedPolicies.tdd) {
+    config = { ...config, development: { ...config.development, methodology: "standard", require_test_changes: false } };
+  }
+  if (!resolvedPolicies.sonar) {
+    config = { ...config, sonarqube: { ...config.sonarqube, enabled: false } };
+  }
+  if (!resolvedPolicies.reviewer) {
+    reviewerEnabled = false;
+  }
+
+  emitProgress(
+    emitter,
+    makeEvent("policies:resolved", eventBase, {
+      message: `Policies resolved for taskType="${resolvedPolicies.taskType}"`,
+      detail: resolvedPolicies
+    })
+  );
+
   // --- Researcher (pre-planning) ---
   let researchContext = null;
   if (researcherEnabled) {

package/src/review/diff-generator.js

@@ -20,3 +20,9 @@ export async function generateDiff({ baseRef }) {
   }
   return result.stdout;
 }
+
+export async function getUntrackedFiles() {
+  const result = await runCommand("git", ["ls-files", "--others", "--exclude-standard"]);
+  if (result.exitCode !== 0) return [];
+  return result.stdout.trim().split("\n").filter(Boolean);
+}

package/src/review/tdd-policy.js

@@ -19,13 +19,15 @@ function isSourceFile(file, extensions = []) {
   return extensions.some((ext) => file.endsWith(ext));
 }
 
-export function evaluateTddPolicy(diff, developmentConfig = {}) {
+export function evaluateTddPolicy(diff, developmentConfig = {}, untrackedFiles = []) {
   const requireTestChanges = developmentConfig.require_test_changes !== false;
   const patterns = developmentConfig.test_file_patterns || ["/tests/", "/__tests__/", ".test.", ".spec."];
   const extensions =
     developmentConfig.source_file_extensions || [".js", ".jsx", ".ts", ".tsx", ".py", ".go", ".java", ".rb", ".php", ".cs"];
 
-  const files = extractChangedFiles(diff);
+  const diffFiles = extractChangedFiles(diff);
+  const extra = Array.isArray(untrackedFiles) ? untrackedFiles : [];
+  const files = [...new Set([...diffFiles, ...extra])];
   const sourceFiles = files.filter((f) => isSourceFile(f, extensions) && !isTestFile(f, patterns));
   const testFiles = files.filter((f) => isTestFile(f, patterns));