sakuracode 0.0.0-stage → 0.1.0

package/dist/code/src/exec-mode.js

@@ -0,0 +1,84 @@
+// Non-interactive mode (`exec`): run one prompt to the end, with no screen. Progress goes to stderr, the final reply to
+// stdout as Markdown (rendered for a terminal, raw for a pipe), or every event as a JSON line with --json.
+import { writeFile } from "node:fs/promises";
+import { renderMarkdown } from "./markdown.js";
+import { createController } from "./session-controller.js";
+import { createTranscript, textOf } from "./transcript.js";
+import { renderBlock, toolHeadline } from "./tui/transcript-view.js";
+const SILENT_SURFACE = {
+    changed: () => undefined,
+    pickSession: async () => undefined,
+    clearScreen: () => undefined,
+    prefill: () => undefined,
+    exit: () => undefined,
+};
+export function exitCodeFor(result) {
+    if (result.reason === "done")
+        return 0;
+    if (result.reason === "cancelled")
+        return 130;
+    if (result.reason === "paused")
+        return 2;
+    return 1;
+}
+export async function runExec(options, deps) {
+    const transcript = createTranscript();
+    const controller = createController({ ...deps.controller, transcript, surface: SILENT_SURFACE });
+    try {
+        await controller.start(options.resume !== undefined ? { resume: options.resume } : {});
+    }
+    catch (error) {
+        deps.stderr.write(`${error.message}\n`);
+        return 1;
+    }
+    deps.onCancelable?.(() => controller.cancel());
+    const meta = controller.currentMeta();
+    const info = controller.statusInfo();
+    if (options.json)
+        deps.stdout.write(`${JSON.stringify({ type: "session", id: meta?.id, provider: info.provider, model: info.model, cwd: info.cwd, permissions: info.permissions, redaction: info.redaction })}\n`);
+    let finalMessage = "";
+    controller.driver.onEvent((event) => {
+        if (options.json)
+            deps.stdout.write(`${JSON.stringify(event)}\n`);
+        if (event.type === "message_end" && event.message.role === "assistant") {
+            const text = textOf(event.message.content);
+            if (text.trim() !== "")
+                finalMessage = text;
+        }
+    });
+    // Progress is optional; a warning or an error (a retry, a failure) is always shown.
+    transcript.subscribe((change) => {
+        if (change.type !== "commit")
+            return;
+        const block = change.block;
+        if (options.quiet && !(block.kind === "notice" && block.level !== "info"))
+            return;
+        if (block.kind === "tool" || block.kind === "notice" || block.kind === "compaction") {
+            const view = { width: 120, color: false, cwd: deps.controller.cwd };
+            deps.stderr.write(`${block.kind === "tool" ? toolHeadline(block, view) : renderBlock(block, view).join("\n")}\n`);
+        }
+    });
+    let result;
+    try {
+        result = await controller.runPrompt(options.prompt);
+    }
+    catch (error) {
+        result = { reason: "error", error: error.message };
+    }
+    if (options.json)
+        deps.stdout.write(`${JSON.stringify({ type: "result", ...result, finalMessage })}\n`);
+    else if (finalMessage !== "") {
+        const text = options.render ? renderMarkdown(finalMessage, { width: Math.min(deps.stdout.columns ?? 100, 120), color: options.color }).join("\n") : finalMessage;
+        deps.stdout.write(`${text}\n`);
+    }
+    if (result.reason === "error")
+        deps.stderr.write(`Error: ${result.error ?? "unknown"}\n`);
+    else if (result.reason === "paused")
+        deps.stderr.write(`The run was paused (${result.pause ?? "unknown"}).\n`);
+    else if (result.reason === "cancelled")
+        deps.stderr.write("Cancelled.\n");
+    if (options.outputLastMessage)
+        await writeFile(options.outputLastMessage, `${finalMessage}\n`);
+    await controller.close();
+    return exitCodeFor(result);
+}

package/dist/code/src/framework-testing.js

@@ -0,0 +1,2 @@
+// The import seam to the framework's scripted model, for tests and for the test hook of the binary (SAKURACODE_FAUX_SCRIPT).
+export { createFauxClient } from "../../sdk/testing.js";

