knodin 0.7.6 → 0.8.2

package/dist/src/init-progress.js

@@ -0,0 +1,155 @@
+const HEARTBEAT_MS = 15_000;
+const TTY_THROTTLE_MS = 100;
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const CLEAR_TTY_LINE = "\r\x1b[2K";
+export function normalizeTerminalDimension(value, fallback) {
+    return Number.isFinite(value) && (value ?? 0) > 0 ? Math.floor(value) : fallback;
+}
+function formatCount(value) {
+    return value.toLocaleString();
+}
+function formatBytes(value) {
+    if (value < 1024 * 1024)
+        return `${Math.round(value / 1024)} KB`;
+    return `${(value / (1024 * 1024)).toFixed(1)} MB`;
+}
+function formatDuration(seconds) {
+    if (seconds < 1)
+        return "<1s";
+    if (seconds < 60)
+        return `${Math.ceil(seconds)}s`;
+    return `${Math.floor(seconds / 60)}m ${Math.ceil(seconds % 60)}s`;
+}
+export function formatProgress(event, ratePerSecond, operation = "init") {
+    const model = event.modelFile ? ` (${event.modelFile})` : "";
+    const total = event.phaseTotal;
+    if (total === undefined)
+        return `[${operation}:${event.phase}] ${event.message}${model}`;
+    const counter = event.phase === "embedding-model"
+        ? `${formatBytes(event.phaseCompleted)} / ${formatBytes(total)}`
+        : `${formatCount(event.phaseCompleted)} / ${formatCount(total)}`;
+    const percent = total > 0 ? ` (${Math.floor((event.phaseCompleted / total) * 100)}%)` : "";
+    const eta = ratePerSecond && total > event.phaseCompleted
+        ? ` • ~${formatDuration((total - event.phaseCompleted) / ratePerSecond)} remaining`
+        : "";
+    const rate = ratePerSecond && event.phase !== "embedding-model"
+        ? ` • ${ratePerSecond.toFixed(ratePerSecond >= 10 ? 0 : 1)}/s`
+        : "";
+    return `[${operation}:${event.phase}] ${counter}${percent} ${event.message}${model}${rate}${eta}`;
+}
+/**
+ * Human-only init feedback. It writes to stderr, leaving stdout stable for the
+ * final result, redraws a TTY at most 10 times/sec, and heartbeats a quiet phase.
+ */
+export function createInitProgressRenderer(options) {
+    const operation = options.operation ?? "init";
+    const now = options.now ?? Date.now;
+    const schedule = options.setTimeout ??
+        ((callback, intervalMs) => setTimeout(callback, intervalMs));
+    const unschedule = options.clearTimeout ?? ((handle) => clearTimeout(handle));
+    const tty = options.stderr.isTTY === true;
+    let started = false;
+    let stopped = false;
+    let hasTtyLine = false;
+    let startedAt = 0;
+    let heartbeat;
+    let spinner;
+    let spinnerFrame = 0;
+    let displayLine = `[${operation}:starting] Opening local graph database`;
+    let lastWriteAt = Number.NEGATIVE_INFINITY;
+    let lastPhase = "starting";
+    let lastPercentBucket = -1;
+    let phaseStartedElapsedMs = 0;
+    let phaseStartedCompleted = 0;
+    const scheduleHeartbeat = () => {
+        if (heartbeat !== undefined || stopped)
+            return;
+        heartbeat = schedule(() => {
+            heartbeat = undefined;
+            if (stopped)
+                return;
+            write(`${displayLine} (still working; ${Math.floor((now() - startedAt) / 1000)}s elapsed)`, false);
+            scheduleHeartbeat();
+        }, HEARTBEAT_MS);
+        if (typeof heartbeat === "object" && heartbeat !== null && "unref" in heartbeat) {
+            heartbeat.unref();
+        }
+    };
+    const scheduleSpinner = () => {
+        if (!tty || spinner !== undefined || stopped)
+            return;
+        spinner = schedule(() => {
+            spinner = undefined;
+            if (stopped)
+                return;
+            spinnerFrame = (spinnerFrame + 1) % SPINNER_FRAMES.length;
+            options.stderr.write(`${CLEAR_TTY_LINE}${SPINNER_FRAMES[spinnerFrame]} ${displayLine} (${Math.floor((now() - startedAt) / 1000)}s elapsed)`);
+            hasTtyLine = true;
+            scheduleSpinner();
+        }, TTY_THROTTLE_MS);
+        if (typeof spinner === "object" && spinner !== null && "unref" in spinner) {
+            spinner.unref();
+        }
+    };
+    const write = (line, updateDisplay = true) => {
+        if (updateDisplay)
+            displayLine = line;
+        if (tty) {
+            options.stderr.write(`${CLEAR_TTY_LINE}${SPINNER_FRAMES[spinnerFrame]} ${line} (${Math.floor((now() - startedAt) / 1000)}s elapsed)`);
+            hasTtyLine = true;
+        }
+        else {
+            options.stderr.write(`${line}\n`);
+        }
+        lastWriteAt = now();
+        scheduleHeartbeat();
+    };
+    return {
+        start() {
+            if (started || stopped)
+                return;
+            started = true;
+            startedAt = now();
+            scheduleSpinner();
+            write(displayLine);
+        },
+        onProgress(event) {
+            if (stopped)
+                return;
+            if (!started)
+                this.start();
+            const percentage = event.phaseTotal && event.phaseTotal > 0
+                ? Math.floor((event.phaseCompleted / event.phaseTotal) * 100)
+                : undefined;
+            const bucket = percentage === undefined ? -1 : Math.floor(percentage / 5);
+            const phaseChanged = event.phase !== lastPhase;
+            if (phaseChanged) {
+                phaseStartedElapsedMs = event.elapsedMs;
+                phaseStartedCompleted = event.phaseCompleted;
+            }
+            const phaseElapsedSeconds = Math.max(0, event.elapsedMs - phaseStartedElapsedMs) / 1_000;
+            const ratePerSecond = phaseElapsedSeconds > 0 && event.phaseCompleted > phaseStartedCompleted
+                ? (event.phaseCompleted - phaseStartedCompleted) / phaseElapsedSeconds
+                : undefined;
+            const completed = event.phaseTotal !== undefined && event.phaseCompleted >= event.phaseTotal;
+            if (tty && !phaseChanged && !completed && now() - lastWriteAt < TTY_THROTTLE_MS)
+                return;
+            if (!tty && !phaseChanged && bucket <= lastPercentBucket && !completed)
+                return;
+            write(formatProgress(event, ratePerSecond, operation));
+            lastPhase = event.phase;
+            lastPercentBucket = Math.max(lastPercentBucket, bucket);
+        },
+        stop() {
+            if (stopped)
+                return;
+            stopped = true;
+            if (heartbeat !== undefined)
+                unschedule(heartbeat);
+            if (spinner !== undefined)
+                unschedule(spinner);
+            if (tty && hasTtyLine)
+                options.stderr.write(`${CLEAR_TTY_LINE}\n`);
+        },
+    };
+}