@robin7331/papyrus-cli 0.1.10 → 0.1.11

package/dist/cli.js

@@ -6,7 +6,7 @@ import { dirname, join, relative, resolve } from "node:path";
 import { Command } from "commander";
 import { clearStoredApiKey, getConfigFilePath, getStoredApiKey, maskApiKey, setStoredApiKey } from "./config.js";
 import { assertModelAvailable, convertPdf, listAvailableModels, UnknownModelError } from "./openaiPdfToMarkdown.js";
-import { defaultOutputPath, formatDurationMs, isPdfPath, looksLikeFileOutput, parseConcurrency, parseFormat, resolveFolderOutputPath, truncate, validateOptionCombination } from "./cliHelpers.js";
+import { defaultOutputPath, formatDurationMs, getSpinnerFrame, isPdfPath, looksLikeFileOutput, parseConcurrency, parseFormat, resolveFolderOutputPath, truncate, validateOptionCombination } from "./cliHelpers.js";
 const program = new Command();
 const configFilePath = getConfigFilePath();
 const OPENAI_API_KEYS_URL = "https://platform.openai.com/settings/organization/api-keys";
@@ -446,17 +446,20 @@ async function runWithConcurrency(items, concurrency, worker) {
     await Promise.all(workers);
 }
 class AsciiWorkerDashboard {
+    static spinnerIntervalMs = 80;
     lanes;
     total;
     workerCount;
     completed = 0;
     failed = 0;
     renderedLineCount = 0;
+    spinnerTimer;
     constructor(total, workerCount) {
         this.total = total;
         this.workerCount = workerCount;
         this.lanes = Array.from({ length: workerCount }, () => ({
-            state: "idle"
+            state: "idle",
+            spinnerFrame: 0
         }));
         process.stdout.write("\x1b[?25l");
         this.render();
@@ -474,6 +477,8 @@ class AsciiWorkerDashboard {
         lane.state = "running";
         lane.file = file;
         lane.message = "processing...";
+        lane.spinnerFrame = 0;
+        this.syncSpinnerTimer();
         this.render();
     }
     setWorkerDone(workerId, file, message) {
@@ -484,6 +489,8 @@ class AsciiWorkerDashboard {
         lane.state = "done";
         lane.file = file;
         lane.message = message;
+        lane.spinnerFrame = 0;
+        this.syncSpinnerTimer();
         this.render();
     }
     setWorkerFailed(workerId, file, message) {
@@ -494,9 +501,12 @@ class AsciiWorkerDashboard {
         lane.state = "failed";
         lane.file = file;
         lane.message = message;
+        lane.spinnerFrame = 0;
+        this.syncSpinnerTimer();
         this.render();
     }
     stop() {
+        this.clearSpinnerTimer();
         this.render();
         process.stdout.write("\x1b[?25h");
     }
@@ -527,7 +537,7 @@ class AsciiWorkerDashboard {
     }
     renderIcon(lane) {
         if (lane.state === "running") {
-            return ">>";
+            return `${getSpinnerFrame(lane.spinnerFrame)} `;
         }
         if (lane.state === "done") {
             return "OK";
@@ -537,6 +547,41 @@ class AsciiWorkerDashboard {
         }
         return "..";
     }
+    syncSpinnerTimer() {
+        if (this.lanes.some((lane) => lane.state === "running")) {
+            this.ensureSpinnerTimer();
+            return;
+        }
+        this.clearSpinnerTimer();
+    }
+    ensureSpinnerTimer() {
+        if (this.spinnerTimer) {
+            return;
+        }
+        this.spinnerTimer = setInterval(() => {
+            let hasRunningLane = false;
+            for (const lane of this.lanes) {
+                if (lane.state !== "running") {
+                    continue;
+                }
+                lane.spinnerFrame += 1;
+                hasRunningLane = true;
+            }
+            if (!hasRunningLane) {
+                this.clearSpinnerTimer();
+                return;
+            }
+            this.render();
+        }, AsciiWorkerDashboard.spinnerIntervalMs);
+        this.spinnerTimer.unref?.();
+    }
+    clearSpinnerTimer() {
+        if (!this.spinnerTimer) {
+            return;
+        }
+        clearInterval(this.spinnerTimer);
+        this.spinnerTimer = undefined;
+    }
 }
 async function confirmFolderProcessing(totalFiles, concurrency, skipPrompt) {
     if (skipPrompt) {

package/dist/cliHelpers.d.ts

@@ -17,4 +17,6 @@ export declare function resolveFolderOutputPath(inputPath: string, inputRoot: st
 export declare function isPdfPath(inputPath: string): boolean;
 export declare function looksLikeFileOutput(outputPath: string): boolean;
 export declare function truncate(value: string, maxLength: number): string;
+export declare const ASCII_SPINNER_FRAMES: string[];
+export declare function getSpinnerFrame(frameIndex: number): string;
 export declare function formatDurationMs(durationMs: number): string;

package/dist/cliHelpers.js

@@ -63,6 +63,12 @@ export function truncate(value, maxLength) {
     }
     return `${value.slice(0, maxLength - 3)}...`;
 }
+export const ASCII_SPINNER_FRAMES = ["|", "/", "-", "\\"];
+export function getSpinnerFrame(frameIndex) {
+    const normalizedIndex = ((Math.trunc(frameIndex) % ASCII_SPINNER_FRAMES.length) + ASCII_SPINNER_FRAMES.length)
+        % ASCII_SPINNER_FRAMES.length;
+    return ASCII_SPINNER_FRAMES[normalizedIndex] ?? ASCII_SPINNER_FRAMES[0];
+}
 export function formatDurationMs(durationMs) {
     return `${(durationMs / 1000).toFixed(2)}s`;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robin7331/papyrus-cli",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "private": false,
   "description": "Convert PDF to markdown or text with the OpenAI Agents SDK",
   "repository": {
@@ -37,7 +37,6 @@
   },
   "dependencies": {
     "@openai/agents": "^0.5.3",
-    "@robin7331/papyrus-cli": "^0.1.4",
     "commander": "^14.0.0",
     "dotenv": "^17.3.1",
     "openai": "^6.7.0",

package/src/cli.ts

@@ -23,6 +23,7 @@ import {
 import {
   defaultOutputPath,
   formatDurationMs,
+  getSpinnerFrame,
   isPdfPath,
   looksLikeFileOutput,
   parseConcurrency,
@@ -605,21 +606,25 @@ type WorkerLane = {
   state: "idle" | "running" | "done" | "failed";
   file?: string;
   message?: string;
+  spinnerFrame: number;
 };
 
 class AsciiWorkerDashboard {
+  private static readonly spinnerIntervalMs = 80;
   private readonly lanes: WorkerLane[];
   private readonly total: number;
   private readonly workerCount: number;
   private completed = 0;
   private failed = 0;
   private renderedLineCount = 0;
+  private spinnerTimer?: NodeJS.Timeout;
 
   constructor(total: number, workerCount: number) {
     this.total = total;
     this.workerCount = workerCount;
     this.lanes = Array.from({ length: workerCount }, () => ({
-      state: "idle"
+      state: "idle",
+      spinnerFrame: 0
     }));
 
     process.stdout.write("\x1b[?25l");
@@ -641,6 +646,8 @@ class AsciiWorkerDashboard {
     lane.state = "running";
     lane.file = file;
     lane.message = "processing...";
+    lane.spinnerFrame = 0;
+    this.syncSpinnerTimer();
     this.render();
   }
 
@@ -653,6 +660,8 @@ class AsciiWorkerDashboard {
     lane.state = "done";
     lane.file = file;
     lane.message = message;
+    lane.spinnerFrame = 0;
+    this.syncSpinnerTimer();
     this.render();
   }
 
@@ -665,10 +674,13 @@ class AsciiWorkerDashboard {
     lane.state = "failed";
     lane.file = file;
     lane.message = message;
+    lane.spinnerFrame = 0;
+    this.syncSpinnerTimer();
     this.render();
   }
 
   stop(): void {
+    this.clearSpinnerTimer();
     this.render();
     process.stdout.write("\x1b[?25h");
   }
@@ -706,7 +718,7 @@ class AsciiWorkerDashboard {
 
   private renderIcon(lane: WorkerLane): string {
     if (lane.state === "running") {
-      return ">>";
+      return `${getSpinnerFrame(lane.spinnerFrame)} `;
     }
 
     if (lane.state === "done") {
@@ -719,6 +731,50 @@ class AsciiWorkerDashboard {
 
     return "..";
   }
+
+  private syncSpinnerTimer(): void {
+    if (this.lanes.some((lane) => lane.state === "running")) {
+      this.ensureSpinnerTimer();
+      return;
+    }
+
+    this.clearSpinnerTimer();
+  }
+
+  private ensureSpinnerTimer(): void {
+    if (this.spinnerTimer) {
+      return;
+    }
+
+    this.spinnerTimer = setInterval(() => {
+      let hasRunningLane = false;
+      for (const lane of this.lanes) {
+        if (lane.state !== "running") {
+          continue;
+        }
+
+        lane.spinnerFrame += 1;
+        hasRunningLane = true;
+      }
+
+      if (!hasRunningLane) {
+        this.clearSpinnerTimer();
+        return;
+      }
+
+      this.render();
+    }, AsciiWorkerDashboard.spinnerIntervalMs);
+    this.spinnerTimer.unref?.();
+  }
+
+  private clearSpinnerTimer(): void {
+    if (!this.spinnerTimer) {
+      return;
+    }
+
+    clearInterval(this.spinnerTimer);
+    this.spinnerTimer = undefined;
+  }
 }
 
 async function confirmFolderProcessing(

package/src/cliHelpers.ts

@@ -100,6 +100,14 @@ export function truncate(value: string, maxLength: number): string {
   return `${value.slice(0, maxLength - 3)}...`;
 }
 
+export const ASCII_SPINNER_FRAMES = ["|", "/", "-", "\\"];
+
+export function getSpinnerFrame(frameIndex: number): string {
+  const normalizedIndex = ((Math.trunc(frameIndex) % ASCII_SPINNER_FRAMES.length) + ASCII_SPINNER_FRAMES.length)
+    % ASCII_SPINNER_FRAMES.length;
+  return ASCII_SPINNER_FRAMES[normalizedIndex] ?? ASCII_SPINNER_FRAMES[0];
+}
+
 export function formatDurationMs(durationMs: number): string {
   return `${(durationMs / 1000).toFixed(2)}s`;
 }

package/test/cliHelpers.test.ts

@@ -2,8 +2,10 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import { InvalidArgumentError } from "commander";
 import {
+  ASCII_SPINNER_FRAMES,
   defaultOutputPath,
   formatDurationMs,
+  getSpinnerFrame,
   isPdfPath,
   looksLikeFileOutput,
   parseConcurrency,
@@ -130,6 +132,15 @@ test("truncate shortens long values and preserves short ones", () => {
   assert.equal(truncate("abcdefghij", 8), "abcde...");
 });
 
+test("getSpinnerFrame cycles through the configured ASCII frames", () => {
+  assert.deepEqual(
+    ASCII_SPINNER_FRAMES.map((_, index) => getSpinnerFrame(index)),
+    ASCII_SPINNER_FRAMES
+  );
+  assert.equal(getSpinnerFrame(ASCII_SPINNER_FRAMES.length), ASCII_SPINNER_FRAMES[0]);
+  assert.equal(getSpinnerFrame(-1), ASCII_SPINNER_FRAMES.at(-1));
+});
+
 test("formatDurationMs formats to seconds with two decimals", () => {
   assert.equal(formatDurationMs(0), "0.00s");
   assert.equal(formatDurationMs(1543), "1.54s");