package/dist/code/src/framework.js

@@ -0,0 +1,3 @@
+// The only import seam to the Sakura framework. If the framework moves or is installed as the npm package
+// `sakura-agent`, this is the one line to change.
+export * from "../../sdk/index.js";

package/dist/code/src/idle-compaction.js

@@ -0,0 +1,38 @@
+// Compacts the conversation once the session has been idle for as long as the provider keeps its prompt cache:
+// the cached prefix is gone anyway then, so a smaller context costs the least. Only the timing lives here.
+export function createIdleCompaction(options) {
+    let timer;
+    let compacting = false;
+    const arm = (delay) => {
+        clearTimeout(timer);
+        timer = undefined;
+        if (options.enabled) {
+            timer = setTimeout(fire, delay);
+            timer.unref();
+        }
+    };
+    async function fire() {
+        timer = undefined;
+        if (compacting)
+            return;
+        if (options.busy() || options.typing())
+            return arm(options.retryMs);
+        compacting = true;
+        try {
+            await options.compact();
+        }
+        catch {
+            // the controller reports failures; the next activity starts a new wait
+        }
+        finally {
+            compacting = false;
+        }
+    }
+    return {
+        touch: () => arm(options.idleMs),
+        stop() {
+            clearTimeout(timer);
+            timer = undefined;
+        },
+    };
+}

package/dist/code/src/images.js

