@xn-intenton-z2a/agentic-lib 7.1.61 → 7.1.62

package/src/iterate.js

@@ -0,0 +1,285 @@
+// SPDX-License-Identifier: GPL-3.0-only
+// Copyright (C) 2025-2026 Polycode Limited
+// src/iterate.js — Shared iteration loop for CLI and MCP server
+//
+// Runs N cycles of maintain → transform → fix, tracking transformation cost
+// against a budget. Stops early on consecutive test passes, no-progress, or
+// budget exhaustion.
+
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { resolve, join, dirname } from "path";
+import { execSync } from "child_process";
+import { fileURLToPath } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const binPath = resolve(__dirname, "../bin/agentic-lib.js");
+
+/**
+ * Take a snapshot of all file contents in a directory (recursive).
+ * Returns an object mapping relative paths to file content strings.
+ */
+export function snapshotDir(dirPath) {
+  const snapshot = {};
+  if (!existsSync(dirPath)) return snapshot;
+  try {
+    const files = readdirSync(dirPath, { recursive: true });
+    for (const f of files) {
+      const fp = join(dirPath, String(f));
+      try {
+        snapshot[String(f)] = readFileSync(fp, "utf8");
+      } catch {
+        // skip non-readable files
+      }
+    }
+  } catch {
+    // skip unreadable dirs
+  }
+  return snapshot;
+}
+
+/**
+ * Count the number of files that differ between two snapshots.
+ */
+export function countChanges(before, after) {
+  let changes = 0;
+  const allKeys = new Set([...Object.keys(before), ...Object.keys(after)]);
+  for (const key of allKeys) {
+    if (before[key] !== after[key]) changes++;
+  }
+  return changes;
+}
+
+/**
+ * Run an agentic-lib CLI command (e.g. "transform --target /tmp/ws --model gpt-5-mini").
+ */
+export function runCli(args, cwd, timeoutMs = 300000) {
+  const cmd = `node ${binPath} ${args}`;
+  try {
+    const stdout = execSync(cmd, {
+      cwd: cwd || resolve(__dirname, ".."),
+      encoding: "utf8",
+      timeout: timeoutMs,
+      env: { ...process.env },
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    return { success: true, output: stdout };
+  } catch (err) {
+    return {
+      success: false,
+      output: `STDOUT:\n${err.stdout || ""}\nSTDERR:\n${err.stderr || ""}`,
+      exitCode: err.status || 1,
+    };
+  }
+}
+
+/**
+ * Run tests in a workspace directory.
+ */
+export function runTests(wsPath, timeoutMs = 120000) {
+  try {
+    const stdout = execSync("npm test 2>&1", {
+      cwd: wsPath,
+      encoding: "utf8",
+      timeout: timeoutMs,
+      env: { ...process.env },
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    return { success: true, output: stdout, exitCode: 0 };
+  } catch (err) {
+    return {
+      success: false,
+      output: `STDOUT:\n${err.stdout || ""}\nSTDERR:\n${err.stderr || ""}`,
+      exitCode: err.status || 1,
+    };
+  }
+}
+
+/**
+ * Read cumulative transformation cost from intentïon.md.
+ * Each cost line: `**agentic-lib transformation cost:** N`
+ */
+export function readTransformationCost(targetPath) {
+  const logPath = resolve(targetPath, "intentïon.md");
+  if (!existsSync(logPath)) return 0;
+  const content = readFileSync(logPath, "utf8");
+  const matches = content.matchAll(/\*\*agentic-lib transformation cost:\*\* (\d+)/g);
+  return [...matches].reduce((sum, m) => sum + parseInt(m[1], 10), 0);
+}
+
+/**
+ * Read transformation budget from agentic-lib.toml.
+ * Falls back to 8 (the "recommended" profile default).
+ */
+export function readBudget(targetPath) {
+  const tomlPath = resolve(targetPath, "agentic-lib.toml");
+  if (!existsSync(tomlPath)) return 8;
+  try {
+    const content = readFileSync(tomlPath, "utf8");
+    const match = content.match(/transformation-budget\s*=\s*(\d+)/);
+    return match ? parseInt(match[1], 10) : 8;
+  } catch {
+    return 8;
+  }
+}
+
+/**
+ * Detect the source path from agentic-lib.toml, defaulting to "src/lib".
+ */
+function detectSourcePath(targetPath) {
+  const tomlPath = resolve(targetPath, "agentic-lib.toml");
+  if (!existsSync(tomlPath)) return "src/lib";
+  try {
+    const content = readFileSync(tomlPath, "utf8");
+    const match = content.match(/^source\s*=\s*"([^"]+)"/m);
+    return match ? match[1] : "src/lib";
+  } catch {
+    return "src/lib";
+  }
+}
+
+/**
+ * Run an iteration loop: N cycles of steps, with stop conditions and budget tracking.
+ *
+ * @param {Object} options
+ * @param {string} options.targetPath - Workspace root directory
+ * @param {string} [options.model] - Copilot SDK model name
+ * @param {number} [options.maxCycles] - Max iterations (0 = use budget)
+ * @param {string[]} [options.steps] - Steps per cycle
+ * @param {boolean} [options.dryRun] - Skip actual Copilot calls
+ * @param {Function} [options.onCycleComplete] - Callback after each cycle
+ * @returns {Promise<{results: Array, totalCost: number, budget: number}>}
+ */
+export async function runIterationLoop({
+  targetPath,
+  model = "gpt-5-mini",
+  maxCycles = 0,
+  steps = ["maintain-features", "transform", "fix-code"],
+  dryRun = false,
+  onCycleComplete,
+}) {
+  const budget = readBudget(targetPath);
+  let totalCost = readTransformationCost(targetPath);
+  const remaining = Math.max(0, budget - totalCost);
+  const effectiveMax = maxCycles > 0 ? Math.min(maxCycles, remaining) : remaining;
+
+  if (effectiveMax <= 0) {
+    return {
+      results: [{ stopped: true, reason: `budget already exhausted (${totalCost}/${budget})` }],
+      totalCost,
+      budget,
+    };
+  }
+
+  const sourcePath = detectSourcePath(targetPath);
+  const results = [];
+  let consecutivePasses = 0;
+  let consecutiveNoChanges = 0;
+
+  for (let i = 0; i < effectiveMax; i++) {
+    const cycleStart = Date.now();
+    const cycleSteps = [];
+
+    // Snapshot source files before
+    const srcBefore = snapshotDir(resolve(targetPath, sourcePath));
+
+    // Run steps
+    for (const step of steps) {
+      if (dryRun) {
+        cycleSteps.push({ step, success: true, elapsed: "0.0", output: "[dry-run]" });
+        continue;
+      }
+      const stepStart = Date.now();
+      const result = runCli(`${step} --target ${targetPath} --model ${model}`, targetPath);
+      const stepElapsed = ((Date.now() - stepStart) / 1000).toFixed(1);
+      cycleSteps.push({
+        step,
+        success: result.success,
+        elapsed: stepElapsed,
+        output: result.output.substring(0, 500),
+      });
+    }
+
+    // Run tests
+    const testResult = dryRun ? { success: true, output: "[dry-run]" } : runTests(targetPath);
+    const testsPassed = testResult.success;
+
+    // Snapshot source files after
+    const srcAfter = dryRun ? srcBefore : snapshotDir(resolve(targetPath, sourcePath));
+    const filesChanged = countChanges(srcBefore, srcAfter);
+    const cost = filesChanged > 0 ? 1 : 0;
+    totalCost += cost;
+
+    const cycleElapsed = ((Date.now() - cycleStart) / 1000).toFixed(1);
+
+    const record = {
+      cycle: i + 1,
+      steps: cycleSteps,
+      testsPassed,
+      filesChanged,
+      cost,
+      totalCost,
+      budget,
+      elapsed: cycleElapsed,
+      model,
+    };
+    results.push(record);
+    if (onCycleComplete) onCycleComplete(record);
+
+    // Stop conditions
+    if (testsPassed) {
+      consecutivePasses++;
+      if (consecutivePasses >= 2) {
+        results.push({ stopped: true, reason: "tests passed 2 consecutive cycles" });
+        break;
+      }
+    } else {
+      consecutivePasses = 0;
+    }
+
+    if (filesChanged === 0) {
+      consecutiveNoChanges++;
+      if (consecutiveNoChanges >= 2) {
+        results.push({ stopped: true, reason: "no progress — 2 cycles with no file changes" });
+        break;
+      }
+    } else {
+      consecutiveNoChanges = 0;
+    }
+
+    if (totalCost >= budget) {
+      results.push({ stopped: true, reason: `budget exhausted (${totalCost}/${budget})` });
+      break;
+    }
+  }
+
+  return { results, totalCost, budget };
+}
+
+/**
+ * Format iteration results into a human-readable markdown string.
+ */
+export function formatIterationResults(results, totalCost, budget, label = "Iterate") {
+  const lines = [`# ${label} Results`, `Budget: ${totalCost}/${budget}`, ""];
+  for (const r of results) {
+    if (r.stopped) {
+      lines.push(`**Stopped:** ${r.reason}`);
+      continue;
+    }
+    lines.push(`## Cycle ${r.cycle} (${r.model})`);
+    lines.push(`- Elapsed: ${r.elapsed}s`);
+    lines.push(`- Files changed: ${r.filesChanged}`);
+    lines.push(`- Tests: ${r.testsPassed ? "PASS" : "FAIL"}`);
+    lines.push(`- Cost: ${r.cost} (total: ${r.totalCost}/${r.budget})`);
+    for (const s of r.steps) {
+      lines.push(`  - ${s.step}: ${s.success ? "OK" : "FAIL"} (${s.elapsed}s)`);
+    }
+    lines.push("");
+  }
+  const completed = results.filter((r) => !r.stopped).length;
+  const lastPassed = results.filter((r) => !r.stopped).slice(-1)[0]?.testsPassed;
+  lines.push("## Summary");
+  lines.push(`- Cycles completed: ${completed}`);
+  lines.push(`- Final test status: ${lastPassed ? "PASS" : "FAIL"}`);
+  lines.push(`- Total cost: ${totalCost}/${budget}`);
+  return lines.join("\n");
+}

package/src/mcp/server.js

@@ -227,7 +227,7 @@ const TOOLS = [
         overrides: {
           type: "object",
           description:
-            "Individual tuning knob overrides. Keys: reasoning-effort, infinite-sessions, features-scan, source-scan, source-content, issues-scan, document-summary, discussion-comments",
+            "Individual tuning knob overrides. Keys: reasoning-effort, infinite-sessions, max-feature-files, max-source-files, max-source-chars, max-issues, max-summary-chars, max-discussion-comments",
         },
       },
       required: ["workspace"],
@@ -482,115 +482,40 @@ async function handleIterate({ workspace, cycles = 3, steps }) {
     return text(`Workspace "${workspace}" not found.`);
   }
 
+  const { runIterationLoop, formatIterationResults } = await import("../iterate.js");
   const stepsToRun = steps || ["maintain-features", "transform", "fix-code"];
-  const results = [];
-  let consecutivePasses = 0;
-  let consecutiveNoChanges = 0;
   const startIterNum = (meta.iterations?.length || 0) + 1;
 
   meta.status = "iterating";
   writeMetadata(wsPath, meta);
 
-  for (let i = 0; i < cycles; i++) {
-    const iterNum = startIterNum + i;
-    const iterStart = Date.now();
-    const iterSteps = [];
-
-    // Snapshot source files before
-    const srcBefore = snapshotDir(join(wsPath, "src/lib"));
-
-    for (const step of stepsToRun) {
-      const stepStart = Date.now();
-      const result = runCli(
-        `${step} --target ${wsPath} --model ${meta.model}`,
-        wsPath,
-        300000,
-      );
-      const stepElapsed = ((Date.now() - stepStart) / 1000).toFixed(1);
-      iterSteps.push({
-        step,
-        success: result.success,
-        elapsed: stepElapsed,
-        output: result.output.substring(0, 500),
+  const { results, totalCost, budget } = await runIterationLoop({
+    targetPath: wsPath,
+    model: meta.model,
+    maxCycles: cycles,
+    steps: stepsToRun,
+    onCycleComplete: (record) => {
+      if (record.stopped) return;
+      // Persist each iteration to workspace metadata
+      meta.iterations.push({
+        number: startIterNum + record.cycle - 1,
+        profile: meta.profile,
+        model: meta.model,
+        steps: record.steps,
+        testsPassed: record.testsPassed,
+        filesChanged: record.filesChanged,
+        elapsed: record.elapsed,
       });
-    }
-
-    // Run tests
-    const testResult = runInWorkspace("npm test 2>&1", wsPath, 60000);
-    const testsPassed = testResult.success;
-
-    // Snapshot source files after
-    const srcAfter = snapshotDir(join(wsPath, "src/lib"));
-    const filesChanged = countChanges(srcBefore, srcAfter);
-
-    const iterElapsed = ((Date.now() - iterStart) / 1000).toFixed(1);
-
-    const iterRecord = {
-      number: iterNum,
-      profile: meta.profile,
-      model: meta.model,
-      steps: iterSteps,
-      testsPassed,
-      filesChanged,
-      elapsed: iterElapsed,
-    };
-
-    meta.iterations.push(iterRecord);
-    writeMetadata(wsPath, meta);
-
-    results.push(iterRecord);
-
-    // Check stop conditions
-    if (testsPassed) {
-      consecutivePasses++;
-      if (consecutivePasses >= 2) {
-        results.push({ stopped: true, reason: "tests passed for 2 consecutive iterations" });
-        break;
-      }
-    } else {
-      consecutivePasses = 0;
-    }
-
-    if (filesChanged === 0) {
-      consecutiveNoChanges++;
-      if (consecutiveNoChanges >= 2) {
-        results.push({ stopped: true, reason: "no files changed for 2 consecutive iterations (stalled)" });
-        break;
-      }
-    } else {
-      consecutiveNoChanges = 0;
-    }
-  }
+      writeMetadata(wsPath, meta);
+    },
+  });
 
   meta.status = "ready";
   writeMetadata(wsPath, meta);
 
-  // Format results
-  const lines = [`# Iterate Results: ${workspace}`, `Cycles requested: ${cycles}`, ""];
-  for (const r of results) {
-    if (r.stopped) {
-      lines.push(`**Stopped early:** ${r.reason}`);
-      continue;
-    }
-    lines.push(`## Iteration ${r.number} (${r.model}, ${r.profile})`);
-    lines.push(`- Elapsed: ${r.elapsed}s`);
-    lines.push(`- Files changed: ${r.filesChanged}`);
-    lines.push(`- Tests: ${r.testsPassed ? "PASS" : "FAIL"}`);
-    for (const s of r.steps) {
-      lines.push(`  - ${s.step}: ${s.success ? "OK" : "FAIL"} (${s.elapsed}s)`);
-    }
-    lines.push("");
-  }
-
-  const totalIters = results.filter((r) => !r.stopped).length;
-  const lastPassed = results.filter((r) => !r.stopped).slice(-1)[0]?.testsPassed;
-  lines.push("## Summary");
-  lines.push(`- Iterations completed: ${totalIters}`);
-  lines.push(`- Final test status: ${lastPassed ? "PASS" : "FAIL"}`);
-  lines.push(`- Total iterations for this workspace: ${meta.iterations.length}`);
-  lines.push(`- Profile: ${meta.profile} | Model: ${meta.model}`);
-
-  return text(lines.join("\n"));
+  const output = formatIterationResults(results, totalCost, budget, `Iterate: ${workspace}`);
+  const extra = `\n- Total iterations for this workspace: ${meta.iterations.length}\n- Profile: ${meta.profile} | Model: ${meta.model}`;
+  return text(output + extra);
 }
 
 async function handleRunTests({ workspace }) {
@@ -841,34 +766,6 @@ function profileDefaultModel(profile) {
   return models[profile] || "gpt-5-mini";
 }
 
-function snapshotDir(dirPath) {
-  const snapshot = {};
-  if (!existsSync(dirPath)) return snapshot;
-  try {
-    const files = readdirSync(dirPath, { recursive: true });
-    for (const f of files) {
-      const fp = join(dirPath, String(f));
-      try {
-        snapshot[String(f)] = readFileSync(fp, "utf8");
-      } catch {
-        // skip non-readable files
-      }
-    }
-  } catch {
-    // skip unreadable dirs
-  }
-  return snapshot;
-}
-
-function countChanges(before, after) {
-  let changes = 0;
-  const allKeys = new Set([...Object.keys(before), ...Object.keys(after)]);
-  for (const key of allKeys) {
-    if (before[key] !== after[key]) changes++;
-  }
-  return changes;
-}
-
 // ─── MCP Server ─────────────────────────────────────────────────────
 
 const toolHandlers = {

package/src/seeds/zero-README.md

@@ -60,8 +60,8 @@ source = "src/lib/"
 tests = "tests/unit/"
 
 [limits]
-feature-issues = 2      # max concurrent feature issues
-attempts-per-issue = 2   # max retries per issue
+max-feature-issues = 2      # max concurrent feature issues
+max-attempts-per-issue = 2   # max retries per issue
 ```
 
 ## Updating

package/src/seeds/zero-package.json

@@ -14,7 +14,7 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "@xn-intenton-z2a/agentic-lib": "^7.1.61"
+    "@xn-intenton-z2a/agentic-lib": "^7.1.62"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "^4.0.18",