kairn-cli 2.2.3 → 2.2.5

package/dist/cli.js

@@ -221,7 +221,7 @@ var ui = {
   // Key-value pairs
   kv: (key, value) => `  ${chalk.cyan(key.padEnd(14))} ${value}`,
   // File list
-  file: (path24) => chalk.dim(`    ${path24}`),
+  file: (path25) => chalk.dim(`    ${path25}`),
   // Tool display
   tool: (name, reason) => `    ${warmStone("\u25CF")} ${chalk.bold(name)}
       ${chalk.dim(reason)}`,
@@ -3702,8 +3702,8 @@ var keysCommand = new Command10("keys").description("Add or update API keys for
 import { Command as Command11 } from "commander";
 import chalk14 from "chalk";
 import ora2 from "ora";
-import fs23 from "fs/promises";
-import path23 from "path";
+import fs24 from "fs/promises";
+import path24 from "path";
 import { parse as yamlParse2 } from "yaml";
 import { confirm as confirm3, select as select4 } from "@inquirer/prompts";
 
@@ -4569,32 +4569,114 @@ function parseToolCalls(stdout) {
     return [];
   }
 }
-async function evaluateAll(tasks, harnessPath, workspacePath, iteration, config, onProgress) {
+async function runWithConcurrency(tasks, limit) {
+  const results = new Array(tasks.length);
+  const executing = /* @__PURE__ */ new Set();
+  const errors = [];
+  const effectiveLimit = Math.max(1, limit);
+  for (let i = 0; i < tasks.length; i++) {
+    const p = tasks[i]().then(
+      (result) => {
+        results[i] = result;
+      },
+      (err) => {
+        errors.push(err);
+      }
+    );
+    const tracked = p.then(() => {
+      executing.delete(tracked);
+    });
+    executing.add(tracked);
+    if (executing.size >= effectiveLimit) {
+      await Promise.race(executing);
+    }
+  }
+  await Promise.all(executing);
+  if (errors.length > 0) {
+    throw errors[0];
+  }
+  return results;
+}
+function computeStddev(values, mean) {
+  if (values.length <= 1) return 0;
+  const sumSqDiffs = values.reduce((sum, v) => sum + (v - mean) ** 2, 0);
+  return Math.sqrt(sumSqDiffs / values.length);
+}
+async function evaluateAll(tasks, harnessPath, workspacePath, iteration, config, onProgress, runsPerTask = 1, parallelTasks = 1) {
   const results = {};
   const projectRoot = path18.resolve(workspacePath, "..");
-  for (const task of tasks) {
-    const traceDir = path18.join(
-      workspacePath,
-      "traces",
-      iteration.toString(),
-      task.id
-    );
+  const effectiveRuns = Math.max(1, runsPerTask);
+  const concurrency = Math.max(1, parallelTasks);
+  const evaluateTask = async (task) => {
     onProgress?.({ type: "task-start", iteration, taskId: task.id });
-    const taskResult = await runTask(task, harnessPath, traceDir, iteration, projectRoot);
-    let score = taskResult.score;
-    if (config) {
-      const stdout = await fs18.readFile(path18.join(traceDir, "stdout.log"), "utf-8").catch(() => "");
-      const stderr = await fs18.readFile(path18.join(traceDir, "stderr.log"), "utf-8").catch(() => "");
-      score = await scoreTask(task, traceDir, stdout, stderr, config);
-      await writeScore(traceDir, score);
-    }
-    results[task.id] = score;
+    let finalScore;
+    if (effectiveRuns > 1 && config) {
+      const runScores = [];
+      let passCount = 0;
+      for (let run = 0; run < effectiveRuns; run++) {
+        const traceDir = path18.join(
+          workspacePath,
+          "traces",
+          iteration.toString(),
+          `${task.id}_run${run}`
+        );
+        onProgress?.({
+          type: "task-run",
+          iteration,
+          taskId: task.id,
+          message: `Run ${run + 1}/${effectiveRuns} of ${task.id}`
+        });
+        await runTask(task, harnessPath, traceDir, iteration, projectRoot);
+        const stdout = await fs18.readFile(path18.join(traceDir, "stdout.log"), "utf-8").catch(() => "");
+        const stderr = await fs18.readFile(path18.join(traceDir, "stderr.log"), "utf-8").catch(() => "");
+        const score = await scoreTask(task, traceDir, stdout, stderr, config);
+        await writeScore(traceDir, score);
+        runScores.push(score.score ?? (score.pass ? 100 : 0));
+        if (score.pass) passCount++;
+      }
+      const mean = runScores.reduce((a, b) => a + b, 0) / runScores.length;
+      const stddev = computeStddev(runScores, mean);
+      finalScore = {
+        pass: passCount > effectiveRuns / 2,
+        score: mean,
+        details: `Mean of ${effectiveRuns} runs`,
+        variance: {
+          runs: effectiveRuns,
+          scores: runScores,
+          mean,
+          stddev
+        }
+      };
+    } else {
+      const traceDir = path18.join(
+        workspacePath,
+        "traces",
+        iteration.toString(),
+        task.id
+      );
+      const taskResult = await runTask(task, harnessPath, traceDir, iteration, projectRoot);
+      finalScore = taskResult.score;
+      if (config) {
+        const stdout = await fs18.readFile(path18.join(traceDir, "stdout.log"), "utf-8").catch(() => "");
+        const stderr = await fs18.readFile(path18.join(traceDir, "stderr.log"), "utf-8").catch(() => "");
+        finalScore = await scoreTask(task, traceDir, stdout, stderr, config);
+        await writeScore(traceDir, finalScore);
+      }
+    }
     onProgress?.({
       type: "task-scored",
       iteration,
       taskId: task.id,
-      score: score.score ?? (score.pass ? 100 : 0)
+      score: finalScore.score ?? (finalScore.pass ? 100 : 0)
     });
+    return { id: task.id, score: finalScore };
+  };
+  const taskResults = await runWithConcurrency(
+    tasks.map((task) => () => evaluateTask(task)),
+    concurrency
+  );
+  for (const { id, score } of taskResults) {
+    results[id] = score;
   }
   const scores = Object.values(results);
   const total = scores.reduce(
@@ -5052,7 +5134,9 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
       workspacePath,
       iter,
       kairnConfig,
-      onProgress
+      onProgress,
+      evolveConfig.runsPerTask,
+      evolveConfig.parallelTasks
     );
     onProgress?.({ type: "iteration-scored", iteration: iter, score: aggregate });
     if (iter === 0) baselineScore = aggregate;
@@ -5409,24 +5493,128 @@ async function generateJsonReport(workspacePath) {
   };
 }
 
+// src/evolve/apply.ts
+import fs23 from "fs/promises";
+import path23 from "path";
+async function listIterations(workspacePath) {
+  const iterationsDir = path23.join(workspacePath, "iterations");
+  let entries;
+  try {
+    entries = await fs23.readdir(iterationsDir);
+  } catch {
+    return [];
+  }
+  const nums = [];
+  for (const entry of entries) {
+    const n = parseInt(entry, 10);
+    if (!isNaN(n)) {
+      try {
+        await fs23.access(path23.join(iterationsDir, entry, "harness"));
+        nums.push(n);
+      } catch {
+      }
+    }
+  }
+  return nums.sort((a, b) => a - b);
+}
+async function findBestIteration(workspacePath, iterations) {
+  let bestIter = iterations[0];
+  let bestScore = -Infinity;
+  for (const iter of iterations) {
+    const log = await loadIterationLog(workspacePath, iter);
+    const score = log?.score ?? 0;
+    if (score > bestScore) {
+      bestScore = score;
+      bestIter = iter;
+    }
+  }
+  return bestIter;
+}
+async function listFilesRecursive(dir) {
+  const results = [];
+  async function walk(current) {
+    let entries;
+    try {
+      entries = await fs23.readdir(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = path23.join(current, entry.name);
+      if (entry.isDirectory()) {
+        await walk(fullPath);
+      } else {
+        results.push(path23.relative(dir, fullPath));
+      }
+    }
+  }
+  await walk(dir);
+  return results;
+}
+async function applyEvolution(workspacePath, projectRoot, targetIteration) {
+  const iterations = await listIterations(workspacePath);
+  if (iterations.length === 0) {
+    throw new Error("No iterations found in workspace. Run `kairn evolve run` first.");
+  }
+  let iter;
+  if (targetIteration !== void 0) {
+    if (!iterations.includes(targetIteration)) {
+      throw new Error(
+        `Iteration ${targetIteration} not found. Available: ${iterations.join(", ")}`
+      );
+    }
+    iter = targetIteration;
+  } else {
+    iter = await findBestIteration(workspacePath, iterations);
+  }
+  const harnessPath = path23.join(
+    workspacePath,
+    "iterations",
+    iter.toString(),
+    "harness"
+  );
+  const claudeDir = path23.join(projectRoot, ".claude");
+  const diffPreview = await generateDiff2(claudeDir, harnessPath);
+  const currentFiles = await listFilesRecursive(claudeDir);
+  const targetFiles = await listFilesRecursive(harnessPath);
+  const allPaths = /* @__PURE__ */ new Set([...currentFiles, ...targetFiles]);
+  const filesChanged = [];
+  for (const filePath of allPaths) {
+    const currentContent = await fs23.readFile(path23.join(claudeDir, filePath), "utf-8").catch(() => null);
+    const targetContent = await fs23.readFile(path23.join(harnessPath, filePath), "utf-8").catch(() => null);
+    if (currentContent !== targetContent) {
+      filesChanged.push(filePath);
+    }
+  }
+  await fs23.rm(claudeDir, { recursive: true, force: true });
+  await copyDir(harnessPath, claudeDir);
+  return {
+    iteration: iter,
+    filesChanged,
+    diffPreview
+  };
+}
+
 // src/commands/evolve.ts
 var DEFAULT_CONFIG = {
   model: "claude-sonnet-4-6",
   proposerModel: "claude-opus-4-6",
   scorer: "pass-fail",
   maxIterations: 5,
-  parallelTasks: 1
+  parallelTasks: 1,
+  runsPerTask: 1
 };
 async function loadEvolveConfigFromWorkspace(workspacePath) {
   try {
-    const configStr = await fs23.readFile(path23.join(workspacePath, "config.yaml"), "utf-8");
+    const configStr = await fs24.readFile(path24.join(workspacePath, "config.yaml"), "utf-8");
     const parsed = yamlParse2(configStr);
     return {
       model: parsed.model ?? DEFAULT_CONFIG.model,
       proposerModel: parsed.proposer_model ?? DEFAULT_CONFIG.proposerModel,
       scorer: parsed.scorer ?? DEFAULT_CONFIG.scorer,
       maxIterations: parsed.max_iterations ?? DEFAULT_CONFIG.maxIterations,
-      parallelTasks: parsed.parallel_tasks ?? DEFAULT_CONFIG.parallelTasks
+      parallelTasks: parsed.parallel_tasks ?? DEFAULT_CONFIG.parallelTasks,
+      runsPerTask: parsed.runs_per_task ?? DEFAULT_CONFIG.runsPerTask
     };
   } catch {
     return { ...DEFAULT_CONFIG };
@@ -5437,9 +5625,9 @@ evolveCommand.command("init").description("Initialize an evolution workspace wit
   try {
     const projectRoot = process.cwd();
     console.log(ui.section("Evolve Init"));
-    const claudeDir = path23.join(projectRoot, ".claude");
+    const claudeDir = path24.join(projectRoot, ".claude");
     try {
-      await fs23.access(claudeDir);
+      await fs24.access(claudeDir);
     } catch {
       console.log(ui.error("No .claude/ directory found. Run kairn describe first."));
       process.exit(1);
@@ -5489,7 +5677,7 @@ evolveCommand.command("init").description("Initialize an evolution workspace wit
           if (config) {
             let claudeMd = "";
             try {
-              claudeMd = await fs23.readFile(path23.join(claudeDir, "CLAUDE.md"), "utf-8");
+              claudeMd = await fs24.readFile(path24.join(claudeDir, "CLAUDE.md"), "utf-8");
             } catch {
             }
             const profile = await buildProjectProfile(projectRoot);
@@ -5520,16 +5708,16 @@ evolveCommand.command("init").description("Initialize an evolution workspace wit
 evolveCommand.command("baseline").description("Snapshot current .claude/ directory as baseline").action(async () => {
   try {
     const projectRoot = process.cwd();
-    const workspace = path23.join(projectRoot, ".kairn-evolve");
+    const workspace = path24.join(projectRoot, ".kairn-evolve");
     console.log(ui.section("Evolve Baseline"));
     try {
-      await fs23.access(workspace);
+      await fs24.access(workspace);
     } catch {
       console.log(ui.error("No .kairn-evolve/ directory found. Run kairn evolve init first."));
       process.exit(1);
     }
     await snapshotBaseline(projectRoot, workspace);
-    const baselineDir = path23.join(workspace, "baseline");
+    const baselineDir = path24.join(workspace, "baseline");
     const fileCount = await countFiles(baselineDir);
     console.log(ui.success(`Baseline snapshot created (${fileCount} files)`));
   } catch (err) {
@@ -5538,21 +5726,21 @@ evolveCommand.command("baseline").description("Snapshot current .claude/ directo
     process.exit(1);
   }
 });
-evolveCommand.command("run").description("Run tasks against the current harness").option("--task <id>", "Run a specific task by ID").option("--iterations <n>", "Number of evolution iterations", "5").action(async (options) => {
+evolveCommand.command("run").description("Run tasks against the current harness").option("--task <id>", "Run a specific task by ID").option("--iterations <n>", "Number of evolution iterations", "5").option("--runs <n>", "Run each task N times for variance measurement", "1").option("--parallel <n>", "Run up to N tasks concurrently", "1").action(async (options) => {
   try {
     const projectRoot = process.cwd();
-    const workspace = path23.join(projectRoot, ".kairn-evolve");
+    const workspace = path24.join(projectRoot, ".kairn-evolve");
     console.log(ui.section("Evolve Run"));
     try {
-      await fs23.access(workspace);
+      await fs24.access(workspace);
     } catch {
       console.log(ui.error("No .kairn-evolve/ directory found. Run kairn evolve init first."));
       process.exit(1);
     }
-    const tasksPath = path23.join(workspace, "tasks.yaml");
+    const tasksPath = path24.join(workspace, "tasks.yaml");
     let tasksContent;
     try {
-      tasksContent = await fs23.readFile(tasksPath, "utf-8");
+      tasksContent = await fs24.readFile(tasksPath, "utf-8");
     } catch {
       console.log(ui.error("No tasks.yaml found. Run kairn evolve init first."));
       process.exit(1);
@@ -5571,15 +5759,15 @@ evolveCommand.command("run").description("Run tasks against the current harness"
       console.log(ui.info(`Running ${tasksToRun.length} task(s)...`));
       console.log("");
       const config = await loadConfig();
-      const harnessPath = path23.join(projectRoot, ".claude");
+      const harnessPath = path24.join(projectRoot, ".claude");
       const results = [];
       for (const task of tasksToRun) {
-        const traceDir = path23.join(workspace, "traces", "0", task.id);
+        const traceDir = path24.join(workspace, "traces", "0", task.id);
         const spinner = ora2(`Running: ${task.id}`).start();
         const result = await runTask(task, harnessPath, traceDir, 0);
         if (config) {
-          const stdout = await fs23.readFile(path23.join(traceDir, "stdout.log"), "utf-8").catch(() => "");
-          const stderr = await fs23.readFile(path23.join(traceDir, "stderr.log"), "utf-8").catch(() => "");
+          const stdout = await fs24.readFile(path24.join(traceDir, "stdout.log"), "utf-8").catch(() => "");
+          const stderr = await fs24.readFile(path24.join(traceDir, "stderr.log"), "utf-8").catch(() => "");
           const score = await scoreTask(task, traceDir, stdout, stderr, config);
           result.score = score;
           await writeScore(traceDir, score);
@@ -5607,8 +5795,20 @@ evolveCommand.command("run").description("Run tasks against the current harness"
         process.exit(1);
       }
       evolveConfig.maxIterations = iterations;
+      const runs = parseInt(options.runs ?? "1", 10);
+      if (isNaN(runs) || runs < 1) {
+        console.log(ui.error("--runs must be a positive integer"));
+        process.exit(1);
+      }
+      evolveConfig.runsPerTask = runs;
+      const parallel = parseInt(options.parallel ?? "1", 10);
+      if (isNaN(parallel) || parallel < 1) {
+        console.log(ui.error("--parallel must be a positive integer"));
+        process.exit(1);
+      }
+      evolveConfig.parallelTasks = parallel;
       try {
-        await fs23.access(path23.join(workspace, "iterations", "0", "harness"));
+        await fs24.access(path24.join(workspace, "iterations", "0", "harness"));
       } catch {
         console.log(ui.error("No baseline harness found. Run kairn evolve baseline first."));
         process.exit(1);
@@ -5641,6 +5841,9 @@ evolveCommand.command("run").description("Run tasks against the current harness"
           case "task-start":
             console.log(chalk14.dim(`    Running: ${event.taskId ?? "unknown"}...`));
             break;
+          case "task-run":
+            console.log(chalk14.dim(`      ${event.message ?? ""}`));
+            break;
           case "task-scored": {
             const taskScore = event.score ?? 0;
             const taskStatus = taskScore >= 100 ? chalk14.green("PASS") : taskScore >= 60 ? chalk14.yellow("PARTIAL") : chalk14.red("FAIL");
@@ -5662,9 +5865,18 @@ evolveCommand.command("run").description("Run tasks against the current harness"
         console.log(`  Improvement:   ${improvement.toFixed(1)} points`);
       }
       console.log("");
-      console.log("  Iter  Score     Mutations  Status");
+      const showVariance = runs > 1;
+      console.log(showVariance ? "  Iter  Score        Mutations  Status" : "  Iter  Score     Mutations  Status");
       for (const iter of result.iterations) {
-        const scoreStr = iter.score.toFixed(1).padStart(6) + "%";
+        let scoreDisplay;
+        if (showVariance) {
+          const taskScores = Object.values(iter.taskResults);
+          const stddevs = taskScores.map((s) => s.variance?.stddev).filter((v) => v !== void 0);
+          const avgStddev = stddevs.length > 0 ? stddevs.reduce((a, b) => a + b, 0) / stddevs.length : 0;
+          scoreDisplay = `${iter.score.toFixed(1).padStart(6)}% \xB1${avgStddev.toFixed(1)}`;
+        } else {
+          scoreDisplay = iter.score.toFixed(1).padStart(6) + "%";
+        }
         const mutations = iter.proposal?.mutations.length ?? 0;
         const mutStr = mutations > 0 ? mutations.toString() : "-";
         let status = "evaluated";
@@ -5672,7 +5884,7 @@ evolveCommand.command("run").description("Run tasks against the current harness"
         else if (!iter.proposal && !iter.diffPatch) status = "rollback";
         else if (iter.score >= 100) status = "perfect";
         else if (iter.iteration === result.bestIteration) status = "best";
-        console.log(`  ${iter.iteration.toString().padStart(4)}  ${scoreStr}  ${mutStr.padStart(9)}  ${status}`);
+        console.log(`  ${iter.iteration.toString().padStart(4)}  ${scoreDisplay}  ${mutStr.padStart(9)}  ${status}`);
       }
     }
   } catch (err) {
@@ -5681,12 +5893,56 @@ evolveCommand.command("run").description("Run tasks against the current harness"
     process.exit(1);
   }
 });
+evolveCommand.command("apply").description("Apply the best evolved harness to your project").option("--iter <n>", "Apply a specific iteration instead of the best").option("--force", "Apply even if git working tree is dirty").option("--no-commit", "Skip automatic git commit after applying").action(async (options) => {
+  try {
+    const projectRoot = process.cwd();
+    const workspace = path24.join(projectRoot, ".kairn-evolve");
+    console.log(ui.section("Evolve Apply"));
+    try {
+      await fs24.access(workspace);
+    } catch {
+      console.log(ui.error("No .kairn-evolve/ directory found. Run kairn evolve init first."));
+      process.exit(1);
+    }
+    let targetIteration;
+    if (options.iter) {
+      targetIteration = parseInt(options.iter, 10);
+      if (isNaN(targetIteration)) {
+        console.log(ui.error("--iter must be a number"));
+        process.exit(1);
+      }
+    }
+    const result = await applyEvolution(workspace, projectRoot, targetIteration);
+    if (result.diffPreview) {
+      console.log(ui.section("Changes"));
+      for (const line of result.diffPreview.split("\n")) {
+        if (line.startsWith("---") || line.startsWith("+++")) {
+          console.log(chalk14.bold(line));
+        } else if (line.startsWith("+")) {
+          console.log(chalk14.green(line));
+        } else if (line.startsWith("-")) {
+          console.log(chalk14.red(line));
+        } else {
+          console.log(line);
+        }
+      }
+    }
+    console.log("");
+    console.log(ui.success(
+      `Applied iteration ${result.iteration} harness (${result.filesChanged.length} files)`
+    ));
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.log(ui.error(msg));
+    process.exit(1);
+  }
+});
 evolveCommand.command("report").description("Generate a summary report of the evolution run").option("--json", "Output machine-readable JSON instead of Markdown").action(async (options) => {
   try {
     const projectRoot = process.cwd();
-    const workspace = path23.join(projectRoot, ".kairn-evolve");
+    const workspace = path24.join(projectRoot, ".kairn-evolve");
     try {
-      await fs23.access(workspace);
+      await fs24.access(workspace);
     } catch {
       console.log(ui.error("No .kairn-evolve/ directory found. Run kairn evolve init first."));
       process.exit(1);
@@ -5707,23 +5963,23 @@ evolveCommand.command("report").description("Generate a summary report of the ev
 evolveCommand.command("diff <iter1> <iter2>").description("Show harness changes between two iterations").action(async (iter1Str, iter2Str) => {
   try {
     const projectRoot = process.cwd();
-    const workspace = path23.join(projectRoot, ".kairn-evolve");
+    const workspace = path24.join(projectRoot, ".kairn-evolve");
     const iter1 = parseInt(iter1Str, 10);
     const iter2 = parseInt(iter2Str, 10);
     if (isNaN(iter1) || isNaN(iter2)) {
       console.log(ui.error("Both arguments must be integers (iteration numbers)"));
       process.exit(1);
     }
-    const harness1 = path23.join(workspace, "iterations", iter1.toString(), "harness");
-    const harness2 = path23.join(workspace, "iterations", iter2.toString(), "harness");
+    const harness1 = path24.join(workspace, "iterations", iter1.toString(), "harness");
+    const harness2 = path24.join(workspace, "iterations", iter2.toString(), "harness");
     try {
-      await fs23.access(harness1);
+      await fs24.access(harness1);
     } catch {
       console.log(ui.error(`Iteration ${iter1} harness not found at ${harness1}`));
       process.exit(1);
     }
     try {
-      await fs23.access(harness2);
+      await fs24.access(harness2);
     } catch {
       console.log(ui.error(`Iteration ${iter2} harness not found at ${harness2}`));
       process.exit(1);
@@ -5778,10 +6034,10 @@ evolveCommand.command("diff <iter1> <iter2>").description("Show harness changes
 async function countFiles(dir) {
   let count = 0;
   try {
-    const entries = await fs23.readdir(dir, { withFileTypes: true });
+    const entries = await fs24.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        count += await countFiles(path23.join(dir, entry.name));
+        count += await countFiles(path24.join(dir, entry.name));
       } else {
         count++;
       }