kairn-cli 2.2.4 → 2.2.6

package/dist/cli.js

@@ -1245,9 +1245,6 @@ async function callLLM(config, userMessage, options) {
     const messages = [
       { role: "user", content: userMessage }
     ];
-    if (jsonMode) {
-      messages.push({ role: "assistant", content: "{" });
-    }
     try {
       const response = await client2.messages.create({
         model: config.model,
@@ -1259,7 +1256,7 @@ async function callLLM(config, userMessage, options) {
       if (!textBlock || textBlock.type !== "text") {
         throw new Error("No text response from compiler LLM");
       }
-      return jsonMode ? `{${textBlock.text}` : textBlock.text;
+      return textBlock.text;
     } catch (err) {
       throw new Error(classifyError(err, providerName));
     }
@@ -4569,17 +4566,47 @@ function parseToolCalls(stdout) {
     return [];
   }
 }
+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) {
+async function evaluateAll(tasks, harnessPath, workspacePath, iteration, config, onProgress, runsPerTask = 1, parallelTasks = 1) {
   const results = {};
   const projectRoot = path18.resolve(workspacePath, "..");
   const effectiveRuns = Math.max(1, runsPerTask);
-  for (const task of tasks) {
+  const concurrency = Math.max(1, parallelTasks);
+  const evaluateTask = async (task) => {
     onProgress?.({ type: "task-start", iteration, taskId: task.id });
+    let finalScore;
     if (effectiveRuns > 1 && config) {
       const runScores = [];
       let passCount = 0;
@@ -4606,7 +4633,7 @@ async function evaluateAll(tasks, harnessPath, workspacePath, iteration, config,
       }
       const mean = runScores.reduce((a, b) => a + b, 0) / runScores.length;
       const stddev = computeStddev(runScores, mean);
-      results[task.id] = {
+      finalScore = {
         pass: passCount > effectiveRuns / 2,
         score: mean,
         details: `Mean of ${effectiveRuns} runs`,
@@ -4625,22 +4652,28 @@ async function evaluateAll(tasks, harnessPath, workspacePath, iteration, config,
         task.id
       );
       const taskResult = await runTask(task, harnessPath, traceDir, iteration, projectRoot);
-      let score = taskResult.score;
+      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(() => "");
-        score = await scoreTask(task, traceDir, stdout, stderr, config);
-        await writeScore(traceDir, score);
+        finalScore = await scoreTask(task, traceDir, stdout, stderr, config);
+        await writeScore(traceDir, finalScore);
       }
-      results[task.id] = score;
     }
-    const finalScore = results[task.id];
     onProgress?.({
       type: "task-scored",
       iteration,
       taskId: task.id,
       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(
@@ -5099,7 +5132,8 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
       iter,
       kairnConfig,
       onProgress,
-      evolveConfig.runsPerTask
+      evolveConfig.runsPerTask,
+      evolveConfig.parallelTasks
     );
     onProgress?.({ type: "iteration-scored", iteration: iter, score: aggregate });
     if (iter === 0) baselineScore = aggregate;
@@ -5689,7 +5723,7 @@ 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").option("--runs <n>", "Run each task N times for variance measurement", "1").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 = path24.join(projectRoot, ".kairn-evolve");
@@ -5764,6 +5798,12 @@ evolveCommand.command("run").description("Run tasks against the current harness"
         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 fs24.access(path24.join(workspace, "iterations", "0", "harness"));
       } catch {