@iletai/nzb 1.7.0 → 1.7.4

package/dist/tui/renderer.js

@@ -0,0 +1,59 @@
+import { C, LABEL_PAD, NZB_LABEL } from "./ansi.js";
+/** Render a single line of markdown to ANSI (used by both streaming and batch). */
+export function renderLine(line, inCodeBlock) {
+    if (inCodeBlock) {
+        return `  ${C.dim("│")} ${line}`;
+    }
+    if (/^[-*_]{3,}\s*$/.test(line))
+        return C.dim("──────────────────────────────────");
+    if (line.startsWith("### "))
+        return C.coral(line.slice(4));
+    if (line.startsWith("## "))
+        return C.boldWhite(line.slice(3));
+    if (line.startsWith("# "))
+        return C.boldWhite(line.slice(2));
+    if (line.startsWith("> "))
+        return `${C.dim("│")} ${C.dim(line.slice(2))}`;
+    if (/^ {2,}[-*] /.test(line))
+        return `    ◦ ${line.replace(/^ +[-*] /, "")}`;
+    if (/^[-*] /.test(line))
+        return `  • ${line.slice(2)}`;
+    if (/^\d+\. /.test(line))
+        return `  ${line}`;
+    return line;
+}
+/** Apply inline formatting (bold, code, links, etc.) to already-rendered text. */
+export function applyInlineFormatting(text) {
+    return text
+        .replace(/\*\*\*(.+?)\*\*\*/g, `\x1b[1;3m$1\x1b[0m`)
+        .replace(/\*\*(.+?)\*\*/g, `\x1b[1m$1\x1b[0m`)
+        .replace(/~~(.+?)~~/g, `\x1b[9m$1\x1b[0m`)
+        .replace(/`([^`]+)`/g, C.yellow("$1"))
+        .replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_m, t, u) => `${t} ${C.dim(`(${u})`)}`);
+}
+/** Render a complete markdown document to ANSI (used for proactive/background messages). */
+export function renderMarkdown(text) {
+    let inCodeBlock = false;
+    const rendered = text.split("\n").map((line) => {
+        if (/^```/.test(line)) {
+            if (inCodeBlock) {
+                inCodeBlock = false;
+                return "";
+            }
+            inCodeBlock = true;
+            const lang = line.slice(3).trim();
+            return lang ? C.dim(lang) : "";
+        }
+        return renderLine(line, inCodeBlock);
+    });
+    return applyInlineFormatting(rendered.join("\n"));
+}
+/** Write a rendered message with a role label (NZB/SYS). */
+export function writeLabeled(role, text) {
+    const label = role === "nzb" ? NZB_LABEL : `  ${C.dim("SYS")}     `;
+    const lines = text.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+        process.stdout.write((i === 0 ? label : LABEL_PAD) + lines[i] + "\n");
+    }
+}
+//# sourceMappingURL=renderer.js.map

package/dist/tui/stream.js

