aiden-runtime 4.0.2 → 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;

package/dist/cli/v4/shellInterpolation.js

@@ -0,0 +1,139 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/shellInterpolation.ts — Phase v4.1-tier3-essentials
+ *
+ * Inline shell expansion. When a user prompt contains one or more
+ * `{!cmd}` spans, we run each command, splice the output back in,
+ * and submit the rewritten prompt to the agent.
+ *
+ * Rules:
+ *   - Each `{!cmd}` runs via `child_process.exec` with a 5s wallclock
+ *     timeout (kill on overrun).
+ *   - Output is stdout (or stderr if stdout empty), trimmed, capped
+ *     at 500 visible chars. Multi-line output is collapsed to the
+ *     first 500 chars verbatim — newlines preserved.
+ *   - On non-zero exit / timeout / spawn failure, the span is
+ *     replaced with `[shell:error]` so the rest of the prompt still
+ *     submits.
+ *   - Every span runs in parallel; total wait bounded by the slowest
+ *     single command.
+ *
+ * MCP serve mode never reaches this path (REPL doesn't run there).
+ *
+ * Security: this expands BEFORE the agent loop, so the same
+ * `approvalEngine` gate the user has on the in-agent `shell_exec`
+ * tool does NOT apply here. To prevent an unattended REPL from
+ * exfiltrating arbitrary command output, callers SHOULD only invoke
+ * this on user-typed prompts (never on tool-emitted text). chatSession
+ * applies it to `readUserInput`'s return value, which is exactly that.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INTERPOLATION_RE = void 0;
+exports.hasInterpolation = hasInterpolation;
+exports.expand = expand;
+exports.countSpans = countSpans;
+const node_child_process_1 = require("node:child_process");
+/** Matches `{!cmd}` spans non-greedily so `{!a} {!b}` produces two matches. */
+exports.INTERPOLATION_RE = /\{!(.+?)\}/g;
+/** Truthy check used by callers that want to skip the work entirely. */
+function hasInterpolation(text) {
+    return /\{![^}]+\}/.test(text);
+}
+/** Default output cap (visible chars per span). */
+const OUTPUT_CAP = 500;
+/** Default wallclock timeout per span (ms). */
+const TIMEOUT_MS = 5000;
+/**
+ * Run a single `cmd` and return the trimmed output (or `[shell:error]`).
+ * Always resolves; never rejects.
+ */
+async function runOne(cmd, opts) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const child = (0, node_child_process_1.exec)(cmd, { timeout: opts.timeoutMs, windowsHide: true }, (err, stdout, stderr) => {
+            if (settled)
+                return;
+            settled = true;
+            if (err) {
+                // exec sets err.killed=true on timeout. Either way:
+                // surface a marker rather than a partial command output.
+                resolve('[shell:error]');
+                return;
+            }
+            const out = (stdout && stdout.length > 0 ? stdout : stderr ?? '').trim();
+            if (out.length === 0) {
+                resolve('');
+                return;
+            }
+            if (out.length <= opts.outputCap) {
+                resolve(out);
+            }
+            else {
+                resolve(out.slice(0, opts.outputCap) + '…');
+            }
+        });
+        // Defensive: kill on timeout in case `exec`'s built-in timeout
+        // misses the window (Windows shell quirks). The exec callback
+        // above will still fire.
+        setTimeout(() => {
+            if (!settled) {
+                try {
+                    child.kill('SIGKILL');
+                }
+                catch { /* */ }
+            }
+        }, opts.timeoutMs + 500);
+    });
+}
+/**
+ * Expand every `{!cmd}` in `text`, returning the rewritten string.
+ * If `text` contains no spans, returned verbatim with no work done.
+ */
+async function expand(text, optsIn = {}) {
+    if (!hasInterpolation(text))
+        return text;
+    const opts = {
+        timeoutMs: optsIn.timeoutMs ?? TIMEOUT_MS,
+        outputCap: optsIn.outputCap ?? OUTPUT_CAP,
+    };
+    // Collect all matches up front so we can splice in order.
+    const matches = [];
+    for (const m of text.matchAll(exports.INTERPOLATION_RE)) {
+        if (m.index === undefined)
+            continue;
+        matches.push({
+            start: m.index,
+            end: m.index + m[0].length,
+            cmd: (m[1] ?? '').trim(),
+        });
+    }
+    // Run all spans in parallel.
+    const replacements = await Promise.all(matches.map(async (m) => ({
+        start: m.start,
+        end: m.end,
+        text: m.cmd.length > 0 ? await runOne(m.cmd, opts) : '',
+    })));
+    // Splice from right-to-left so earlier spans' positions stay valid.
+    let out = text;
+    for (let i = replacements.length - 1; i >= 0; i -= 1) {
+        const r = replacements[i];
+        out = out.slice(0, r.start) + r.text + out.slice(r.end);
+    }
+    return out;
+}
+/**
+ * Cheap surface count for the pre-submit "[shell] running N
+ * interpolations…" status line.
+ */
+function countSpans(text) {
+    let n = 0;
+    for (const _ of text.matchAll(exports.INTERPOLATION_RE))
+        n += 1;
+    return n;
+}

package/dist/cli/v4/skinEngine.js

