@boopkit/cli 0.6.12 → 0.6.13

package/dist/commands/loop.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RESUME_PROMPT = exports.DEFAULT_BUDGET_USD = void 0;
+exports.RESUME_PROMPT = exports.DEFAULT_BUDGET_USD = exports.BD_READ_MAX_BUFFER = void 0;
 exports.assertDoltServerMode = assertDoltServerMode;
 exports.discoverDoltServer = discoverDoltServer;
 exports.resolveDefaultBranch = resolveDefaultBranch;
@@ -57,6 +57,71 @@ const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const crypto_1 = require("crypto");
+/**
+ * Output cap for every `bd … --json` read the loop makes.
+ *
+ * Node's execSync defaults to 1 MiB and throws ENOBUFS past it. `bd ready --json`
+ * returns each issue WITH its full description, and `bd show --children --json`
+ * on a large container is the same trap — a mature backlog crosses 1 MiB and the
+ * read dies. The ready-queue read also projects its output (see
+ * READY_QUEUE_CMD); this cap is the backstop for the reads that cannot (boop-fl22).
+ */
+exports.BD_READ_MAX_BUFFER = 256 * 1024 * 1024;
+/**
+ * The ready-queue read, projected to the only three fields the filters below use.
+ *
+ * Unprojected this returns every ready issue with its full description: measured
+ * in boop at 274,529 bytes for 112 issues, 69.7% of it description that nothing
+ * here reads. The projection takes that to 5,941 bytes. `-n 0` = unlimited, which
+ * is itself the fix for boop-pra; unlimited fetch is only safe once the per-record
+ * payload is bounded (boop-fl22).
+ */
+const READY_QUEUE_CMD = `bd ready --json -n 0 2>/dev/null | jq -c '[.[] | {id, issue_type, parent}]'`;
+/**
+ * The same read without the projection, for hosts that have no `jq`.
+ *
+ * jq ships with neither stock macOS nor stock Debian, and the projection is an
+ * optimisation rather than a requirement — BD_READ_MAX_BUFFER already makes the
+ * unprojected read safe. So a missing jq degrades the read instead of breaking
+ * the loop (boop-fl22).
+ */
+const READY_QUEUE_CMD_UNPROJECTED = 'bd ready --json -n 0 2>/dev/null';
+/** Warn once per process, not once per loop iteration. Never gates control flow. */
+let warnedAboutProjection = false;
+function readReadyQueue(execSyncFn) {
+    const opts = { encoding: 'utf8', maxBuffer: exports.BD_READ_MAX_BUFFER };
+    // Run one read and insist it produced something. A healthy read always emits
+    // at least `[]`, so empty output means the command failed — and `sh` has no
+    // pipefail, so a pipeline hides the exit status of `bd` itself. This is the
+    // only signal that the left side of the pipe died. The command is carried in
+    // the message so the diagnostic names the read that actually failed.
+    const read = (cmd) => {
+        let raw;
+        try {
+            raw = execSyncFn(cmd, opts);
+        }
+        catch (e) {
+            throw new Error(`${e.message.split('\n')[0]} (command: ${cmd})`);
+        }
+        if (!raw.trim()) {
+            throw new Error(`bd produced no output — a healthy read emits at least [] (command: ${cmd})`);
+        }
+        return raw;
+    };
+    // Always attempt the projection: a failed `jq` lookup is microseconds, and
+    // caching the outcome would make this function depend on call history.
+    try {
+        return read(READY_QUEUE_CMD);
+    }
+    catch (e) {
+        if (!warnedAboutProjection) {
+            warnedAboutProjection = true;
+            console.warn(`\x1b[33m[bd-loop]\x1b[0m Projected ready-queue read failed (${e.message}); ` +
+                `falling back to the unprojected read. Install \`jq\` to keep the queue read small.`);
+        }
+    }
+    return read(READY_QUEUE_CMD_UNPROJECTED);
+}
 /**
  * Hard requirement: beads must run in Dolt server mode so concurrent worktrees
  * share one issue DB over TCP. Reads `.beads/metadata.json` and throws an
@@ -490,8 +555,9 @@ async function planWork(opts) {
     // Fallback: query bd list for recently created features
     console.log('\x1b[33m[bd-loop]\x1b[0m No FEATURE_ID in output, trying fallback query...');
     try {
-        const execFn = opts.execSyncFn || ((cmd, o) => (0, child_process_1.execSync)(cmd, o));
-        const raw = execFn('bd list --json --type feature 2>/dev/null', { encoding: 'utf8' });
+        const execFn = opts.execSyncFn ||
+            ((cmd, o) => (0, child_process_1.execSync)(cmd, o));
+        const raw = execFn('bd list --json --type feature 2>/dev/null', { encoding: 'utf8', maxBuffer: exports.BD_READ_MAX_BUFFER });
         const features = JSON.parse(raw);
         const fallbackId = findFallbackFeature(features, workContent, opts.workPath);
         if (fallbackId) {
@@ -615,7 +681,7 @@ function findNextIssue(prefix, includeFeatures) {
 }
 function getIssueParentId(id) {
     try {
-        const raw = (0, child_process_1.execSync)(`bd show ${id} --json 2>/dev/null`, { encoding: 'utf8' });
+        const raw = (0, child_process_1.execSync)(`bd show ${id} --json 2>/dev/null`, { encoding: 'utf8', maxBuffer: exports.BD_READ_MAX_BUFFER });
         const data = JSON.parse(raw);
         const issue = data[0] || data;
         return issue.parent || null;
@@ -678,7 +744,7 @@ function shouldCloseFeatureRoot(feature, children) {
 }
 function getIssueChildren(id) {
     try {
-        const raw = (0, child_process_1.execSync)(`bd show ${id} --children --json 2>/dev/null`, { encoding: 'utf8' });
+        const raw = (0, child_process_1.execSync)(`bd show ${id} --children --json 2>/dev/null`, { encoding: 'utf8', maxBuffer: exports.BD_READ_MAX_BUFFER });
         const data = JSON.parse(raw);
         const children = data[id];
         return Array.isArray(children) ? children : [];
@@ -714,7 +780,7 @@ function closeCompletedFeatureRoot(featureId) {
 }
 function getIssueInfoWithStatus(id) {
     try {
-        const raw = (0, child_process_1.execSync)(`bd show ${id} --json 2>/dev/null`, { encoding: 'utf8' });
+        const raw = (0, child_process_1.execSync)(`bd show ${id} --json 2>/dev/null`, { encoding: 'utf8', maxBuffer: exports.BD_READ_MAX_BUFFER });
         const data = JSON.parse(raw);
         const issue = data[0] || data;
         return { status: issue.status || 'unknown', issue_type: issue.issue_type || 'task' };
@@ -723,15 +789,18 @@ function getIssueInfoWithStatus(id) {
         return null;
     }
 }
+/**
+ * Read the ready queue, filtered to what this loop may claim.
+ *
+ * THROWS on a failed read. It must never answer a broken read with an empty
+ * array: the caller treats "no issues" as a clean finish, so a swallowed
+ * failure makes the loop exit 0 with work undone (boop-fl22).
+ */
 function getMatchingReadyIssues(prefix, includeFeatures, deps) {
     const execSyncFn = deps?.execSyncFn ||
         ((cmd, opts) => (0, child_process_1.execSync)(cmd, opts));
     try {
-        // -n 0 = unlimited. A bounded window (formerly -n 20) starves the scope
-        // filter below: with more than 20 ready issues globally, in-scope issues
-        // sorting outside the window are never seen and the loop exits with group
-        // work undone (boop-pra).
-        const raw = execSyncFn('bd ready --json -n 0 2>/dev/null', { encoding: 'utf8' });
+        const raw = readReadyQueue(execSyncFn);
         const issues = JSON.parse(raw);
         const typeFilter = includeFeatures
             ? (i) => i.issue_type !== 'epic'
@@ -763,13 +832,13 @@ function getMatchingReadyIssues(prefix, includeFeatures, deps) {
             .filter((issue) => isIssueInScope(issue, prefix, getParentById))
             .filter((issue) => isClaimableReadyIssue(issue, hasChildren));
     }
-    catch {
-        return [];
+    catch (e) {
+        throw new Error(`Could not read the ready queue: ${e.message}`);
     }
 }
 function getIssueInfo(id) {
     try {
-        const raw = (0, child_process_1.execSync)(`bd show ${id} --json 2>/dev/null`, { encoding: 'utf8' });
+        const raw = (0, child_process_1.execSync)(`bd show ${id} --json 2>/dev/null`, { encoding: 'utf8', maxBuffer: exports.BD_READ_MAX_BUFFER });
         const data = JSON.parse(raw);
         const issue = data[0] || data;
         return {
@@ -786,7 +855,7 @@ function getIssueInfo(id) {
 }
 function isIssueClosed(id) {
     try {
-        const raw = (0, child_process_1.execSync)(`bd show ${id} --json 2>/dev/null`, { encoding: 'utf8' });
+        const raw = (0, child_process_1.execSync)(`bd show ${id} --json 2>/dev/null`, { encoding: 'utf8', maxBuffer: exports.BD_READ_MAX_BUFFER });
         const data = JSON.parse(raw);
         const status = (data[0] || data).status || 'unknown';
         return status === 'closed';
@@ -1300,7 +1369,27 @@ async function runLoop(options) {
     // rotation). Actual rotations are everything after the first — see the summary.
     const sessionStarts = [];
     while (true) {
-        const nextId = prefix ? findNextIssue(prefix, includeFeatures) : null;
+        let nextId = null;
+        if (prefix) {
+            try {
+                nextId = findNextIssue(prefix, includeFeatures);
+            }
+            catch (e) {
+                // A failed read is not a drained queue. Treating the two alike is the
+                // boop-fl22 bug: the loop printed "No more ready issues" and exited 0
+                // while `bd ready` was still listing claimable work.
+                console.error(`\x1b[31m[bd-loop]\x1b[0m ${e.message}`);
+                if (poll) {
+                    console.error(`\x1b[31m[bd-loop]\x1b[0m Ready-queue read FAILED (not an empty queue); retrying in ${pollInterval}s.`);
+                    await sleep(pollInterval * 1000);
+                    continue;
+                }
+                console.error(`\x1b[31m[bd-loop]\x1b[0m Stopping: the ready queue could not be read, so work may be outstanding. ` +
+                    `This is NOT a clean finish.`);
+                process.exitCode = 1;
+                break;
+            }
+        }
         if (!nextId) {
             // Spec-driven safety net: the filter removes the workflow-owned feature
             // root from claimable work, so when its chain completes nobody may have