@@ -0,0 +1,163 @@
+import { C, NZB_LABEL, LABEL_PAD } from "./ansi.js";
+import { debugLog, previewForDebug } from "./debug.js";
+import { renderLine, applyInlineFormatting } from "./renderer.js";
+// Shared request context — updated by index.ts before each request
+export const streamContext = {
+    requestId: 0,
+    requestStartedAt: 0,
+};
+// ── Stream buffer state ──────────────────────────────────
+let streamLineBuffer = "";
+let inStreamCodeBlock = false;
+let streamIsFirstLine = true;
+/** Get the prefix for the current stream line (label or padding). */
+function streamPrefix() {
+    return streamIsFirstLine ? NZB_LABEL : LABEL_PAD;
+}
+function stripLeadingStreamNewlines(text) {
+    if (!streamIsFirstLine || streamLineBuffer.length > 0)
+        return text;
+    const stripped = text.replace(/^(?:\r?\n)+/, "");
+    if (stripped.length !== text.length) {
+        debugLog("stream-strip-leading-newlines", {
+            requestId: streamContext.requestId,
+            removedChars: text.length - stripped.length,
+            originalPreview: previewForDebug(text),
+        });
+    }
+    return stripped;
+}
+/** Clear the current visual line (handles terminal wrapping). */
+function clearVisualLine(charCount) {
+    const cols = process.stdout.columns || 80;
+    const up = Math.ceil(Math.max(charCount, 1) / cols) - 1;
+    debugLog("clear-visual-line", { requestId: streamContext.requestId, charCount, cols, up });
+    if (up > 0)
+        process.stdout.write(`\x1b[${up}A`);
+    process.stdout.write(`\r\x1b[J`);
+}
+/** Render a buffered line and write it with the appropriate prefix. */
+function writeRenderedStreamLine(line) {
+    const prefix = streamPrefix();
+    if (/^```/.test(line)) {
+        if (inStreamCodeBlock) {
+            inStreamCodeBlock = false;
+        }
+        else {
+            inStreamCodeBlock = true;
+            const lang = line.slice(3).trim();
+            process.stdout.write(prefix + (lang ? C.dim(lang) : ""));
+        }
+    }
+    else {
+        const rendered = applyInlineFormatting(renderLine(line, inStreamCodeBlock));
+        process.stdout.write(prefix + rendered);
+    }
+    process.stdout.write("\n");
+    streamIsFirstLine = false;
+}
+/** Process a chunk of streaming text, rendering complete lines with labels. */
+export function writeStreamChunk(newText) {
+    debugLog("stream-chunk", {
+        requestId: streamContext.requestId,
+        length: newText.length,
+        preview: previewForDebug(newText),
+        startsWithNewline: /^(?:\r?\n)/.test(newText),
+    });
+    let pos = 0;
+    while (pos < newText.length) {
+        const nl = newText.indexOf("\n", pos);
+        if (nl === -1) {
+            // No newline — buffer and write raw with prefix if at line start
+            const partial = newText.slice(pos);
+            if (streamLineBuffer.length === 0) {
+                process.stdout.write(streamPrefix());
+            }
+            streamLineBuffer += partial;
+            process.stdout.write(partial);
+            return;
+        }
+        // Got a complete line
+        const segment = newText.slice(pos, nl);
+        const hadPartial = streamLineBuffer.length > 0;
+        streamLineBuffer += segment;
+        if (hadPartial) {
+            // Clear the partially-written raw text
+            clearVisualLine(10 + streamLineBuffer.length);
+        }
+        if (streamLineBuffer.length === 0 && !hadPartial) {
+            // Empty line
+            process.stdout.write(streamPrefix() + "\n");
+            streamIsFirstLine = false;
+        }
+        else {
+            writeRenderedStreamLine(streamLineBuffer);
+        }
+        streamLineBuffer = "";
+        pos = nl + 1;
+    }
+}
+/** Normalize streaming text by stripping leading newlines from the first chunk. */
+export function normalizeStreamText(text) {
+    return stripLeadingStreamNewlines(text);
+}
+/** Flush any remaining partial line and reset streaming state. */
+export function flushStreamState() {
+    if (streamLineBuffer.length > 0) {
+        clearVisualLine(10 + streamLineBuffer.length);
+        writeRenderedStreamLine(streamLineBuffer);
+    }
+    streamLineBuffer = "";
+    inStreamCodeBlock = false;
+    streamIsFirstLine = true;
+}
+/** Reset stream buffer state without flushing content. */
+export function resetStreamState() {
+    streamLineBuffer = "";
+    inStreamCodeBlock = false;
+    streamIsFirstLine = true;
+}
+// ── Thinking indicator ────────────────────────────────────
+let thinkingTimer;
+let thinkingFrame = 0;
+let thinkingVisible = false;
+const thinkingFrames = ["Thinking", "Thinking.", "Thinking..", "Thinking..."];
+export function startThinking() {
+    stopThinking("restart-thinking");
+    thinkingFrame = 0;
+    thinkingVisible = true;
+    process.stdout.write(`\n${NZB_LABEL}${C.dim(thinkingFrames[0])}`);
+    debugLog("thinking-start", {
+        requestId: streamContext.requestId,
+        frame: thinkingFrames[0],
+        msSinceSubmit: streamContext.requestStartedAt > 0 ? Date.now() - streamContext.requestStartedAt : null,
+    });
+    thinkingTimer = setInterval(() => {
+        thinkingFrame = (thinkingFrame + 1) % thinkingFrames.length;
+        process.stdout.write(`\r\x1b[K${NZB_LABEL}${C.dim(thinkingFrames[thinkingFrame])}`);
+        debugLog("thinking-tick", {
+            requestId: streamContext.requestId,
+            frameIndex: thinkingFrame,
+            frame: thinkingFrames[thinkingFrame],
+        });
+    }, 400);
+}
+export function stopThinking(reason = "unspecified") {
+    const hadTimer = Boolean(thinkingTimer);
+    const wasVisible = thinkingVisible;
+    if (thinkingTimer) {
+        clearInterval(thinkingTimer);
+        thinkingTimer = undefined;
+    }
+    if (thinkingVisible) {
+        process.stdout.write(`\r\x1b[K`);
+        thinkingVisible = false;
+    }
+    debugLog("thinking-stop", {
+        requestId: streamContext.requestId,
+        reason,
+        hadTimer,
+        wasVisible,
+    });
+}
+//# sourceMappingURL=stream.js.map

package/dist/update.js

@@ -10,6 +10,7 @@ function getPackageJson() {
         return { name: pkg.name || PKG_NAME, version: pkg.version || "0.0.0" };
     }
     catch {
+        // Expected: package.json may not be found in dev/bundled environments
         return { name: PKG_NAME, version: "0.0.0" };
     }
 }
@@ -34,6 +35,7 @@ export async function getLatestVersion() {
         return result || null;
     }
     catch {
+        // Expected: npm registry may be unreachable
         return null;
     }
 }

package/dist/utils.js

@@ -0,0 +1,102 @@
+/**
+ * Shared utility functions for NZB.
+ */
+/** Error thrown when a promise exceeds its timeout. */
+export class TimeoutError extends Error {
+    constructor(ms, label) {
+        const msg = label
+            ? `Operation "${label}" timed out after ${ms}ms`
+            : `Operation timed out after ${ms}ms`;
+        super(msg);
+        this.name = "TimeoutError";
+    }
+}
+/**
+ * Wraps a promise with a timeout. Rejects with `TimeoutError` if the
+ * promise doesn't settle within `ms` milliseconds.
+ */
+export function withTimeout(promise, ms, label) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            reject(new TimeoutError(ms, label));
+        }, ms);
+        promise.then((value) => {
+            clearTimeout(timer);
+            resolve(value);
+        }, (err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+    });
+}
+/**
+ * Returns a human-readable age string from a timestamp.
+ * Examples: "5s", "2m 30s", "1h 5m", "3d 2h"
+ */
+export function formatAge(startedAt) {
+    const totalSeconds = Math.floor((Date.now() - startedAt) / 1000);
+    if (totalSeconds < 0)
+        return "0s";
+    if (totalSeconds < 60)
+        return `${totalSeconds}s`;
+    const days = Math.floor(totalSeconds / 86400);
+    const hours = Math.floor((totalSeconds % 86400) / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = totalSeconds % 60;
+    if (days > 0)
+        return `${days}d ${hours}h`;
+    if (hours > 0)
+        return `${hours}h ${minutes}m`;
+    return `${minutes}m ${seconds}s`;
+}
+/**
+ * Unicode-safe text truncation. Appends "…" if the text was truncated.
+ * Uses `Array.from` to avoid splitting multi-byte characters or emoji.
+ */
+export function truncateText(text, maxLength) {
+    if (maxLength <= 0)
+        return "";
+    if (text.length === 0)
+        return "";
+    const chars = Array.from(text);
+    if (chars.length <= maxLength)
+        return text;
+    return chars.slice(0, maxLength).join("") + "…";
+}
+/**
+ * Simple async mutex. Callers `acquire()` the lock and receive a `release`
+ * function. If the lock is held, callers queue in FIFO order.
+ */
+export function asyncLock() {
+    let locked = false;
+    const queue = [];
+    function acquire() {
+        return new Promise((resolve) => {
+            const run = () => {
+                locked = true;
+                resolve(release);
+            };
+            if (!locked) {
+                run();
+            }
+            else {
+                queue.push(run);
+            }
+        });
+    }
+    function release() {
+        const next = queue.shift();
+        if (next) {
+            next();
+        }
+        else {
+            locked = false;
+        }
+    }
+    return { acquire };
+}
+/** Returns a promise that resolves after `ms` milliseconds. */
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=utils.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@iletai/nzb",
-    "version": "1.7.0",
+    "version": "1.7.4",
     "description": "NZB — a personal AI assistant for developers, built on the GitHub Copilot SDK",
     "bin": {
         "nzb": "dist/cli.js"