kodevu 0.1.13 → 0.1.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kodevu",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "type": "module",
   "description": "Poll SVN revisions or Git commits, send each change diff to a reviewer CLI, and write configurable review reports.",
   "bin": {
@@ -13,7 +13,7 @@
   ],
   "scripts": {
     "start": "node src/index.js",
-    "check": "node --check src/index.js && node --check src/config.js && node --check src/review-runner.js && node --check src/svn-client.js && node --check src/git-client.js && node --check src/vcs-client.js && node --check src/shell.js"
+    "check": "node --check src/index.js && node --check src/config.js && node --check src/review-runner.js && node --check src/svn-client.js && node --check src/git-client.js && node --check src/vcs-client.js && node --check src/shell.js && node --check src/progress-ui.js"
   },
   "engines": {
     "node": ">=20"

package/src/progress-ui.js

@@ -0,0 +1,206 @@
+import readline from "node:readline";
+
+const SPINNER_FRAMES = ["|", "/", "-", "\\"];
+const DEFAULT_BAR_WIDTH = 24;
+
+function clampProgress(value) {
+  if (!Number.isFinite(value)) {
+    return 0;
+  }
+
+  return Math.max(0, Math.min(1, value));
+}
+
+function buildBar(progress, width) {
+  const safeProgress = clampProgress(progress);
+  const filled = Math.max(Math.round(safeProgress * width), safeProgress > 0 ? 1 : 0);
+
+  if (filled >= width) {
+    return `[${"=".repeat(width)}]`;
+  }
+
+  if (filled === 0) {
+    return `[${" ".repeat(width)}]`;
+  }
+
+  return `[${"=".repeat(Math.max(filled - 1, 0))}>${" ".repeat(width - filled)}]`;
+}
+
+class ProgressItem {
+  constructor(display, label, options = {}) {
+    this.display = display;
+    this.label = label;
+    this.barWidth = options.barWidth || DEFAULT_BAR_WIDTH;
+    this.progress = 0;
+    this.stage = "";
+    this.active = false;
+    this.lastFallbackLine = "";
+  }
+
+  start(stage = "starting") {
+    this.stage = stage;
+    this.active = true;
+
+    if (!this.display.enabled) {
+      this.writeFallback(`... ${this.label}: ${stage}`);
+      return;
+    }
+
+    this.display.start();
+    this.display.render();
+  }
+
+  update(progress, stage) {
+    this.progress = clampProgress(progress);
+
+    if (stage) {
+      this.stage = stage;
+    }
+
+    if (!this.display.enabled) {
+      this.writeFallback(`... ${this.label}: ${this.stage}`);
+      return;
+    }
+
+    this.display.render();
+  }
+
+  log(message) {
+    this.display.log(message);
+  }
+
+  succeed(message) {
+    this.finish("[done]", 1, message || `${this.label} complete`);
+  }
+
+  fail(message) {
+    this.finish("[fail]", this.progress, message || `${this.label} failed`);
+  }
+
+  finish(prefix, progress, message) {
+    this.progress = clampProgress(progress);
+    this.active = false;
+    this.display.stopIfIdle();
+    this.display.writeStaticLine(
+      `${prefix} ${this.label} ${buildBar(this.progress, this.barWidth)} ${Math.round(this.progress * 100)
+        .toString()
+        .padStart(3, " ")}% ${message}`
+    );
+  }
+
+  renderLine(frameIndex) {
+    const spinner = SPINNER_FRAMES[frameIndex];
+    const bar = buildBar(this.progress, this.barWidth);
+    const pct = `${Math.round(this.progress * 100)}`.padStart(3, " ");
+    return `${spinner} ${this.label} ${bar} ${pct}% ${this.stage}`;
+  }
+
+  writeFallback(line) {
+    if (line === this.lastFallbackLine) {
+      return;
+    }
+
+    this.lastFallbackLine = line;
+    this.display.stream.write(`${line}\n`);
+  }
+}
+
+export class ProgressDisplay {
+  constructor(options = {}) {
+    this.stream = options.stream || process.stdout;
+    this.enabled = Boolean(this.stream.isTTY);
+    this.frameIndex = 0;
+    this.timer = null;
+    this.items = [];
+    this.renderedLineCount = 0;
+  }
+
+  createItem(label, options = {}) {
+    const item = new ProgressItem(this, label, options);
+    this.items.push(item);
+    return item;
+  }
+
+  start() {
+    if (!this.enabled || this.timer) {
+      return;
+    }
+
+    this.timer = setInterval(() => {
+      this.frameIndex = (this.frameIndex + 1) % SPINNER_FRAMES.length;
+      this.render();
+    }, 120);
+  }
+
+  log(message) {
+    if (!this.enabled) {
+      this.stream.write(`${message}\n`);
+      return;
+    }
+
+    this.clearRender();
+    this.stream.write(`${message}\n`);
+    this.render();
+  }
+
+  writeStaticLine(message) {
+    if (!this.enabled) {
+      this.stream.write(`${message}\n`);
+      return;
+    }
+
+    this.clearRender();
+    this.stream.write(`${message}\n`);
+    this.render();
+  }
+
+  render() {
+    if (!this.enabled) {
+      return;
+    }
+
+    const activeItems = this.items.filter((item) => item.active);
+    this.clearRender();
+
+    if (activeItems.length === 0) {
+      this.renderedLineCount = 0;
+      return;
+    }
+
+    const lines = activeItems.map((item) => item.renderLine(this.frameIndex));
+    this.stream.write(lines.join("\n"));
+    this.renderedLineCount = lines.length;
+  }
+
+  clearRender() {
+    if (!this.enabled || this.renderedLineCount === 0) {
+      return;
+    }
+
+    readline.moveCursor(this.stream, 0, -Math.max(this.renderedLineCount - 1, 0));
+
+    for (let index = 0; index < this.renderedLineCount; index += 1) {
+      readline.clearLine(this.stream, 0);
+      readline.cursorTo(this.stream, 0);
+
+      if (index < this.renderedLineCount - 1) {
+        readline.moveCursor(this.stream, 0, 1);
+      }
+    }
+
+    readline.moveCursor(this.stream, 0, -Math.max(this.renderedLineCount - 1, 0));
+    readline.cursorTo(this.stream, 0);
+    this.renderedLineCount = 0;
+  }
+
+  stopIfIdle() {
+    if (this.items.some((item) => item.active)) {
+      return;
+    }
+
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+}

package/src/review-runner.js

@@ -1,6 +1,7 @@
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import { ProgressDisplay } from "./progress-ui.js";
 import { runCommand } from "./shell.js";
 import { resolveRepositoryContext } from "./vcs-client.js";
 
@@ -424,10 +425,12 @@ function buildStateSnapshot(backend, targetInfo, changeId) {
   };
 }
 
-async function reviewChange(config, backend, targetInfo, changeId) {
+async function reviewChange(config, backend, targetInfo, changeId, progress) {
+  progress?.update(0.05, "loading change details");
   const details = await backend.getChangeDetails(config, targetInfo, changeId);
 
   if (details.changedPaths.length === 0) {
+    progress?.update(0.7, "writing skipped report");
     const skippedReport = [
       `# ${backend.displayName} Review Report: ${details.displayId}`,
       "",
@@ -459,6 +462,7 @@ async function reviewChange(config, backend, targetInfo, changeId) {
     };
   }
 
+  progress?.update(0.2, "loading diff");
   const diffText = await backend.getChangeDiff(config, targetInfo, changeId);
   const reviewersToTry = [config.reviewer, ...(config.fallbackReviewers || [])];
 
@@ -470,6 +474,7 @@ async function reviewChange(config, backend, targetInfo, changeId) {
   for (const reviewerName of reviewersToTry) {
     currentReviewerConfig = { ...config, reviewer: reviewerName };
     debugLog(config, `Trying reviewer: ${reviewerName}`);
+    progress?.update(0.45, `running reviewer ${reviewerName}`);
 
     const res = await runReviewerPrompt(
       currentReviewerConfig,
@@ -487,10 +492,11 @@ async function reviewChange(config, backend, targetInfo, changeId) {
     }
 
     if (reviewerName !== reviewersToTry[reviewersToTry.length - 1]) {
-      console.log(`${reviewer.displayName} failed for ${details.displayId}; trying next reviewer...`);
+      progress?.log(`${reviewer.displayName} failed for ${details.displayId}; trying next reviewer...`);
     }
   }
 
+  progress?.update(0.82, "writing report");
   const report = buildReport(currentReviewerConfig, backend, targetInfo, details, diffPayloads, reviewer, reviewerResult);
   const outputFile = path.join(config.outputDir, backend.getReportFileName(changeId));
   const jsonOutputFile = outputFile.replace(/\.md$/i, ".json");
@@ -526,6 +532,15 @@ function formatChangeList(backend, changeIds) {
   return changeIds.map((changeId) => backend.formatChangeId(changeId)).join(", ");
 }
 
+function updateOverallProgress(progress, completedCount, totalCount, currentFraction, stage) {
+  if (!progress || totalCount <= 0) {
+    return;
+  }
+
+  const overallFraction = (completedCount + currentFraction) / totalCount;
+  progress.update(overallFraction, `${completedCount}/${totalCount} completed${stage ? ` | ${stage}` : ""}`);
+}
+
 export async function runReviewCycle(config) {
   await ensureDir(config.outputDir);
 
@@ -576,21 +591,52 @@ export async function runReviewCycle(config) {
   }
 
   console.log(`Reviewing ${backend.displayName} ${backend.changeName}s ${formatChangeList(backend, changeIdsToReview)}`);
+  const progressDisplay = new ProgressDisplay();
+  const overallProgress = progressDisplay.createItem(
+    `${backend.displayName} ${backend.changeName} batch`,
+    { barWidth: 30 }
+  );
+  overallProgress.start("0/" + changeIdsToReview.length + " completed");
 
-  for (const changeId of changeIdsToReview) {
+  for (const [index, changeId] of changeIdsToReview.entries()) {
     debugLog(config, `Starting review for ${backend.formatChangeId(changeId)}.`);
-    const result = await reviewChange(config, backend, targetInfo, changeId);
+    const displayId = backend.formatChangeId(changeId);
+    const progress = progressDisplay.createItem(
+      `${backend.displayName} ${backend.changeName} ${displayId} (${index + 1}/${changeIdsToReview.length})`
+    );
+    progress.start("queued");
+    updateOverallProgress(overallProgress, index, changeIdsToReview.length, 0, `starting ${displayId}`);
+
+    const syncOverallProgress = (fraction, stage) => {
+      progress.update(fraction, stage);
+      updateOverallProgress(overallProgress, index, changeIdsToReview.length, fraction, `${displayId} | ${stage}`);
+    };
+
+    let result;
+
+    try {
+      result = await reviewChange(config, backend, targetInfo, changeId, { update: syncOverallProgress, log: (message) => progress.log(message) });
+      syncOverallProgress(0.94, "saving checkpoint");
+    } catch (error) {
+      progress.fail(`failed at ${displayId}`);
+      overallProgress.fail(`failed at ${displayId} (${index}/${changeIdsToReview.length} completed)`);
+      throw error;
+    }
+
     const outputLabels = [
       result.outputFile ? `md: ${result.outputFile}` : null,
       result.jsonOutputFile ? `json: ${result.jsonOutputFile}` : null
     ].filter(Boolean);
-    console.log(`Reviewed ${backend.formatChangeId(changeId)}: ${outputLabels.join(" | ") || "(no report file generated)"}`);
     const nextProjectState = buildStateSnapshot(backend, targetInfo, changeId);
     await saveState(config.stateFilePath, updateProjectState(stateFile, targetInfo, nextProjectState));
     stateFile.projects[targetInfo.stateKey] = nextProjectState;
     debugLog(config, `Saved checkpoint for ${backend.formatChangeId(changeId)} to ${config.stateFilePath}.`);
+    progress.succeed(`reviewed ${displayId}: ${outputLabels.join(" | ") || "(no report file generated)"}`);
+    updateOverallProgress(overallProgress, index + 1, changeIdsToReview.length, 0, `finished ${displayId}`);
   }
 
+  overallProgress.succeed(`completed ${changeIdsToReview.length}/${changeIdsToReview.length}`);
+
   const remainingChanges = await backend.getPendingChangeIds(
     config,
     targetInfo,