kodevu 0.1.16 → 0.1.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kodevu",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "type": "module",
   "description": "Poll SVN revisions or Git commits, send each change diff to a reviewer CLI, and write configurable review reports.",
   "bin": {

package/src/progress-ui.js

@@ -1,7 +1,7 @@
 import readline from "node:readline";
 
 const SPINNER_FRAMES = ["|", "/", "-", "\\"];
-const DEFAULT_BAR_WIDTH = 24;
+const ELLIPSIS = "...";
 
 function clampProgress(value) {
   if (!Number.isFinite(value)) {
@@ -11,19 +11,45 @@ function clampProgress(value) {
   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);
+function getCharacterWidth(character) {
+  const codePoint = character.codePointAt(0);
 
-  if (filled >= width) {
-    return `[${"=".repeat(width)}]`;
+  if (!codePoint || codePoint <= 0x1f || (codePoint >= 0x7f && codePoint <= 0x9f)) {
+    return 0;
+  }
+
+  if (
+    codePoint >= 0x1100 &&
+    (
+      codePoint <= 0x115f ||
+      codePoint === 0x2329 ||
+      codePoint === 0x232a ||
+      (codePoint >= 0x2e80 && codePoint <= 0xa4cf && codePoint !== 0x303f) ||
+      (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
+      (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
+      (codePoint >= 0xfe10 && codePoint <= 0xfe19) ||
+      (codePoint >= 0xfe30 && codePoint <= 0xfe6f) ||
+      (codePoint >= 0xff00 && codePoint <= 0xff60) ||
+      (codePoint >= 0xffe0 && codePoint <= 0xffe6) ||
+      (codePoint >= 0x1f300 && codePoint <= 0x1f64f) ||
+      (codePoint >= 0x1f900 && codePoint <= 0x1f9ff) ||
+      (codePoint >= 0x20000 && codePoint <= 0x3fffd)
+    )
+  ) {
+    return 2;
   }
 
-  if (filled === 0) {
-    return `[${" ".repeat(width)}]`;
+  return 1;
+}
+
+function getDisplayWidth(text) {
+  let width = 0;
+
+  for (const character of text) {
+    width += getCharacterWidth(character);
   }
 
-  return `[${"=".repeat(Math.max(filled - 1, 0))}>${" ".repeat(width - filled)}]`;
+  return width;
 }
 
 function truncateLine(line, maxWidth) {
@@ -31,7 +57,7 @@ function truncateLine(line, maxWidth) {
     return "";
   }
 
-  if (line.length <= maxWidth) {
+  if (getDisplayWidth(line) <= maxWidth) {
     return line;
   }
 
@@ -39,14 +65,28 @@ function truncateLine(line, maxWidth) {
     return ".".repeat(maxWidth);
   }
 
-  return `${line.slice(0, maxWidth - 3)}...`;
+  const targetWidth = maxWidth - getDisplayWidth(ELLIPSIS);
+  let result = "";
+  let width = 0;
+
+  for (const character of line) {
+    const nextWidth = width + getCharacterWidth(character);
+
+    if (nextWidth > targetWidth) {
+      break;
+    }
+
+    result += character;
+    width = nextWidth;
+  }
+
+  return `${result}${ELLIPSIS}`;
 }
 
 class ProgressItem {
-  constructor(display, label, options = {}) {
+  constructor(display, label) {
     this.display = display;
     this.label = label;
-    this.barWidth = options.barWidth || DEFAULT_BAR_WIDTH;
     this.progress = 0;
     this.stage = "";
     this.active = false;
@@ -54,8 +94,8 @@ class ProgressItem {
   }
 
   start(stage = "starting") {
-    this.stage = stage;
     this.active = true;
+    this.stage = stage;
 
     if (!this.display.enabled) {
       this.writeFallback(`... ${this.label}: ${stage}`);
@@ -63,7 +103,7 @@ class ProgressItem {
     }
 
     this.display.start();
-    this.display.render();
+    this.display.activate(this);
   }
 
   update(progress, stage) {
@@ -78,7 +118,7 @@ class ProgressItem {
       return;
     }
 
-    this.display.render();
+    this.display.activate(this);
   }
 
   log(message) {
@@ -96,46 +136,23 @@ class ProgressItem {
   finish(prefix, progress, message) {
     this.progress = clampProgress(progress);
     this.active = false;
-    this.display.stopIfIdle();
-    this.display.writeStaticLine(this.buildLine(prefix, message));
+    this.display.deactivate(this);
+    this.display.writeStaticLine(this.buildFinalLine(prefix, message));
   }
 
   renderLine(frameIndex) {
-    const spinner = SPINNER_FRAMES[frameIndex];
-    return this.buildLine(spinner, this.stage);
+    return this.buildStatusLine(SPINNER_FRAMES[frameIndex], this.stage);
   }
 
-  buildLine(prefix, suffix) {
+  buildFinalLine(prefix, message) {
+    return this.buildStatusLine(prefix, message);
+  }
+
+  buildStatusLine(prefix, suffix) {
     const availableWidth = this.display.getAvailableWidth();
     const pct = `${Math.round(this.progress * 100)}`.padStart(3, " ");
-    const parts = [prefix, this.label];
-    const suffixText = suffix ? ` ${suffix}` : "";
-
-    if (availableWidth < 10) {
-      return truncateLine(`${prefix} ${pct}%`, availableWidth);
-    }
-
-    const fullReservedWidth = prefix.length + this.label.length + pct.length + suffixText.length + 4;
-    const fullBarWidth = availableWidth - fullReservedWidth;
-
-    if (fullBarWidth >= 4) {
-      return truncateLine(
-        `${parts.join(" ")} ${buildBar(this.progress, Math.min(this.barWidth, fullBarWidth))} ${pct}%${suffixText}`,
-        availableWidth
-      );
-    }
-
-    const compactReservedWidth = prefix.length + pct.length + suffixText.length + 4;
-    const compactBarWidth = availableWidth - compactReservedWidth;
-
-    if (compactBarWidth >= 4) {
-      return truncateLine(
-        `${prefix} ${buildBar(this.progress, compactBarWidth)} ${pct}%${suffixText}`,
-        availableWidth
-      );
-    }
-
-    return truncateLine(`${prefix} ${pct}%${suffixText}`, availableWidth);
+    const suffixText = suffix ? ` | ${suffix}` : "";
+    return truncateLine(`${prefix} ${pct}% ${this.label}${suffixText}`, availableWidth);
   }
 
   writeFallback(line) {
@@ -155,12 +172,15 @@ export class ProgressDisplay {
     this.frameIndex = 0;
     this.timer = null;
     this.items = [];
-    this.renderedLineCount = 0;
+    this.currentItem = null;
+    this.statusVisible = false;
+    this.lastStatusWidth = 0;
+    this.resizeAttached = false;
     this.handleResize = this.handleResize.bind(this);
   }
 
-  createItem(label, options = {}) {
-    const item = new ProgressItem(this, label, options);
+  createItem(label) {
+    const item = new ProgressItem(this, label);
     this.items.push(item);
     return item;
   }
@@ -171,21 +191,38 @@ export class ProgressDisplay {
     }
 
     this.attachResizeHandler();
-
     this.timer = setInterval(() => {
       this.frameIndex = (this.frameIndex + 1) % SPINNER_FRAMES.length;
       this.render();
     }, 120);
   }
 
+  activate(item) {
+    this.currentItem = item;
+    this.render();
+  }
+
+  deactivate(item) {
+    if (this.currentItem === item) {
+      this.currentItem = this.items.findLast((candidate) => candidate.active) || null;
+    }
+
+    this.stopIfIdle();
+    this.clearStatusLine();
+
+    if (this.currentItem) {
+      this.render();
+    }
+  }
+
   log(message) {
     if (!this.enabled) {
       this.stream.write(`${message}\n`);
       return;
     }
 
-    this.clearRender();
-    this.stream.write(`${message}\n`);
+    this.clearStatusLine();
+    this.stream.write(`${truncateLine(message, this.getAvailableWidth())}\n`);
     this.render();
   }
 
@@ -195,48 +232,45 @@ export class ProgressDisplay {
       return;
     }
 
-    this.clearRender();
+    this.clearStatusLine();
     this.stream.write(`${truncateLine(message, this.getAvailableWidth())}\n`);
     this.render();
   }
 
   render() {
-    if (!this.enabled) {
+    if (!this.enabled || !this.currentItem?.active) {
       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;
+    this.clearStatusLine();
+    const line = this.currentItem.renderLine(this.frameIndex);
+    this.stream.write(line);
+    this.statusVisible = true;
+    this.lastStatusWidth = getDisplayWidth(line);
   }
 
-  clearRender() {
-    if (!this.enabled || this.renderedLineCount === 0) {
+  clearStatusLine() {
+    if (!this.enabled || !this.statusVisible) {
       return;
     }
 
-    readline.moveCursor(this.stream, 0, -Math.max(this.renderedLineCount - 1, 0));
+    const rows = Math.max(1, Math.ceil(this.lastStatusWidth / Math.max(this.stream.columns || 1, 1)));
+
+    readline.moveCursor(this.stream, 0, -Math.max(rows - 1, 0));
 
-    for (let index = 0; index < this.renderedLineCount; index += 1) {
+    for (let index = 0; index < rows; index += 1) {
       readline.clearLine(this.stream, 0);
       readline.cursorTo(this.stream, 0);
 
-      if (index < this.renderedLineCount - 1) {
+      if (index < rows - 1) {
         readline.moveCursor(this.stream, 0, 1);
       }
     }
 
-    readline.moveCursor(this.stream, 0, -Math.max(this.renderedLineCount - 1, 0));
+    readline.moveCursor(this.stream, 0, -Math.max(rows - 1, 0));
     readline.cursorTo(this.stream, 0);
-    this.renderedLineCount = 0;
+    this.statusVisible = false;
+    this.lastStatusWidth = 0;
   }
 
   stopIfIdle() {

package/src/review-runner.js

@@ -592,24 +592,16 @@ 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");
+  const progress = progressDisplay.createItem(`${backend.displayName} ${backend.changeName} batch`);
+  progress.start("0/" + changeIdsToReview.length + " completed");
 
   for (const [index, changeId] of changeIdsToReview.entries()) {
     debugLog(config, `Starting review for ${backend.formatChangeId(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}`);
+    updateOverallProgress(progress, index, changeIdsToReview.length, 0, `starting ${displayId}`);
 
     const syncOverallProgress = (fraction, stage) => {
-      progress.update(fraction, stage);
-      updateOverallProgress(overallProgress, index, changeIdsToReview.length, fraction, `${displayId} | ${stage}`);
+      updateOverallProgress(progress, index, changeIdsToReview.length, fraction, `${displayId} | ${stage}`);
     };
 
     let result;
@@ -618,8 +610,7 @@ export async function runReviewCycle(config) {
       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)`);
+      progress.fail(`failed at ${displayId} (${index}/${changeIdsToReview.length} completed)`);
       throw error;
     }
 
@@ -631,11 +622,11 @@ export async function runReviewCycle(config) {
     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}`);
+    progress.log(`[done] reviewed ${displayId}: ${outputLabels.join(" | ") || "(no report file generated)"}`);
+    updateOverallProgress(progress, index + 1, changeIdsToReview.length, 0, `finished ${displayId}`);
   }
 
-  overallProgress.succeed(`completed ${changeIdsToReview.length}/${changeIdsToReview.length}`);
+  progress.succeed(`completed ${changeIdsToReview.length}/${changeIdsToReview.length}`);
 
   const remainingChanges = await backend.getPendingChangeIds(
     config,