@vexdo/cli 0.1.1 → 0.1.3

package/dist/index.js

@@ -552,7 +552,11 @@ ${JSON.stringify(opts.reviewComments)}`
         if (!isRetryableError(error) || attempt === MAX_ATTEMPTS) {
           throw new ClaudeError(attempt, error);
         }
-        await sleep(1e3 * 2 ** (attempt - 1));
+        const backoffMs = 1e3 * 2 ** (attempt - 1);
+        warn(
+          `Claude API error on attempt ${String(attempt)}/${String(MAX_ATTEMPTS)}. Retrying in ${String(Math.round(backoffMs / 1e3))}s...`
+        );
+        await sleep(backoffMs);
       }
     }
     throw new ClaudeError(MAX_ATTEMPTS, lastError);
@@ -673,6 +677,7 @@ function isRetryableError(error) {
 // src/lib/codex.ts
 import { execFile as execFileCb } from "child_process";
 var CODEX_TIMEOUT_MS = 6e5;
+var VERBOSE_HEARTBEAT_MS = 15e3;
 var CodexError = class extends Error {
   stdout;
   stderr;
@@ -691,6 +696,33 @@ var CodexNotFoundError = class extends Error {
     this.name = "CodexNotFoundError";
   }
 };
+function formatElapsed(startedAt) {
+  const seconds = Math.max(0, Math.round((Date.now() - startedAt) / 1e3));
+  return `${String(seconds)}s`;
+}
+function buildVerboseStreamHandler(label) {
+  let partialLine = "";
+  return {
+    onData(chunk) {
+      partialLine += chunk.toString();
+      const lines = partialLine.split(/\r?\n/);
+      partialLine = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line) {
+          continue;
+        }
+        debug(`[codex:${label}] ${line}`);
+      }
+    },
+    flush() {
+      if (!partialLine) {
+        return;
+      }
+      debug(`[codex:${label}] ${partialLine}`);
+      partialLine = "";
+    }
+  };
+}
 async function checkCodexAvailable() {
   await new Promise((resolve, reject) => {
     execFileCb("codex", ["--version"], { timeout: CODEX_TIMEOUT_MS, encoding: "utf8" }, (error) => {
@@ -704,24 +736,43 @@ async function checkCodexAvailable() {
 }
 async function exec(opts) {
   const args = ["exec", "--model", opts.model, "--full-auto", "--", opts.spec];
+  const startedAt = Date.now();
+  if (opts.verbose) {
+    debug(`[codex] starting (model=${opts.model}, cwd=${opts.cwd})`);
+  }
   return await new Promise((resolve, reject) => {
-    execFileCb(
+    let liveLogsAttached = false;
+    const stdoutHandler = buildVerboseStreamHandler("stdout");
+    const stderrHandler = buildVerboseStreamHandler("stderr");
+    const heartbeat = opts.verbose ? setInterval(() => {
+      debug(`[codex] still running (${formatElapsed(startedAt)})`);
+    }, VERBOSE_HEARTBEAT_MS) : null;
+    const child = execFileCb(
       "codex",
       args,
       { cwd: opts.cwd, timeout: CODEX_TIMEOUT_MS, encoding: "utf8", maxBuffer: 10 * 1024 * 1024 },
       (error, stdout, stderr) => {
+        if (heartbeat) {
+          clearInterval(heartbeat);
+        }
+        stdoutHandler.flush();
+        stderrHandler.flush();
         const normalizedStdout = stdout.trimEnd();
         const normalizedStderr = stderr.trimEnd();
         if (opts.verbose) {
-          if (normalizedStdout) {
+          debug(`[codex] finished in ${formatElapsed(startedAt)}`);
+          if (!liveLogsAttached && normalizedStdout) {
             debug(normalizedStdout);
           }
-          if (normalizedStderr) {
+          if (!liveLogsAttached && normalizedStderr) {
             debug(normalizedStderr);
           }
         }
         if (error) {
           const exitCode = typeof error.code === "number" ? error.code : 1;
+          if (opts.verbose) {
+            debug(`[codex] failed in ${formatElapsed(startedAt)} with exit ${String(exitCode)}`);
+          }
           reject(new CodexError(normalizedStdout, normalizedStderr || error.message, exitCode));
           return;
         }
@@ -732,6 +783,18 @@ async function exec(opts) {
         });
       }
     );
+    if (opts.verbose) {
+      const stdout = child.stdout;
+      const stderr = child.stderr;
+      if (stdout) {
+        liveLogsAttached = true;
+        stdout.on("data", stdoutHandler.onData);
+      }
+      if (stderr) {
+        liveLogsAttached = true;
+        stderr.on("data", stderrHandler.onData);
+      }
+    }
   });
 }
 
@@ -846,6 +909,10 @@ function getBranchName(taskId, service) {
 }
 
 // src/lib/review-loop.ts
+function formatElapsed2(startedAt) {
+  const seconds = Math.max(0, Math.round((Date.now() - startedAt) / 1e3));
+  return `${String(seconds)}s`;
+}
 async function runReviewLoop(opts) {
   if (opts.dryRun) {
     info(`[dry-run] Would run review loop for service ${opts.step.service}`);
@@ -868,7 +935,11 @@ async function runReviewLoop(opts) {
   let iteration2 = opts.stepState.iteration;
   for (; ; ) {
     iteration(iteration2 + 1, opts.config.review.max_iterations);
+    info(`Collecting git diff for service ${opts.step.service}`);
     const diff = await getDiff(serviceRoot);
+    if (opts.verbose) {
+      info(`Diff collected (${String(diff.length)} chars)`);
+    }
     if (!diff.trim()) {
       return {
         decision: "submit",
@@ -881,18 +952,39 @@ async function runReviewLoop(opts) {
         }
       };
     }
+    info(`Requesting reviewer analysis (model: ${opts.config.review.model})`);
+    const reviewerStartedAt = Date.now();
+    const reviewerHeartbeat = opts.verbose ? setInterval(() => {
+      info(`Waiting for reviewer response (${formatElapsed2(reviewerStartedAt)})`);
+    }, 15e3) : null;
     const review = await opts.claude.runReviewer({
       spec: opts.step.spec,
       diff,
       model: opts.config.review.model
+    }).finally(() => {
+      if (reviewerHeartbeat) {
+        clearInterval(reviewerHeartbeat);
+      }
     });
+    info(`Reviewer response received in ${formatElapsed2(reviewerStartedAt)}`);
     reviewSummary(review.comments);
+    info(`Requesting arbiter decision (model: ${opts.config.review.model})`);
+    const arbiterStartedAt = Date.now();
+    const arbiterHeartbeat = opts.verbose ? setInterval(() => {
+      info(`Waiting for arbiter response (${formatElapsed2(arbiterStartedAt)})`);
+    }, 15e3) : null;
     const arbiter = await opts.claude.runArbiter({
       spec: opts.step.spec,
       diff,
       reviewComments: review.comments,
       model: opts.config.review.model
+    }).finally(() => {
+      if (arbiterHeartbeat) {
+        clearInterval(arbiterHeartbeat);
+      }
     });
+    info(`Arbiter response received in ${formatElapsed2(arbiterStartedAt)}`);
+    info(`Arbiter decision: ${arbiter.decision} (${arbiter.summary})`);
     saveIterationLog(opts.projectRoot, opts.taskId, opts.step.service, iteration2, {
       diff,
       review,
@@ -940,6 +1032,7 @@ async function runReviewLoop(opts) {
         }
       };
     }
+    info("Applying arbiter feedback with codex");
     await exec({
       spec: arbiter.feedback_for_codex,
       model: opts.config.codex.model,
@@ -992,6 +1085,7 @@ async function runFix(feedback, options) {
         verbose: options.verbose
       });
     }
+    info(`Running review loop for service ${step2.service}`);
     const result = await runReviewLoop({
       taskId: task.id,
       task,
@@ -1023,7 +1117,7 @@ async function runFix(feedback, options) {
   }
 }
 function registerFixCommand(program2) {
-  program2.command("fix").description("Provide feedback to codex and rerun review").argument("<feedback>").action(async (feedback, options, command) => {
+  program2.command("fix").description("Provide feedback to codex and rerun review").argument("<feedback>").option("--verbose", "Enable verbose logs").option("--dry-run", "Print plan without making changes").action(async (feedback, options, command) => {
     const merged = command.optsWithGlobals();
     await runFix(feedback, { ...options, ...merged });
   });
@@ -1223,6 +1317,7 @@ async function runReview(options) {
     if (!step2) {
       fatalAndExit4(`Could not locate task step for service '${currentStep.service}'.`);
     }
+    info(`Running review loop for service ${step2.service}`);
     const result = await runReviewLoop({
       taskId: task.id,
       task,
@@ -1265,7 +1360,7 @@ async function runReview(options) {
   }
 }
 function registerReviewCommand(program2) {
-  program2.command("review").description("Run review loop for the current step").action(async (options, command) => {
+  program2.command("review").description("Run review loop for the current step").option("--verbose", "Enable verbose logs").option("--dry-run", "Print plan without making changes").action(async (options, command) => {
     const merged = command.optsWithGlobals();
     await runReview({ ...options, ...merged });
   });
@@ -1382,6 +1477,7 @@ async function runStart(taskFile, options) {
         saveState(projectRoot, state);
       }
       if (!options.resume && !options.dryRun) {
+        info(`Running codex implementation for service ${step2.service}`);
         await exec({
           spec: step2.spec,
           model: config.codex.model,
@@ -1391,6 +1487,7 @@ async function runStart(taskFile, options) {
       } else if (options.dryRun) {
         info(`[dry-run] Would run codex for service ${step2.service}`);
       }
+      info(`Starting review loop for service ${step2.service}`);
       const result = await runReviewLoop({
         taskId: task.id,
         task,
@@ -1445,7 +1542,7 @@ async function runStart(taskFile, options) {
   }
 }
 function registerStartCommand(program2) {
-  program2.command("start").description("Start a task from a YAML file").argument("<task-file>").option("--resume", "Resume an existing active task").action(async (taskFile, options, command) => {
+  program2.command("start").description("Start a task from a YAML file").argument("<task-file>").option("--verbose", "Enable verbose logs").option("--dry-run", "Print plan without making changes").option("--resume", "Resume an existing active task").action(async (taskFile, options, command) => {
     const merged = command.optsWithGlobals();
     await runStart(taskFile, { ...options, ...merged });
   });
@@ -1456,7 +1553,7 @@ function fatalAndExit6(message) {
   fatal(message);
   process.exit(1);
 }
-function formatElapsed(startedAt) {
+function formatElapsed3(startedAt) {
   const elapsedMs = Date.now() - new Date(startedAt).getTime();
   const minutes = Math.floor(elapsedMs / 1e3 / 60);
   const hours = Math.floor(minutes / 60);
@@ -1484,7 +1581,7 @@ function runStatus() {
   if (inProgress?.lastArbiterResult?.summary) {
     info(`Last arbiter summary: ${inProgress.lastArbiterResult.summary}`);
   }
-  info(`Elapsed: ${formatElapsed(state.startedAt)}`);
+  info(`Elapsed: ${formatElapsed3(state.startedAt)}`);
 }
 function registerStatusCommand(program2) {
   program2.command("status").description("Print active task status").action(() => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vexdo/cli",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "type": "module",
   "main": "./dist/index.js",
   "bin": {