aiden-runtime 4.0.2 → 4.1.0

package/dist/cli/v4/historyStore.js

@@ -0,0 +1,163 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/historyStore.ts — Tier-3.1.1 (v4.1-tier3.1.1)
+ *
+ * Persistent input history for the chat REPL. Each user prompt is
+ * appended to `<aidenHome>/.aiden_history`, one entry per line,
+ * multiline-encoded so a prompt with embedded newlines round-trips
+ * faithfully:
+ *   - `\n` inside a prompt is encoded as `\\n` on disk
+ *   - `\\` inside a prompt is encoded as `\\\\` on disk
+ *
+ * The store filters out:
+ *   - blank entries
+ *   - duplicates of the most recent entry
+ *   - very-short entries (<3 chars after trim) — too noisy to suggest
+ *   - paste-labelled entries (`[paste #N: …]`) — privacy. The user's
+ *     real prompt was the label-substituted text; storing the label
+ *     would leak nothing but storing the expanded text would leak the
+ *     entire pasted block into a plain-text history file.
+ *
+ * On startup, `loadRecent()` returns the last `limit` entries (newest
+ * first) for the autosuggest history fallback.
+ *
+ * Atomic write: each `append` writes a temp sibling then renames over
+ * the live file (Windows rename is atomic on the same volume), so a
+ * crash mid-write can never corrupt the history.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HISTORY_MAX_ENTRIES = void 0;
+exports.appendHistory = appendHistory;
+exports.loadRecent = loadRecent;
+exports._resetForTests = _resetForTests;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const paths_1 = require("../../core/v4/paths");
+const HISTORY_FILENAME = '.aiden_history';
+const PASTE_LABEL_RE = /\[paste #\d+:[^\]]*\]/;
+let writeLatch = Promise.resolve();
+function historyPath() {
+    return node_path_1.default.join((0, paths_1.resolveAidenPaths)().root, HISTORY_FILENAME);
+}
+/** Encode a prompt for one-line storage on disk. */
+function encode(s) {
+    return s.replace(/\\/g, '\\\\').replace(/\n/g, '\\n');
+}
+/** Reverse of `encode`. */
+function decode(s) {
+    // Walk the string so `\\\\n` decodes to `\\n` (literal backslash + n)
+    // rather than the placeholder for newline.
+    let out = '';
+    for (let i = 0; i < s.length; i += 1) {
+        const c = s[i];
+        if (c === '\\' && i + 1 < s.length) {
+            const next = s[i + 1];
+            if (next === 'n') {
+                out += '\n';
+                i += 1;
+            }
+            else if (next === '\\') {
+                out += '\\';
+                i += 1;
+            }
+            else {
+                out += c;
+            }
+        }
+        else {
+            out += c;
+        }
+    }
+    return out;
+}
+/**
+ * Append `entry` to the history file. Filters per the rules above.
+ * Best-effort — disk failures are swallowed so a crashed history
+ * write never breaks the agent loop.
+ */
+/**
+ * Tier-3-essentials: cap the live file at this many entries. When an
+ * append would push the count above, we rotate the oldest out before
+ * writing the new line. 5000 = ~250 KB at typical prompt sizes,
+ * trivial to keep on disk and load on every prompt.
+ */
+exports.HISTORY_MAX_ENTRIES = 5000;
+async function appendHistory(entry) {
+    const trimmed = entry.trim();
+    if (trimmed.length < 3)
+        return;
+    if (PASTE_LABEL_RE.test(trimmed))
+        return;
+    await (writeLatch = writeLatch.then(async () => {
+        try {
+            const p = historyPath();
+            const dir = node_path_1.default.dirname(p);
+            if (!(0, node_fs_1.existsSync)(dir))
+                (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+            // Read current contents once — we use them for both dup-suppress
+            // and rotation.
+            let priorLines = [];
+            try {
+                const cur = await node_fs_1.promises.readFile(p, 'utf8');
+                priorLines = cur.split('\n').filter((l) => l.length > 0);
+            }
+            catch { /* file may not exist yet */ }
+            // Skip if equal to the last entry on disk (cheap dup-suppress).
+            const lastDecoded = priorLines.length > 0 ? decode(priorLines[priorLines.length - 1]) : '';
+            if (lastDecoded === entry)
+                return;
+            // Rotation: cap at HISTORY_MAX_ENTRIES. The new line will push
+            // total to len+1; if that exceeds the cap, drop the oldest
+            // (len+1 - cap) entries from the front so we land EXACTLY at
+            // the cap.
+            const wantTotal = priorLines.length + 1;
+            if (wantTotal > exports.HISTORY_MAX_ENTRIES) {
+                const dropFront = wantTotal - exports.HISTORY_MAX_ENTRIES;
+                priorLines = priorLines.slice(dropFront);
+            }
+            const tmp = `${p}.tmp`;
+            const nextContent = priorLines.join('\n')
+                + (priorLines.length > 0 ? '\n' : '')
+                + `${encode(entry)}\n`;
+            await node_fs_1.promises.writeFile(tmp, nextContent, 'utf8');
+            await node_fs_1.promises.rename(tmp, p);
+        }
+        catch {
+            // History write failure must not bubble up.
+        }
+    }));
+}
+/**
+ * Return the last `limit` entries (newest first). Decoded — caller
+ * sees the original prompt verbatim including any embedded newlines.
+ *
+ * Tier-3-essentials: default raised 100 → 500 so the autosuggest
+ * history-mode reaches further back. The on-disk cap is independently
+ * controlled by `HISTORY_MAX_ENTRIES`.
+ */
+async function loadRecent(limit = 500) {
+    try {
+        const p = historyPath();
+        const raw = await node_fs_1.promises.readFile(p, 'utf8');
+        const lines = raw.split('\n').filter((l) => l.length > 0);
+        const decoded = lines.map(decode);
+        const sliced = decoded.slice(Math.max(0, decoded.length - limit));
+        return sliced.reverse();
+    }
+    catch {
+        return [];
+    }
+}
+/** Test/reset hook: drop in-process state. Disk untouched. */
+function _resetForTests() {
+    writeLatch = Promise.resolve();
+}

package/dist/cli/v4/pasteCompression.js

@@ -0,0 +1,124 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/pasteCompression.ts — Tier-3.1 (v4.1-tier3.1)
+ *
+ * When a user pastes a large block (>5 lines OR >500 chars), the
+ * REPL replaces the visible echo with a compact label
+ *   `[paste #<id>: <N> lines, <KB>]`
+ * and stores the original at `<aidenRoot>/pastes/paste_<id>.txt`.
+ * The agent receives the original text as input — only the visible
+ * echo is compressed, so the LLM still sees full content.
+ *
+ * The id counter is persisted in `<aidenRoot>/pastes/manifest.json`
+ * so it increments across sessions. Concurrent writes from the same
+ * process are serialised through an in-process latch; cross-process
+ * concurrency is best-effort (the manifest is read+rewritten atomic-
+ * ally enough for a single-user CLI).
+ *
+ * `expandPaste(id)` reads the original back from disk, used by the
+ * `/show <id>` slash command.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PASTE_COMPRESS_CHARS = exports.PASTE_COMPRESS_LINES = void 0;
+exports.compressPaste = compressPaste;
+exports.expandPaste = expandPaste;
+exports._resetLatchForTests = _resetLatchForTests;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const paths_1 = require("../../core/v4/paths");
+/** Heuristic threshold — copy-paste a code block of >5 lines or >500
+ *  chars and we compress; smaller pastes echo verbatim. */
+exports.PASTE_COMPRESS_LINES = 5;
+exports.PASTE_COMPRESS_CHARS = 500;
+/** Per-process write latch so concurrent compresses don't race the
+ *  manifest. Cross-process safety is non-goal for the single-user CLI. */
+let writeLatch = Promise.resolve();
+function pastesDir() {
+    const paths = (0, paths_1.resolveAidenPaths)();
+    return node_path_1.default.join(paths.root, 'pastes');
+}
+function manifestPath() {
+    return node_path_1.default.join(pastesDir(), 'manifest.json');
+}
+async function readNextId() {
+    try {
+        const raw = await node_fs_1.promises.readFile(manifestPath(), 'utf8');
+        const j = JSON.parse(raw);
+        if (typeof j.nextId === 'number' && j.nextId >= 1)
+            return j.nextId;
+    }
+    catch {
+        // missing or malformed — start at 1
+    }
+    return 1;
+}
+async function writeNextId(next) {
+    const dir = pastesDir();
+    await node_fs_1.promises.mkdir(dir, { recursive: true });
+    await node_fs_1.promises.writeFile(manifestPath(), JSON.stringify({ nextId: next }, null, 2), 'utf8');
+}
+function formatBytes(text) {
+    const bytes = Buffer.byteLength(text, 'utf8');
+    if (bytes < 1024)
+        return `${bytes}B`;
+    return `${(bytes / 1024).toFixed(1)}KB`;
+}
+/**
+ * Decide whether `text` should be compressed and (if so) persist the
+ * original. Always returns the original text for the agent path; only
+ * the echo path consults `compressed`/`label`.
+ */
+async function compressPaste(text) {
+    const lineCount = (text.match(/\n/g)?.length ?? 0) + 1;
+    const big = lineCount > exports.PASTE_COMPRESS_LINES || text.length > exports.PASTE_COMPRESS_CHARS;
+    if (!big) {
+        return { compressed: false, original: text };
+    }
+    // Atomic ID allocation under in-process latch.
+    let id = '';
+    let label = '';
+    await (writeLatch = writeLatch.then(async () => {
+        const next = await readNextId();
+        id = String(next);
+        const dir = pastesDir();
+        await node_fs_1.promises.mkdir(dir, { recursive: true });
+        await node_fs_1.promises.writeFile(node_path_1.default.join(dir, `paste_${id}.txt`), text, 'utf8');
+        await writeNextId(next + 1);
+        label = `[paste #${id}: ${lineCount} lines, ${formatBytes(text)}]`;
+    }));
+    return { compressed: true, id, label, original: text };
+}
+/**
+ * Read back a previously stored paste by id. Returns `null` if the
+ * id is unknown or the file vanished.
+ */
+async function expandPaste(id) {
+    // Defence-in-depth: only allow numeric ids — keeps the path-join
+    // from straying outside the pastes directory if someone ever
+    // wires an untrusted argument here.
+    if (!/^\d+$/.test(id))
+        return null;
+    try {
+        const file = node_path_1.default.join(pastesDir(), `paste_${id}.txt`);
+        return await node_fs_1.promises.readFile(file, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Test/reset hook: drop the in-process latch so a fresh test run
+ * starts with a clean serialiser. Disk state untouched.
+ */
+function _resetLatchForTests() {
+    writeLatch = Promise.resolve();
+}

package/dist/cli/v4/pasteIntercept.js

@@ -0,0 +1,203 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/pasteIntercept.ts — Tier-3.1a (v4.1-tier3.1a)
+ *
+ * Stdin pre-tap that handles bracketed paste sequences before
+ * @inquirer/prompts sees them. Modern inquirer treats any internal
+ * `\n` as Enter and resolves early, so a multi-line paste auto-
+ * submits before the user has a chance to review. This module
+ * intercepts paste boundaries (CSI 2004), captures the content,
+ * persists it via the existing pasteCompression manifest, and
+ * substitutes a `[paste #<id>: <N> lines, <KB>]` label on stdin.
+ *
+ * The user sees the label in inquirer's input buffer, presses Enter
+ * to submit, and chatSession.readUserInput swaps the label for the
+ * original via getPasteOriginal(id) before handing to the agent.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPasteOriginal = getPasteOriginal;
+exports.expandPasteLabels = expandPasteLabels;
+exports.installPasteInterceptor = installPasteInterceptor;
+exports._resetForTests = _resetForTests;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const paths_1 = require("../../core/v4/paths");
+const PASTE_BEGIN = '\x1b[200~';
+const PASTE_END = '\x1b[201~';
+/** id → original text (in-memory swap table). */
+const originals = new Map();
+function pastesDir() {
+    return node_path_1.default.join((0, paths_1.resolveAidenPaths)().root, 'pastes');
+}
+function manifestPath() {
+    return node_path_1.default.join(pastesDir(), 'manifest.json');
+}
+function readNextIdSync() {
+    try {
+        const raw = (0, node_fs_1.readFileSync)(manifestPath(), 'utf8');
+        const j = JSON.parse(raw);
+        if (typeof j.nextId === 'number' && j.nextId >= 1)
+            return j.nextId;
+    }
+    catch { /* missing or malformed */ }
+    return 1;
+}
+function writeNextIdSync(next) {
+    const dir = pastesDir();
+    if (!(0, node_fs_1.existsSync)(dir))
+        (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+    (0, node_fs_1.writeFileSync)(manifestPath(), JSON.stringify({ nextId: next }, null, 2), 'utf8');
+}
+function formatBytes(text) {
+    const bytes = Buffer.byteLength(text, 'utf8');
+    return bytes < 1024 ? `${bytes}B` : `${(bytes / 1024).toFixed(1)}KB`;
+}
+function compressSync(text) {
+    const dir = pastesDir();
+    if (!(0, node_fs_1.existsSync)(dir))
+        (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+    const next = readNextIdSync();
+    const id = String(next);
+    (0, node_fs_1.writeFileSync)(node_path_1.default.join(dir, `paste_${id}.txt`), text, 'utf8');
+    writeNextIdSync(next + 1);
+    const lineCount = (text.match(/\n/g)?.length ?? 0) + 1;
+    return { id, label: `[paste #${id}: ${lineCount} lines, ${formatBytes(text)}]` };
+}
+/**
+ * Look up the original text for a paste id. Returns undefined if the
+ * id was never seen by this process (e.g. the user typed a label by
+ * hand). Disk is the source of truth for /show <id>; this map is the
+ * fast path for the in-flight prompt swap.
+ */
+function getPasteOriginal(id) {
+    return originals.get(id);
+}
+/**
+ * Replace `[paste #N: …]` patterns in `input` with the corresponding
+ * original text from the in-process map. Patterns whose id we don't
+ * know are left intact (might be user-typed). Returns the swapped
+ * string.
+ */
+function expandPasteLabels(input) {
+    return input.replace(/\[paste #(\d+):[^\]]*\]/g, (m, id) => {
+        const orig = originals.get(id);
+        return orig !== undefined ? orig : m;
+    });
+}
+let installed = null;
+/**
+ * Install the stdin pre-tap. Wraps `process.stdin.emit('data', …)`
+ * so paste payloads are captured + replaced with labels before any
+ * downstream listener (inquirer) sees them. Idempotent. Returns an
+ * uninstall function.
+ *
+ * MCP serve mode: never call this — `aiden mcp serve` doesn't run
+ * the REPL.
+ */
+function installPasteInterceptor(stdin) {
+    if (installed)
+        return installed.restore;
+    const origEmit = stdin.emit.bind(stdin);
+    const state = { inPaste: false, buf: '' };
+    function processChunk(text) {
+        let out = '';
+        let cursor = 0;
+        while (cursor < text.length) {
+            if (state.inPaste) {
+                const endIdx = text.indexOf(PASTE_END, cursor);
+                if (endIdx === -1) {
+                    state.buf += text.slice(cursor);
+                    cursor = text.length;
+                }
+                else {
+                    state.buf += text.slice(cursor, endIdx);
+                    cursor = endIdx + PASTE_END.length;
+                    // Tier-3.1c: terminals (and some clipboard payloads) emit a
+                    // trailing CR/LF immediately after PASTE_END. Without this
+                    // swallow the bytes pass through to readline, where they
+                    // become an Enter event and auto-submit the prompt before
+                    // the user has reviewed the paste. Eat at most one CR + one
+                    // LF (in either order) right after PASTE_END.
+                    if (text[cursor] === '\r')
+                        cursor += 1;
+                    if (text[cursor] === '\n')
+                        cursor += 1;
+                    state.inPaste = false;
+                    const original = state.buf.replace(/\r\n/g, '\n');
+                    state.buf = '';
+                    // Strip a single trailing newline (Enter at end of paste).
+                    const trimmed = original.replace(/\n+$/, '');
+                    if (!trimmed.includes('\n') && trimmed.length <= 500) {
+                        // Single-line, small — emit as-is so user can edit.
+                        out += trimmed;
+                    }
+                    else {
+                        // Multi-line or large — disk-back + emit label.
+                        try {
+                            const { id, label } = compressSync(trimmed);
+                            originals.set(id, trimmed);
+                            out += label;
+                        }
+                        catch {
+                            // Disk failure: fall back to a single-space substitute
+                            // so internal newlines don't trigger auto-submit.
+                            out += trimmed.replace(/\n/g, ' ');
+                        }
+                    }
+                }
+            }
+            else {
+                const beginIdx = text.indexOf(PASTE_BEGIN, cursor);
+                if (beginIdx === -1) {
+                    out += text.slice(cursor);
+                    cursor = text.length;
+                }
+                else {
+                    out += text.slice(cursor, beginIdx);
+                    cursor = beginIdx + PASTE_BEGIN.length;
+                    state.inPaste = true;
+                }
+            }
+        }
+        return out;
+    }
+    const wrappedEmit = function (event, ...args) {
+        if (event !== 'data')
+            return origEmit(event, ...args);
+        const chunk = args[0];
+        if (chunk == null)
+            return origEmit(event, ...args);
+        const text = Buffer.isBuffer(chunk)
+            ? chunk.toString('utf8')
+            : (typeof chunk === 'string' ? chunk : String(chunk));
+        const processed = processChunk(text);
+        if (processed.length === 0)
+            return true; // suppress entirely
+        const nextArgs = [Buffer.from(processed, 'utf8'), ...args.slice(1)];
+        return origEmit(event, ...nextArgs);
+    };
+    stdin.emit = wrappedEmit;
+    const restore = () => {
+        if (!installed)
+            return;
+        stdin.emit = origEmit;
+        installed = null;
+    };
+    installed = { restore };
+    return restore;
+}
+/** Test helper: clear the in-memory map (does not touch disk). */
+function _resetForTests() {
+    originals.clear();
+    if (installed)
+        installed.restore();
+}