aiden-runtime 4.0.1 → 4.1.0

package/dist/cli/v4/replyRenderer.js

@@ -0,0 +1,209 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod). Licensed under AGPL-3.0.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/replyRenderer.ts — Phase v4.1-reply-formatting
+ *
+ * Configures marked-terminal with skin-aware renderers so Aiden's
+ * agent replies render as structured markdown instead of raw walls
+ * of text. Headers, lists, code blocks, blockquotes, inline emphasis,
+ * and links all get terminal-friendly painting.
+ *
+ * The renderer is an instance — `getReplyRenderer().render(text)`
+ * returns the painted string. Used by:
+ *   - `display.markdown(text)` (non-streaming agent reply)
+ *   - `display.streamComplete()` (post-stream re-render, optional)
+ *   - the citation footer composer
+ *
+ * Stable-prefix split for streaming lives in `streamingPrefix.ts`
+ * (pure function over the buffered text); this module is only the
+ * static renderer.
+ *
+ * NO_COLOR honour: the skin engine already returns plain text when
+ * `NO_COLOR` is set, so every paint call gracefully degrades.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getReplyRenderer = getReplyRenderer;
+exports._resetForTests = _resetForTests;
+const marked_1 = require("marked");
+const skinEngine_1 = require("./skinEngine");
+const syntaxHighlight_1 = require("./syntaxHighlight");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const TerminalRenderer = require('marked-terminal').default ?? require('marked-terminal');
+function paint(kind) {
+    return (text) => (0, skinEngine_1.getSkinEngine)().applyColors(text, kind);
+}
+/**
+ * Render a fenced code block: top divider with language label, body
+ * with optional syntax highlighting, bottom divider.
+ *
+ *     ── typescript ─────────────
+ *       const x = 1;
+ *     ──────────────────────────
+ *
+ * Used by the prototype-override path below — marked-terminal's
+ * internal `Renderer.prototype.code` ignores user `opts.code` and
+ * runs its own highlighter, so we override the prototype method
+ * directly. The token-object signature is what marked v15 calls
+ * the renderer with; the older positional path is kept for
+ * compatibility.
+ */
+function renderCodeBlock(code, lang) {
+    const sk = (0, skinEngine_1.getSkinEngine)();
+    const width = Math.min(process.stdout.columns ?? 80, 100) - 4;
+    const langLabel = (lang ?? '').trim();
+    const top = langLabel
+        ? `── ${langLabel} ${'─'.repeat(Math.max(0, width - langLabel.length - 4))}`
+        : '─'.repeat(width);
+    const bot = '─'.repeat(width);
+    const body = (0, syntaxHighlight_1.isSupportedLang)(langLabel)
+        ? (0, syntaxHighlight_1.highlightCode)(code, langLabel)
+        : code;
+    const indented = body.split('\n').map((ln) => `  ${ln}`).join('\n');
+    return [
+        sk.applyColors(top, 'muted'),
+        indented,
+        sk.applyColors(bot, 'muted'),
+        '',
+    ].join('\n') + '\n';
+}
+/**
+ * Render a block quote with a `┃` left rail in muted colour.
+ * Multi-line quotes get the rail on every line.
+ */
+function renderBlockquote(quote) {
+    const rail = paint('muted')('┃ ');
+    return quote
+        .split('\n')
+        .map((ln) => (ln.length === 0 ? rail.trimEnd() : `${rail}${ln}`))
+        .join('\n') + '\n';
+}
+/**
+ * Marked-terminal heading callback gets the rendered heading text +
+ * level. We paint h1 in brand-bold, h2 in brand, h3+ in heading.
+ */
+function renderHeading(text, level, _raw) {
+    if (level <= 1)
+        return paint('brand')(text.toUpperCase()) + '\n\n';
+    if (level === 2)
+        return paint('brand')(text) + '\n\n';
+    return paint('heading')(text) + '\n\n';
+}
+/**
+ * List items get a `▸ ` glyph in muted; numbered lists keep their
+ * numeric prefix (marked-terminal already prepends `N.` for ordered
+ * lists, so we just paint the body).
+ */
+function renderListItem(text) {
+    // marked-terminal feeds us the rendered child text. Strip its
+    // default tab prefix so our two-space indent stays consistent.
+    const body = text.replace(/^\s+/, '');
+    return `  ${paint('muted')('▸')} ${body}\n`;
+}
+/**
+ * Singleton — caching is fine since options bind to the active skin
+ * via paint callbacks (which read getSkinEngine() each call).
+ */
+let cachedRenderer = null;
+function getReplyRenderer() {
+    if (cachedRenderer)
+        return cachedRenderer;
+    // marked-terminal's `opts.<X>` callbacks are invoked with ALREADY-
+    // assembled strings, not raw token data — they're meant for ANSI
+    // wrapping, not structural override. So `opts.code` for example is
+    // never actually called for fenced blocks: marked-terminal's
+    // prototype.code runs its own internal highlighter and skips opts.
+    // To emit our structured code blocks (top divider + lang label +
+    // syntax highlight + bottom divider) we override the prototype
+    // method directly below.
+    const opts = {
+        blockquote: renderBlockquote,
+        heading: renderHeading,
+        firstHeading: (text, _level, _raw) => paint('brand')(text.toUpperCase()) + '\n\n',
+        hr: () => paint('muted')('─'.repeat(Math.min(process.stdout.columns ?? 80, 100) - 4)) + '\n',
+        listitem: renderListItem,
+        paragraph: (text) => `${text}\n\n`,
+        strong: paint('brand'),
+        em: paint('muted'),
+        codespan: (text) => paint('accent')(`\`${text}\``),
+        del: paint('muted'),
+        // marked-terminal calls opts.link with the ASSEMBLED visual
+        // (already OSC8-wrapped when the host terminal supports it),
+        // so we just paint it.
+        link: (assembled) => paint('accent')(assembled),
+        href: paint('accent'),
+        text: (text) => text,
+        width: Math.min(process.stdout.columns ?? 80, 100),
+        showSectionPrefix: false,
+        reflowText: false,
+        tab: 2,
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const renderer = new TerminalRenderer(opts);
+    // Override the prototype `code` method on this instance so we get
+    // structured code blocks (divider + lang label + syntax highlight
+    // + divider) instead of marked-terminal's plain yellow-highlighted
+    // output. Token-object signature handles marked v15.
+    renderer.code = function (code, lang, _escaped) {
+        let text;
+        let langOut;
+        if (typeof code === 'object' && code !== null) {
+            // marked v15 passes a token object: { text, lang, escaped }.
+            const tok = code;
+            text = tok.text ?? '';
+            langOut = tok.lang;
+        }
+        else {
+            text = String(code ?? '');
+            langOut = lang;
+        }
+        return renderCodeBlock(text, langOut);
+    };
+    // Override `link` to ALWAYS emit OSC8 hyperlinks (marked-terminal's
+    // default uses `supports-hyperlinks` which returns false on piped
+    // stdout — but Aiden's REPL targets modern terminals that support
+    // OSC8 universally). Visible label gets accent paint; href is the
+    // OSC8 target. Token-object signature handles marked v15.
+    renderer.link = function (href, _title, text) {
+        let url;
+        let label;
+        if (typeof href === 'object' && href !== null) {
+            const tok = href;
+            url = tok.href ?? '';
+            label = this
+                .parser?.parseInline?.(tok.tokens ?? []) ?? '';
+        }
+        else {
+            url = String(href ?? '');
+            label = String(text ?? url);
+        }
+        if (!label)
+            label = url;
+        const painted = paint('accent')(label);
+        return `\x1b]8;;${url}\x1b\\${painted}\x1b]8;;\x1b\\`;
+    };
+    cachedRenderer = {
+        render(text) {
+            try {
+                // Bind the renderer globally before each parse — marked v15
+                // applies the renderer at parse time, so re-setting before
+                // each call is safe and ensures our custom options win even
+                // if other code transiently swaps the renderer.
+                marked_1.marked.setOptions({ renderer: renderer });
+                const out = marked_1.marked.parse(text);
+                return typeof out === 'string' ? out : String(out);
+            }
+            catch {
+                return text;
+            }
+        },
+    };
+    return cachedRenderer;
+}
+/** Test reset — drops the cached renderer so a skin change picks up. */
+function _resetForTests() {
+    cachedRenderer = null;
+}

package/dist/cli/v4/resizeGuard.js

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/resizeGuard.ts — Phase v4.1-tier3-essentials
+ *
+ * Hard-clear the terminal on `process.stdout` resize so dropdown
+ * re-renders, prompt frames, and dirty escape state from before the
+ * resize don't ghost into the new viewport.
+ *
+ * The clear is a single `\x1b[2J\x1b[H` (erase display + cursor home);
+ * every mainstream emulator honours it. A virtualised transcript could
+ * do this more surgically via React state, but we don't have one yet,
+ * so the brute-force clear is the right minimum for v4.1.
+ *
+ * Skipped in non-TTY (`process.stdout.isTTY` falsy) and in MCP serve
+ * mode (`isMcpServeMode()` true). 100ms debounce so a continuous
+ * resize drag doesn't issue dozens of clears.
+ *
+ * `installResizeGuard()` returns a teardown function. Idempotent.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HARD_CLEAR_SEQUENCE = void 0;
+exports.installResizeGuard = installResizeGuard;
+exports._resetForTests = _resetForTests;
+const uiBuild_1 = require("./uiBuild");
+/** Single ANSI sequence: `ED 2` (erase display) + `CUP` (cursor home). */
+const HARD_CLEAR = '\x1b[2J\x1b[H';
+const DEFAULT_DEBOUNCE_MS = 100;
+let installed = null;
+/**
+ * Install a 'resize' listener on `process.stdout`. No-op when stdout
+ * is non-TTY or MCP serve mode is active. Idempotent — calling twice
+ * returns the same teardown.
+ */
+function installResizeGuard(opts = {}) {
+    if (installed)
+        return installed.uninstall;
+    const out = opts.out ?? process.stdout;
+    if (!out || !out.isTTY) {
+        const noop = () => { };
+        installed = { uninstall: noop };
+        return noop;
+    }
+    if ((0, uiBuild_1.isMcpServeMode)()) {
+        const noop = () => { };
+        installed = { uninstall: noop };
+        return noop;
+    }
+    const debounceMs = opts.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+    let pending = null;
+    const onResize = () => {
+        if (pending)
+            clearTimeout(pending);
+        pending = setTimeout(() => {
+            pending = null;
+            try {
+                out.write(HARD_CLEAR);
+            }
+            catch { /* defensive */ }
+            try {
+                opts.onCleared?.();
+            }
+            catch { /* re-render must not crash the listener */ }
+        }, debounceMs);
+    };
+    out.on('resize', onResize);
+    const uninstall = () => {
+        if (!installed)
+            return;
+        out.removeListener('resize', onResize);
+        if (pending) {
+            clearTimeout(pending);
+            pending = null;
+        }
+        installed = null;
+    };
+    installed = { uninstall };
+    return uninstall;
+}
+/** Test helper: drop install state. */
+function _resetForTests() {
+    if (installed)
+        installed.uninstall();
+    installed = null;
+}
+/** Constant exposed for smokes — they assert we emit this exact bytes. */
+exports.HARD_CLEAR_SEQUENCE = HARD_CLEAR;