@@ -57,7 +57,12 @@ const DEFAULT_SKIN = {
     glyphs: {
         bullet: '•',
         arrow: '›',
-        spinner: ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'],
+        // Tier-3.1 (v4.1-tier3.1): replaced the generic braille spinner
+        // with a custom Aiden frame set derived from the ▲ prompt glyph.
+        // Six-frame rotating-triangle cadence reads as motion at the
+        // standard ~80ms tick without depending on colour, so it works
+        // identically under monochrome forks of this skin.
+        spinner: ['▲', '△', '▴', '▵', '▴', '△'],
     },
 };
 const LIGHT_SKIN = {
@@ -150,6 +155,21 @@ class SkinEngine {
      * The loaded skin becomes the active skin.
      */
     async loadSkin(name) {
+        // Tier-3-essentials: 'auto' resolves to a concrete skin via the
+        // multi-signal detector (AIDEN_THEME / NO_COLOR / COLORFGBG /
+        // TERM_PROGRAM, falling back to 'default'). Resolves once per
+        // call — caller can re-invoke loadSkin('auto') if env changes.
+        if (name === 'auto') {
+            // Lazy import keeps the skin loader free of detector deps in
+            // synchronous test paths that bypass loadSkin.
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const { detectTheme, detectedToSkinName } = require('./themeDetect');
+            const detected = detectTheme();
+            const resolved = detectedToSkinName(detected);
+            // Re-enter loadSkin with the resolved name (no infinite loop —
+            // the detector never returns 'auto').
+            return this.loadSkin(resolved);
+        }
         if (this.cache.has(name)) {
             this.current = this.cache.get(name);
             return this.current;

package/dist/cli/v4/streamingPrefix.js

@@ -0,0 +1,121 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod). Licensed under AGPL-3.0.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/streamingPrefix.ts — Phase v4.1-reply-formatting
+ *
+ * Stable-prefix split for streaming markdown. Given the running
+ * buffered text, return the index of the last "safe" boundary —
+ * a `\n\n` that lies OUTSIDE any open code fence. Content above
+ * the boundary is locked (already rendered, won't redraw); content
+ * below the boundary is the suffix the caller may re-render.
+ *
+ *   safePrefixBoundary("# H\n\nbody\n\nmore") === <index after 2nd \n\n>
+ *   safePrefixBoundary("```ts\nstill open") === 0  // inside fence
+ *
+ * Pure function. Used by display.streamComplete to decide whether to
+ * re-render the whole stream as markdown or only the trailing chunk.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safePrefixBoundary = safePrefixBoundary;
+exports.splitAtBoundary = splitAtBoundary;
+exports.endsInsideFence = endsInsideFence;
+/**
+ * Returns the index in `text` immediately AFTER the last `\n\n` that
+ * lies outside an open code fence. Returns 0 when no safe boundary
+ * exists (e.g. when the text is entirely inside an open fence).
+ */
+function safePrefixBoundary(text) {
+    let inFence = false;
+    let fenceMarker = null;
+    let lastBoundary = 0;
+    let i = 0;
+    const n = text.length;
+    while (i < n) {
+        if (!inFence) {
+            // Open fence?
+            if (text.startsWith('```', i)) {
+                inFence = true;
+                fenceMarker = '```';
+                i += 3;
+                continue;
+            }
+            if (text.startsWith('~~~', i)) {
+                inFence = true;
+                fenceMarker = '~~~';
+                i += 3;
+                continue;
+            }
+            // Paragraph break — `\n\n` (or `\n  \n` with whitespace gap).
+            if (text[i] === '\n' && /\n[ \t]*\n/.test(text.slice(i, i + 4))) {
+                // Advance past the consecutive whitespace+newlines.
+                let j = i;
+                while (j < n && (text[j] === '\n' || text[j] === ' ' || text[j] === '\t')) {
+                    j += 1;
+                }
+                // Boundary is the START of the post-break content.
+                lastBoundary = j;
+                i = j;
+                continue;
+            }
+        }
+        else {
+            // Close fence?
+            if (fenceMarker && text.startsWith(fenceMarker, i)) {
+                inFence = false;
+                fenceMarker = null;
+                i += 3;
+                continue;
+            }
+        }
+        i += 1;
+    }
+    return lastBoundary;
+}
+/**
+ * Split `text` at the safe boundary. `prefix` is locked content
+ * (already rendered), `suffix` is the unstable tail the caller
+ * should re-render on the next pass.
+ */
+function splitAtBoundary(text) {
+    const idx = safePrefixBoundary(text);
+    return { prefix: text.slice(0, idx), suffix: text.slice(idx) };
+}
+/**
+ * Helper: detect whether `text` ends inside an open code fence.
+ * The streaming renderer uses this to decide whether to defer
+ * markdown rendering until the fence closes.
+ */
+function endsInsideFence(text) {
+    let inFence = false;
+    let fenceMarker = null;
+    let i = 0;
+    const n = text.length;
+    while (i < n) {
+        if (!inFence) {
+            if (text.startsWith('```', i)) {
+                inFence = true;
+                fenceMarker = '```';
+                i += 3;
+                continue;
+            }
+            if (text.startsWith('~~~', i)) {
+                inFence = true;
+                fenceMarker = '~~~';
+                i += 3;
+                continue;
+            }
+        }
+        else if (fenceMarker && text.startsWith(fenceMarker, i)) {
+            inFence = false;
+            fenceMarker = null;
+            i += 3;
+            continue;
+        }
+        i += 1;
+    }
+    return inFence;
+}