@@ -0,0 +1,18 @@
+// Image files: which paths are images, and how a pasted or dropped path is read.
+import { existsSync, statSync } from "node:fs";
+import { extname, isAbsolute, resolve } from "node:path";
+const IMAGE_TYPES = { ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".gif": "image/gif", ".webp": "image/webp", ".bmp": "image/bmp" };
+export function imageMediaType(path) {
+    return IMAGE_TYPES[extname(path).toLowerCase()];
+}
+/** The existing image file a pasted text names (a terminal drop gives a path, maybe quoted or with escaped spaces), or undefined. */
+export function pastedImagePath(text, cwd) {
+    let candidate = text.trim();
+    if (candidate === "" || candidate.includes("\n"))
+        return undefined;
+    candidate = candidate.replace(/^(['"])(.*)\1$/, "$2").replace(/\\ /g, " ").replace(/^file:\/\//, "");
+    if (imageMediaType(candidate) === undefined)
+        return undefined;
+    const path = isAbsolute(candidate) ? candidate : resolve(cwd, candidate);
+    return existsSync(path) && statSync(path).isFile() ? path : undefined;
+}

package/dist/code/src/invocation.js

@@ -0,0 +1,39 @@
+// What a command line asks for, apart from the settings flags: which mode, which session, which prompt.
+import { ConfigError } from "./config.js";
+import { reviewPrompt } from "./slash-commands.js";
+export function parseInvocation(positionals, flags) {
+    const [command, ...rest] = positionals;
+    const last = flags.last ? "last" : undefined;
+    switch (command) {
+        case "providers":
+        case "sessions":
+            return command === "providers" ? { mode: "providers" } : { mode: "sessions" };
+        case "exec": {
+            if (rest[0] === "resume") {
+                const reference = last ?? rest[1];
+                if (reference === undefined)
+                    throw new ConfigError("exec resume needs a session id or --last");
+                return { mode: "exec", resume: reference, prompt: rest.slice(last ? 1 : 2).join(" ") };
+            }
+            return { mode: "exec", resume: last ?? flags.resume, prompt: rest.join(" ") };
+        }
+        case "review":
+            if ([flags.base, flags.commit].filter(Boolean).length > 1)
+                throw new ConfigError("--base and --commit cannot be used together");
+            return { mode: "exec", resume: undefined, prompt: reviewPrompt({ base: flags.base, commit: flags.commit, focus: rest.join(" ") }) };
+        case "resume": {
+            const reference = last ?? rest[0];
+            if (reference === undefined)
+                return { mode: "tui", resume: undefined, prompt: "", slash: "/resume" };
+            return { mode: "tui", resume: reference, prompt: rest.slice(last ? 0 : 1).join(" "), slash: undefined };
+        }
+        case "fork": {
+            const reference = last ?? rest[0];
+            if (reference === undefined)
+                throw new ConfigError("fork needs a session id or --last");
+            return { mode: "tui", resume: reference, prompt: "", slash: "/fork" };
+        }
+        default:
+            return { mode: "tui", resume: last ?? flags.resume, prompt: positionals.join(" "), slash: undefined };
+    }
+}

package/dist/code/src/markdown.js

@@ -0,0 +1,383 @@
+// Markdown to terminal lines. Handles the parts model replies use: headings, paragraphs, lists (nested, ordered, task),
+// quotes, fenced code, inline code, bold/italic/strike, links, tables and rules.
+import { createPalette, displayWidth, hyperlink, padEnd, wrapAnsi } from "./ansi.js";
+export function renderMarkdown(text, options) {
+    const context = { pal: createPalette(options.color), color: options.color, links: options.hyperlinks ?? false };
+    const lines = renderBlocks(text.replace(/\r\n?/g, "\n").split("\n"), Math.max(10, options.width), context);
+    while (lines.length > 0 && lines[lines.length - 1] === "")
+        lines.pop();
+    return lines;
+}
+// ---------- blocks ----------
+const FENCE = /^(\s{0,3})(`{3,}|~{3,})\s*([^`\s]*)[^`]*$/;
+const HEADING = /^\s{0,3}(#{1,6})\s+(.*?)\s*#*\s*$/;
+const RULE = /^\s{0,3}([-*_])(?:\s*\1){2,}\s*$/;
+const QUOTE = /^\s{0,3}>\s?(.*)$/;
+const LIST_ITEM = /^(\s*)([-*+]|\d{1,9}[.)])\s+(.*)$/;
+const TABLE_SEPARATOR = /^\s*\|?\s*:?-{1,}:?\s*(\|\s*:?-{1,}:?\s*)*\|?\s*$/;
+function renderBlocks(lines, width, context, tight = false) {
+    const out = [];
+    const addBlock = (block) => {
+        if (block.length === 0)
+            return;
+        if (!tight && out.length > 0 && out[out.length - 1] !== "")
+            out.push("");
+        out.push(...block);
+    };
+    let index = 0;
+    while (index < lines.length) {
+        const line = lines[index];
+        if (line.trim() === "") {
+            index += 1;
+            continue;
+        }
+        const fence = FENCE.exec(line);
+        if (fence) {
+            const marker = fence[2];
+            const body = [];
+            index += 1;
+            while (index < lines.length && !new RegExp(`^\\s{0,3}${marker[0]}{${marker.length},}\\s*$`).test(lines[index])) {
+                body.push(lines[index].replace(new RegExp(`^ {0,${fence[1].length}}`), ""));
+                index += 1;
+            }
+            index += 1; // the closing fence (a missing one ends at the end of the text)
+            addBlock(renderCode(body, fence[3] ?? "", width, context));
+            continue;
+        }
+        const heading = HEADING.exec(line);
+        if (heading) {
+            addBlock(renderHeading(heading[1].length, heading[2], width, context));
+            index += 1;
+            continue;
+        }
+        if (RULE.test(line)) {
+            addBlock([context.pal.dim("─".repeat(Math.min(width, 60)))]);
+            index += 1;
+            continue;
+        }
+        if (QUOTE.test(line)) {
+            const quoted = [];
+            while (index < lines.length && QUOTE.test(lines[index])) {
+                quoted.push(QUOTE.exec(lines[index])[1]);
+                index += 1;
+            }
+            addBlock(renderBlocks(quoted, width - 2, context).map((inner) => `${context.pal.dim("│")} ${inner}`.trimEnd()));
+            continue;
+        }
+        if (isTableStart(lines, index)) {
+            const rows = [];
+            while (index < lines.length && lines[index].trim() !== "" && lines[index].includes("|")) {
+                rows.push(lines[index]);
+                index += 1;
+            }
+            addBlock(renderTable(rows, width, context));
+            continue;
+        }
+        if (LIST_ITEM.test(line)) {
+            const taken = takeList(lines, index);
+            index = taken.next;
+            addBlock(renderList(taken.items, width, context));
+            continue;
+        }
+        // paragraph: runs until a blank line or the start of another block
+        const paragraph = [];
+        while (index < lines.length && lines[index].trim() !== "" && (paragraph.length === 0 || !startsBlock(lines, index))) {
+            paragraph.push(lines[index].trim());
+            index += 1;
+        }
+        addBlock(wrapAnsi(renderInline(paragraph.join("\n").replace(/\n/g, " "), context), width));
+    }
+    return out;
+}
+function startsBlock(lines, index) {
+    const line = lines[index];
+    return FENCE.test(line) || HEADING.test(line) || RULE.test(line) || QUOTE.test(line) || LIST_ITEM.test(line) || isTableStart(lines, index);
+}
+function isTableStart(lines, index) {
+    const header = lines[index];
+    const separator = lines[index + 1];
+    return header.includes("|") && separator !== undefined && separator.includes("-") && TABLE_SEPARATOR.test(separator) && splitRow(header).length === splitRow(separator).length;
+}
+function renderHeading(level, text, width, context) {
+    const { pal } = context;
+    const inline = renderInline(text, context);
+    const styled = level === 1 ? pal.bold(pal.underline(inline)) : level === 2 ? pal.bold(inline) : level === 3 ? pal.bold(pal.italic(inline)) : pal.italic(inline);
+    return wrapAnsi(styled, width);
+}
+// ---------- code ----------
+function renderCode(body, language, width, context) {
+    const { pal } = context;
+    const label = language ? pal.dim(`  ${language}`) : "";
+    const rendered = body.flatMap((codeLine) => {
+        const wrapped = wrapAnsi(codeLine === "" ? "" : codeLine.replace(/\t/g, "  "), Math.max(10, width - 2));
+        return wrapped.map((part) => `  ${pal.cyan(part)}`);
+    });
+    const rule = pal.dim("  " + "┄".repeat(Math.min(width - 2, 40)));
+    return [...(label ? [label] : [rule]), ...rendered, rule];
+}
+function takeList(lines, start) {
+    const items = [];
+    const first = LIST_ITEM.exec(lines[start]);
+    const baseIndent = first[1].length;
+    let index = start;
+    while (index < lines.length) {
+        const match = LIST_ITEM.exec(lines[index]);
+        if (!match || match[1].length !== baseIndent || /\d/.test(match[2]) !== /\d/.test(first[2]))
+            break;
+        const marker = match[2];
+        const contentIndent = baseIndent + marker.length + 1;
+        const itemLines = [match[3]];
+        index += 1;
+        while (index < lines.length) {
+            const current = lines[index];
+            if (current.trim() === "") {
+                // a blank line stays in the item only when the next non-blank line is indented under it
+                let lookahead = index + 1;
+                while (lookahead < lines.length && lines[lookahead].trim() === "")
+                    lookahead += 1;
+                const following = lines[lookahead];
+                if (following !== undefined && leadingSpaces(following) >= contentIndent) {
+                    itemLines.push("");
+                    index += 1;
+                    continue;
+                }
+                break;
+            }
+            if (leadingSpaces(current) >= contentIndent) {
+                itemLines.push(current.slice(contentIndent));
+                index += 1;
+                continue;
+            }
+            const next = LIST_ITEM.exec(current);
+            if (next && next[1].length <= baseIndent)
+                break;
+            if (startsBlock(lines, index))
+                break;
+            itemLines.push(current.trim()); // lazy continuation of the paragraph
+            index += 1;
+        }
+        items.push({ ordered: /\d/.test(marker), number: Number.parseInt(marker, 10), lines: itemLines });
+        // blank lines between items of one list
+        let lookahead = index;
+        while (lookahead < lines.length && lines[lookahead].trim() === "")
+            lookahead += 1;
+        const following = lines[lookahead];
+        const nextItem = following === undefined ? null : LIST_ITEM.exec(following);
+        if (nextItem && nextItem[1].length === baseIndent)
+            index = lookahead;
+        else
+            break;
+    }
+    return { items, next: index };
+}
+const leadingSpaces = (line) => line.length - line.trimStart().length;
+function renderList(items, width, context) {
+    const { pal } = context;
+    const out = [];
+    const markerWidth = Math.max(...items.map((item, position) => (item.ordered ? `${item.number + 0 * position}.`.length : 1))) + 1;
+    for (const item of items) {
+        const task = /^\[([ xX])\]\s+/.exec(item.lines[0]);
+        const body = task ? [item.lines[0].slice(task[0].length), ...item.lines.slice(1)] : item.lines;
+        const marker = task ? (task[1] === " " ? "☐" : "☑") : item.ordered ? `${item.number}.` : "•";
+        const inner = renderBlocks(body, width - markerWidth, context, !body.includes(""));
+        const styledMarker = task ? (task[1] === " " ? pal.dim(marker) : pal.green(marker)) : pal.dim(marker);
+        const gutter = markerWidth - displayWidth(marker);
+        inner.forEach((line, position) => {
+            out.push(position === 0 ? `${styledMarker}${" ".repeat(gutter)}${line}` : line === "" ? "" : `${" ".repeat(markerWidth)}${line}`);
+        });
+        if (inner.length === 0)
+            out.push(styledMarker);
+    }
+    return out;
+}
+// ---------- tables ----------
+function splitRow(row) {
+    const trimmed = row.trim().replace(/^\|/, "").replace(/\|$/, "");
+    const cells = [];
+    let current = "";
+    for (let index = 0; index < trimmed.length; index += 1) {
+        const char = trimmed[index];
+        if (char === "\\" && trimmed[index + 1] === "|") {
+            current += "|";
+            index += 1;
+        }
+        else if (char === "|") {
+            cells.push(current.trim());
+            current = "";
+        }
+        else
+            current += char;
+    }
+    cells.push(current.trim());
+    return cells;
+}
+function alignment(cell) {
+    const left = cell.startsWith(":");
+    const right = cell.endsWith(":");
+    return left && right ? "center" : right ? "right" : "left";
+}
+function fitColumns(natural, available) {
+    const widths = [...natural];
+    const minimum = 4;
+    while (widths.reduce((sum, value) => sum + value, 0) > available) {
+        const largest = widths.indexOf(Math.max(...widths));
+        if (widths[largest] <= minimum)
+            break;
+        widths[largest] = widths[largest] - 1;
+    }
+    return widths;
+}
+function renderTable(rows, width, context) {
+    const { pal } = context;
+    const header = splitRow(rows[0]);
+    const aligns = splitRow(rows[1]).map(alignment);
+    const body = rows.slice(2).map((row) => {
+        const cells = splitRow(row);
+        while (cells.length < header.length)
+            cells.push("");
+        return cells.slice(0, header.length);
+    });
+    const all = [header, ...body].map((row) => row.map((cell) => renderInline(cell, context)));
+    const natural = header.map((_, column) => Math.max(1, ...all.map((row) => Math.max(...row[column].split("\n").map(displayWidth), 0))));
+    const chrome = header.length * 3 + 1;
+    const widths = fitColumns(natural, Math.max(header.length * 4, width - chrome));
+    const border = (left, middle, right) => pal.dim(left + widths.map((cell) => "─".repeat(cell + 2)).join(middle) + right);
+    const renderRow = (cells, bold) => {
+        const wrapped = cells.map((cell, column) => wrapAnsi(cell, widths[column]));
+        const height = Math.max(...wrapped.map((cell) => cell.length));
+        return Array.from({ length: height }, (_, lineIndex) => {
+            const parts = wrapped.map((cell, column) => {
+                const text = cell[lineIndex] ?? "";
+                const styled = bold ? pal.bold(text) : text;
+                const gap = widths[column] - displayWidth(text);
+                const align = aligns[column] ?? "left";
+                if (align === "right")
+                    return " ".repeat(gap) + styled;
+                if (align === "center")
+                    return " ".repeat(Math.floor(gap / 2)) + styled + " ".repeat(gap - Math.floor(gap / 2));
+                return padEnd(styled, widths[column]);
+            });
+            return `${pal.dim("│")} ${parts.join(` ${pal.dim("│")} `)} ${pal.dim("│")}`;
+        });
+    };
+    const out = [border("┌", "┬", "┐"), ...renderRow(all[0], true), border("├", "┼", "┤")];
+    all.slice(1).forEach((row) => out.push(...renderRow(row, false)));
+    out.push(border("└", "┴", "┘"));
+    return out;
+}
+// ---------- inline ----------
+export function renderInline(text, context) {
+    const { pal } = context;
+    let out = "";
+    let index = 0;
+    const flushPlain = (value) => {
+        out += value;
+    };
+    while (index < text.length) {
+        const char = text[index];
+        if (char === "\\" && index + 1 < text.length && /[\\`*_{}\[\]()#+\-.!|~<>]/.test(text[index + 1])) {
+            flushPlain(text[index + 1]);
+            index += 2;
+            continue;
+        }
+        if (char === "`") {
+            const run = /^`+/.exec(text.slice(index))[0];
+            const close = text.indexOf(run, index + run.length);
+            if (close > index + run.length - 1 && close !== -1) {
+                const code = text.slice(index + run.length, close).replace(/^ (.*) $/, "$1");
+                out += pal.cyan(code);
+                index = close + run.length;
+                continue;
+            }
+            flushPlain(run);
+            index += run.length;
+            continue;
+        }
+        if (text.startsWith("**", index) || text.startsWith("__", index)) {
+            const marker = text.slice(index, index + 2);
+            const close = findClosing(text, marker, index + 2);
+            if (close !== -1 && text[index + 2] !== " ") {
+                out += pal.bold(renderInline(text.slice(index + 2, close), context));
+                index = close + 2;
+                continue;
+            }
+        }
+        if (text.startsWith("~~", index)) {
+            const close = findClosing(text, "~~", index + 2);
+            if (close !== -1) {
+                out += pal.strike(renderInline(text.slice(index + 2, close), context));
+                index = close + 2;
+                continue;
+            }
+        }
+        if ((char === "*" || char === "_") && text[index + 1] !== " " && text[index + 1] !== undefined) {
+            const previous = text[index - 1];
+            const wordBefore = previous !== undefined && /[\p{L}\p{N}]/u.test(previous);
+            if (!(char === "_" && wordBefore)) {
+                const close = findClosing(text, char, index + 1);
+                if (close !== -1 && text[close - 1] !== " " && !(char === "_" && /[\p{L}\p{N}]/u.test(text[close + 1] ?? ""))) {
+                    out += pal.italic(renderInline(text.slice(index + 1, close), context));
+                    index = close + 1;
+                    continue;
+                }
+            }
+        }
+        if (char === "[") {
+            const link = /^\[((?:[^\[\]]|\[[^\]]*\])*)\]\(([^)\s]+)(?:\s+"[^"]*")?\)/.exec(text.slice(index));
+            if (link) {
+                const label = renderInline(link[1], context);
+                const url = link[2];
+                const shown = pal.underline(pal.blue(label));
+                out += context.links ? hyperlink(shown, url, true) : link[1] === url ? shown : `${shown} ${pal.dim(`(${url})`)}`;
+                index += link[0].length;
+                continue;
+            }
+        }
+        if (char === "<") {
+            const auto = /^<(https?:\/\/[^>\s]+)>/.exec(text.slice(index));
+            if (auto) {
+                out += pal.underline(pal.blue(auto[1]));
+                index += auto[0].length;
+                continue;
+            }
+        }
+        if (char === "h") {
+            const bare = /^https?:\/\/[^\s<>)\]]+[^\s<>)\].,;:!?'"]/.exec(text.slice(index));
+            if (bare && (index === 0 || /[\s(]/.test(text[index - 1]))) {
+                out += pal.underline(pal.blue(bare[0]));
+                index += bare[0].length;
+                continue;
+            }
+        }
+        flushPlain(char);
+        index += 1;
+    }
+    return out;
+}
+function findClosing(text, marker, from) {
+    let index = from;
+    while (index < text.length) {
+        if (text[index] === "`") {
+            const run = /^`+/.exec(text.slice(index))[0];
+            const close = text.indexOf(run, index + run.length);
+            index = close === -1 ? index + run.length : close + run.length;
+            continue;
+        }
+        if (text[index] === "\\") {
+            index += 2;
+            continue;
+        }
+        if (text.startsWith(marker, index) && index > from) {
+            if (marker.length === 1 && text[index + 1] === marker) {
+                index += 2;
+                continue;
+            }
+            return index;
+        }
+        index += 1;
+    }
+    return -1;
+}
+export function createInlineContext(color) {
+    return { pal: createPalette(color), color, links: false };
+}

package/dist/code/src/mentions.js

@@ -0,0 +1,22 @@
+// `@path` mentions in a prompt: files that exist are named to the agent so that it reads them.
+import { stat } from "node:fs/promises";
+import { isAbsolute, resolve } from "node:path";
+import { imageMediaType } from "./images.js";
+import { MENTION_NOTE } from "./transcript.js";
+const MENTION = /(^|\s)@([^\s@]+)/g;
+export async function expandMentions(prompt, cwd, home) {
+    const candidates = [...prompt.matchAll(MENTION)].map((match) => match[2].replace(/[.,;:!?)\]]+$/, ""));
+    const files = [];
+    const images = [];
+    for (const candidate of new Set(candidates)) {
+        const path = candidate.startsWith("~/") && home ? resolve(home, candidate.slice(2)) : isAbsolute(candidate) ? candidate : resolve(cwd, candidate);
+        const info = await stat(path).catch(() => undefined);
+        if (info?.isFile() && imageMediaType(path))
+            images.push(path);
+        else if (info)
+            files.push(info.isDirectory() ? `${path}/` : path);
+    }
+    if (files.length === 0)
+        return { text: prompt, files, images };
+    return { text: `${prompt}${MENTION_NOTE}${files.map((file) => `- ${file}`).join("\n")}`, files, images };
+}

package/dist/code/src/permissions.js

@@ -0,0 +1,31 @@
+// Permission presets: which plugins guard the agent. None of them restricts the working directory.
+import { redactionPlugin, reviewPlugin } from "./framework.js";
+export const PERMISSION_NAMES = ["auto", "read-only", "strict", "full-access"];
+export const PERMISSION_PRESETS = {
+    auto: { name: "auto", summary: "every call is reviewed (hard rules, then a reviewer model); refusals go back to the agent", review: true, tools: undefined, breakerConsecutive: undefined },
+    "read-only": { name: "read-only", summary: "reviewed, and the agent only gets the read tool", review: true, tools: ["read"], breakerConsecutive: undefined },
+    strict: { name: "strict", summary: "reviewed; three refusals in a row pause the run", review: true, tools: undefined, breakerConsecutive: 3 },
+    "full-access": { name: "full-access", summary: "nothing is reviewed", review: false, tools: undefined, breakerConsecutive: undefined },
+};
+export function isPermissionName(value) {
+    return PERMISSION_NAMES.includes(value);
+}
+/**
+ * The plugins for a permission preset and the redaction switch. Redaction is added first so that the reviewer's own requests are masked too.
+ * Review is on unless the preset is full-access; redaction is off unless asked for.
+ */
+export function buildGuards(options) {
+    const preset = PERMISSION_PRESETS[options.permissions];
+    const plugins = [];
+    const redaction = options.redaction ? redactionPlugin() : undefined;
+    if (redaction)
+        plugins.push(redaction);
+    if (preset.review) {
+        const llm = redaction ? redaction.wrap(options.reviewLlm) : options.reviewLlm;
+        plugins.push(reviewPlugin({ llm, directoryRules: false, ...(preset.breakerConsecutive !== undefined ? { breaker: { consecutive: preset.breakerConsecutive } } : {}) }));
+    }
+    return { plugins, tools: preset.tools };
+}
+export function describeThinking(level) {
+    return level ?? "default";
+}