aiden-runtime 4.0.2 → 4.1.1

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;
+}

package/dist/cli/v4/syntaxHighlight.js

@@ -0,0 +1,345 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/syntaxHighlight.ts — Phase v4.1-reply-formatting
+ *
+ * Lightweight regex-based syntax highlighter for fenced code blocks.
+ * No external dependency. Languages with first-class support:
+ *   - typescript / javascript / ts / js
+ *   - python / py
+ *   - shell / bash / sh / zsh
+ *   - json
+ *   - yaml / yml
+ *
+ * Unknown languages fall through with no highlighting (returns the
+ * input verbatim) so the renderer never breaks on exotic fences.
+ *
+ * Tokenization is order-sensitive: comments/strings first (so a
+ * keyword inside a string isn't recoloured), then numbers, then
+ * keywords. The regex passes are conservative — they paint by
+ * token shape, not by full grammar — but they handle the common
+ * 90% case well enough for terminal display.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.highlightCode = highlightCode;
+exports.isSupportedLang = isSupportedLang;
+const skinEngine_1 = require("./skinEngine");
+function normalizeLang(raw) {
+    const s = (raw ?? '').toLowerCase().trim();
+    if (s === 'ts' || s === 'tsx' || s === 'typescript')
+        return 'typescript';
+    if (s === 'js' || s === 'jsx' || s === 'javascript')
+        return 'javascript';
+    if (s === 'py' || s === 'python')
+        return 'python';
+    if (s === 'sh' || s === 'bash' || s === 'zsh' || s === 'shell')
+        return 'shell';
+    if (s === 'json')
+        return 'json';
+    if (s === 'yaml' || s === 'yml')
+        return 'yaml';
+    return 'unknown';
+}
+const TS_KEYWORDS = new Set([
+    'const', 'let', 'var', 'function', 'return', 'if', 'else', 'for', 'while', 'do',
+    'break', 'continue', 'switch', 'case', 'default', 'async', 'await', 'class',
+    'extends', 'implements', 'new', 'this', 'super', 'import', 'export', 'from',
+    'as', 'typeof', 'instanceof', 'interface', 'type', 'enum', 'public', 'private',
+    'protected', 'readonly', 'static', 'void', 'never', 'any', 'unknown', 'true',
+    'false', 'null', 'undefined', 'throw', 'try', 'catch', 'finally', 'yield',
+    'in', 'of',
+]);
+const PY_KEYWORDS = new Set([
+    'def', 'return', 'if', 'elif', 'else', 'for', 'while', 'break', 'continue',
+    'import', 'from', 'as', 'class', 'pass', 'raise', 'try', 'except', 'finally',
+    'with', 'lambda', 'yield', 'global', 'nonlocal', 'True', 'False', 'None',
+    'and', 'or', 'not', 'is', 'in', 'async', 'await', 'assert', 'del',
+]);
+const SH_KEYWORDS = new Set([
+    'if', 'then', 'else', 'elif', 'fi', 'for', 'do', 'done', 'while', 'until', 'case',
+    'esac', 'function', 'return', 'export', 'local', 'readonly', 'in', 'select',
+]);
+/** ANSI-paint a token with the active skin's colour kind. */
+function paint(text, kind) {
+    return (0, skinEngine_1.getSkinEngine)().applyColors(text, kind);
+}
+/**
+ * Walk `code` building an output string. Identifies regions by a
+ * simple state machine: STRING → COMMENT → NUMBER → IDENT (which
+ * may be a keyword). Anything else is emitted verbatim.
+ *
+ * Returns the painted string. Pure — no side effects.
+ */
+function highlightTsJs(code, kw) {
+    let out = '';
+    let i = 0;
+    const n = code.length;
+    while (i < n) {
+        const c = code[i];
+        // Single-line comment
+        if (c === '/' && code[i + 1] === '/') {
+            const end = code.indexOf('\n', i);
+            const stop = end === -1 ? n : end;
+            out += paint(code.slice(i, stop), 'muted');
+            i = stop;
+            continue;
+        }
+        // Block comment
+        if (c === '/' && code[i + 1] === '*') {
+            const end = code.indexOf('*/', i);
+            const stop = end === -1 ? n : end + 2;
+            out += paint(code.slice(i, stop), 'muted');
+            i = stop;
+            continue;
+        }
+        // Strings (', ", `)
+        if (c === '"' || c === "'" || c === '`') {
+            const quote = c;
+            let j = i + 1;
+            while (j < n && code[j] !== quote) {
+                if (code[j] === '\\' && j + 1 < n) {
+                    j += 2;
+                    continue;
+                }
+                j += 1;
+            }
+            const stop = j < n ? j + 1 : n;
+            out += paint(code.slice(i, stop), 'success');
+            i = stop;
+            continue;
+        }
+        // Numbers
+        if (/[0-9]/.test(c) && (i === 0 || !/[a-zA-Z_$]/.test(code[i - 1] ?? ''))) {
+            let j = i;
+            while (j < n && /[0-9.eExX_a-fA-F]/.test(code[j] ?? ''))
+                j += 1;
+            out += paint(code.slice(i, j), 'accent');
+            i = j;
+            continue;
+        }
+        // Identifiers / keywords
+        if (/[a-zA-Z_$]/.test(c)) {
+            let j = i;
+            while (j < n && /[a-zA-Z0-9_$]/.test(code[j] ?? ''))
+                j += 1;
+            const word = code.slice(i, j);
+            out += kw.has(word) ? paint(word, 'brand') : word;
+            i = j;
+            continue;
+        }
+        out += c;
+        i += 1;
+    }
+    return out;
+}
+function highlightPython(code) {
+    // Python: # comments, '/" strings, numbers, keywords. Same engine
+    // as TS/JS but with a `#` comment and Python keyword set.
+    let out = '';
+    let i = 0;
+    const n = code.length;
+    while (i < n) {
+        const c = code[i];
+        if (c === '#') {
+            const end = code.indexOf('\n', i);
+            const stop = end === -1 ? n : end;
+            out += paint(code.slice(i, stop), 'muted');
+            i = stop;
+            continue;
+        }
+        if (c === '"' || c === "'") {
+            const quote = c;
+            // Triple-quote support
+            const triple = code[i + 1] === quote && code[i + 2] === quote;
+            let j = triple ? i + 3 : i + 1;
+            const closer = triple ? quote.repeat(3) : quote;
+            while (j < n) {
+                if (code.startsWith(closer, j)) {
+                    j += closer.length;
+                    break;
+                }
+                if (code[j] === '\\' && j + 1 < n) {
+                    j += 2;
+                    continue;
+                }
+                j += 1;
+            }
+            out += paint(code.slice(i, j), 'success');
+            i = j;
+            continue;
+        }
+        if (/[0-9]/.test(c) && (i === 0 || !/[a-zA-Z_]/.test(code[i - 1] ?? ''))) {
+            let j = i;
+            while (j < n && /[0-9._jJ]/.test(code[j] ?? ''))
+                j += 1;
+            out += paint(code.slice(i, j), 'accent');
+            i = j;
+            continue;
+        }
+        if (/[a-zA-Z_]/.test(c)) {
+            let j = i;
+            while (j < n && /[a-zA-Z0-9_]/.test(code[j] ?? ''))
+                j += 1;
+            const word = code.slice(i, j);
+            out += PY_KEYWORDS.has(word) ? paint(word, 'brand') : word;
+            i = j;
+            continue;
+        }
+        out += c;
+        i += 1;
+    }
+    return out;
+}
+function highlightShell(code) {
+    let out = '';
+    let i = 0;
+    const n = code.length;
+    while (i < n) {
+        const c = code[i];
+        if (c === '#' && (i === 0 || code[i - 1] === '\n' || code[i - 1] === ' ')) {
+            const end = code.indexOf('\n', i);
+            const stop = end === -1 ? n : end;
+            out += paint(code.slice(i, stop), 'muted');
+            i = stop;
+            continue;
+        }
+        if (c === '"' || c === "'") {
+            const quote = c;
+            let j = i + 1;
+            while (j < n && code[j] !== quote) {
+                if (code[j] === '\\' && j + 1 < n) {
+                    j += 2;
+                    continue;
+                }
+                j += 1;
+            }
+            const stop = j < n ? j + 1 : n;
+            out += paint(code.slice(i, stop), 'success');
+            i = stop;
+            continue;
+        }
+        if (/[a-zA-Z_]/.test(c)) {
+            let j = i;
+            while (j < n && /[a-zA-Z0-9_]/.test(code[j] ?? ''))
+                j += 1;
+            const word = code.slice(i, j);
+            out += SH_KEYWORDS.has(word) ? paint(word, 'brand') : word;
+            i = j;
+            continue;
+        }
+        out += c;
+        i += 1;
+    }
+    return out;
+}
+function highlightJson(code) {
+    // JSON has only strings, numbers, true/false/null, and structure.
+    let out = '';
+    let i = 0;
+    const n = code.length;
+    while (i < n) {
+        const c = code[i];
+        if (c === '"') {
+            let j = i + 1;
+            while (j < n && code[j] !== '"') {
+                if (code[j] === '\\' && j + 1 < n) {
+                    j += 2;
+                    continue;
+                }
+                j += 1;
+            }
+            const stop = j < n ? j + 1 : n;
+            // Treat key (followed by ':') vs value distinct.
+            // Skip whitespace after to peek at the next non-space char.
+            let k = stop;
+            while (k < n && /\s/.test(code[k] ?? ''))
+                k += 1;
+            const isKey = code[k] === ':';
+            out += paint(code.slice(i, stop), isKey ? 'heading' : 'success');
+            i = stop;
+            continue;
+        }
+        if (/[0-9-]/.test(c) && /[0-9]/.test(code[i + 1] ?? c)) {
+            let j = i;
+            while (j < n && /[0-9.eE+-]/.test(code[j] ?? ''))
+                j += 1;
+            out += paint(code.slice(i, j), 'accent');
+            i = j;
+            continue;
+        }
+        if (/[a-zA-Z]/.test(c)) {
+            let j = i;
+            while (j < n && /[a-zA-Z]/.test(code[j] ?? ''))
+                j += 1;
+            const word = code.slice(i, j);
+            if (word === 'true' || word === 'false' || word === 'null') {
+                out += paint(word, 'brand');
+            }
+            else {
+                out += word;
+            }
+            i = j;
+            continue;
+        }
+        out += c;
+        i += 1;
+    }
+    return out;
+}
+function highlightYaml(code) {
+    // Simple per-line: comments to '#', `key:` keys, strings.
+    return code
+        .split('\n')
+        .map((line) => {
+        const trimStart = line.match(/^\s*/)?.[0] ?? '';
+        const rest = line.slice(trimStart.length);
+        if (rest.startsWith('#'))
+            return trimStart + paint(rest, 'muted');
+        // key:
+        const m = /^([A-Za-z_][\w-]*)(\s*):(\s*)(.*)$/.exec(rest);
+        if (m) {
+            const [, key, padBeforeColon, padAfter, value] = m;
+            const valOut = /^['"]/.test(value)
+                ? paint(value, 'success')
+                : /^-?\d/.test(value)
+                    ? paint(value, 'accent')
+                    : value === 'true' || value === 'false' || value === 'null'
+                        ? paint(value, 'brand')
+                        : value;
+            return `${trimStart}${paint(key, 'heading')}${padBeforeColon}:${padAfter}${valOut}`;
+        }
+        // Bullet lists
+        if (rest.startsWith('- ')) {
+            return trimStart + paint('-', 'muted') + ' ' + rest.slice(2);
+        }
+        return line;
+    })
+        .join('\n');
+}
+/**
+ * Highlight `code` according to `lang`. Returns the painted string.
+ * If `lang` is unknown or empty, returns the input verbatim.
+ */
+function highlightCode(code, lang) {
+    const norm = normalizeLang(lang);
+    switch (norm) {
+        case 'typescript':
+        case 'javascript':
+            return highlightTsJs(code, TS_KEYWORDS);
+        case 'python': return highlightPython(code);
+        case 'shell': return highlightShell(code);
+        case 'json': return highlightJson(code);
+        case 'yaml': return highlightYaml(code);
+        case 'unknown':
+        default: return code;
+    }
+}
+/** Tiny helper for tests. */
+function isSupportedLang(lang) {
+    return normalizeLang(lang) !== 'unknown';
+}