talos-code 0.0.1 → 0.1.0

package/dist/tui/project-file-index.js

@@ -0,0 +1,214 @@
+/*
+ * R5b D6 (owner decision Q-R5-16): the project's files for `@`, from an own bounded walker (no new dependency; Pi calls
+ * `fd`, Claude Code and Codex walk with ripgrep's ignore rules).
+ * - `.gitignore` files are respected, the root's and every nested one, in git's order: later rules win, `!` re-includes,
+ *   a trailing `/` is for folders only, a pattern with a slash is anchored to its file's folder, one without matches at any
+ *   depth, `*` `?` `[...]` `**` as git reads them. A folder that is ignored is not walked (git cannot re-include inside it).
+ *   Not read: `.git/info/exclude` and the global excludes file.
+ * - `.git` and `node_modules` are never walked.
+ * - A link or junction to a folder is never followed (the R4 guard, file-completion.ts); a linked file is kept only if its
+ *   real path is inside the workspace. Names with control, line-separator or bidi characters are never drawn.
+ * - At most `maxEntries` rows, breadth first; `capped` says the walk stopped, so the list can say so (plan Part III item 2).
+ */
+import { readFile, readdir, stat } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { resolvePathInsideWorkspace, resolveWorkspaceIdentity } from "../security/workspace-identity.js";
+export const PROJECT_INDEX_MAX_ENTRIES = 20_000;
+const MAX_DEPTH = 32;
+const NEVER_WALKED = new Set(['.git', 'node_modules']);
+const UNSAFE_NAME = /[\x00-\x1f\x7f\p{Zl}\p{Zp}\p{Bidi_Control}]/u;
+function escapeRegex(text) { return text.replace(/[.*+?^${}()|[\]\\/]/gu, '\\$&'); }
+function globSource(glob) {
+    let out = '';
+    for (let i = 0; i < glob.length; i++) {
+        const c = glob[i];
+        if (c === '*') {
+            if (glob[i + 1] === '*') {
+                const atStart = i === 0 || glob[i - 1] === '/', slashAfter = glob[i + 2] === '/', atEnd = i + 2 === glob.length;
+                if (atStart && slashAfter) {
+                    out += '(?:.*/)?';
+                    i += 2;
+                    continue;
+                }
+                if (atStart && atEnd) {
+                    out += '.*';
+                    i += 1;
+                    continue;
+                }
+                out += '.*';
+                i += 1;
+                continue;
+            }
+            out += '[^/]*';
+            continue;
+        }
+        if (c === '?') {
+            out += '[^/]';
+            continue;
+        }
+        if (c === '[') {
+            const end = glob.indexOf(']', i + 2);
+            if (end > i) {
+                let body = glob.slice(i + 1, end);
+                if (body.startsWith('!'))
+                    body = '^' + body.slice(1);
+                out += `[${body.replace(/\\/gu, '\\\\')}]`;
+                i = end;
+                continue;
+            }
+        }
+        if (c === '\\' && i + 1 < glob.length) {
+            out += escapeRegex(glob[i + 1]);
+            i += 1;
+            continue;
+        }
+        out += escapeRegex(c);
+    }
+    return out;
+}
+/** The rules of one `.gitignore`; `base` is its folder relative to the project root ('' for the root). */
+export function gitignoreRules(text, base) {
+    const rules = [];
+    for (const raw of text.split(/\r?\n/u)) {
+        let line = raw.replace(/(?<!\\)\s+$/u, '');
+        if (!line || line.startsWith('#'))
+            continue;
+        let negate = false;
+        if (line.startsWith('!')) {
+            negate = true;
+            line = line.slice(1);
+        }
+        if (line.startsWith('\\#') || line.startsWith('\\!'))
+            line = line.slice(1);
+        let directoryOnly = false;
+        if (line.endsWith('/')) {
+            directoryOnly = true;
+            line = line.slice(0, -1);
+        }
+        if (!line)
+            continue;
+        const anchored = line.includes('/');
+        if (line.startsWith('/'))
+            line = line.slice(1);
+        const source = globSource(line);
+        rules.push({ base, negate, directoryOnly, pattern: new RegExp(anchored ? `^${source}$` : `(?:^|/)${source}$`, 'u') });
+    }
+    return rules;
+}
+/** Git's answer for one path (relative to the root, `/`-separated): the last rule that matches decides. */
+export function isIgnored(rules, path, directory) {
+    let ignored = false;
+    for (const rule of rules) {
+        if (rule.directoryOnly && !directory)
+            continue;
+        const relative = rule.base ? (path.startsWith(rule.base + '/') ? path.slice(rule.base.length + 1) : null) : path;
+        if (relative === null)
+            continue;
+        if (rule.pattern.test(relative))
+            ignored = !rule.negate;
+    }
+    return ignored;
+}
+export async function buildProjectFileIndex(projectRoot, { maxEntries = PROJECT_INDEX_MAX_ENTRIES } = {}) {
+    const workspace = await resolveWorkspaceIdentity({ projectRoot });
+    const root = workspace.requestedRoot;
+    const entries = [];
+    let capped = false;
+    const queue = [{ path: '', depth: 0, rules: [] }];
+    while (queue.length && !capped) {
+        const folder = queue.shift();
+        const absolute = folder.path ? join(root, ...folder.path.split('/')) : root;
+        let rules = folder.rules;
+        try {
+            rules = [...rules, ...gitignoreRules(await readFile(join(absolute, '.gitignore'), 'utf8'), folder.path)];
+        }
+        catch { /* no .gitignore here */ }
+        let dirents;
+        try {
+            dirents = await readdir(absolute, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        dirents.sort((a, b) => a.name.localeCompare(b.name));
+        for (const dirent of dirents) {
+            if (UNSAFE_NAME.test(dirent.name) || NEVER_WALKED.has(dirent.name))
+                continue;
+            const path = folder.path ? `${folder.path}/${dirent.name}` : dirent.name;
+            let directory = dirent.isDirectory();
+            if (dirent.isSymbolicLink()) {
+                /* A link or junction: a folder is never followed; a file is kept only when its real path stays inside. */
+                const real = await resolvePathInsideWorkspace(workspace, resolve(absolute, dirent.name)).catch(() => null);
+                if (!real)
+                    continue;
+                let info;
+                try {
+                    info = await stat(real);
+                }
+                catch {
+                    continue;
+                }
+                if (!info.isFile())
+                    continue;
+                directory = false;
+            }
+            else if (!directory && !dirent.isFile())
+                continue;
+            if (isIgnored(rules, path, directory))
+                continue;
+            if (entries.length >= maxEntries) {
+                capped = true;
+                break;
+            }
+            entries.push({ path, directory });
+            if (directory && folder.depth + 1 < MAX_DEPTH)
+                queue.push({ path, depth: folder.depth + 1, rules });
+        }
+    }
+    return { root, entries, capped, max: maxEntries, builtAt: Date.now() };
+}
+/*
+ * Ranking, best first (Claude Code 2.1.280: "a file whose name contains the query above folder-only matches"):
+ * 0 the name starts with the query · 1 the name contains it · 2 the path contains it · 3 the query's letters appear in
+ * order in the path (3 letters or more); inside a tier, files before folders, then shallower, then shorter, then by name.
+ */
+export function rankProjectFiles(index, query) {
+    const q = query.toLowerCase().replace(/\\/gu, '/');
+    if (!q)
+        return [];
+    const scored = [];
+    for (const entry of index.entries) {
+        const path = entry.path.toLowerCase(), name = path.slice(path.lastIndexOf('/') + 1);
+        let tier = -1;
+        if (name.startsWith(q))
+            tier = 0;
+        else if (name.includes(q))
+            tier = 1;
+        else if (path.includes(q))
+            tier = 2;
+        else if (q.length >= 3) {
+            let at = 0;
+            for (const ch of path) {
+                if (ch === q[at])
+                    at += 1;
+                if (at === q.length)
+                    break;
+            }
+            if (at === q.length)
+                tier = 3;
+        }
+        if (tier >= 0)
+            scored.push({ entry, tier });
+    }
+    const depth = (path) => path.split('/').length;
+    return scored.sort((a, b) => a.tier - b.tier || Number(a.entry.directory) - Number(b.entry.directory) || depth(a.entry.path) - depth(b.entry.path) || a.entry.path.length - b.entry.path.length || a.entry.path.localeCompare(b.entry.path)).map(row => row.entry);
+}
+/** One index per project, rebuilt when older than `ttlMs`, so typing after `@` does not walk the tree at every key. */
+export function createProjectFileIndexCache(projectRoot, { ttlMs = 15_000 } = {}) {
+    let pending = null;
+    return { get() {
+            if (pending)
+                return pending.then(index => Date.now() - index.builtAt <= ttlMs ? index : (pending = buildProjectFileIndex(projectRoot)));
+            return (pending = buildProjectFileIndex(projectRoot).catch(error => { pending = null; throw error; }));
+        } };
+}

package/dist/tui/project-references.js

@@ -0,0 +1,85 @@
+import { readFile, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { IMAGE_ATTACHMENT_MAX_BYTES, TEXT_ATTACHMENT_MAX_BYTES, imageMimeFromBytes, validateCliAttachments } from "../runtime/attachments.js";
+import { isPathInsideWorkspace, resolvePathInsideWorkspace, resolveWorkspaceIdentity } from "../security/workspace-identity.js";
+export class ProjectReferenceError extends Error {
+    code;
+    constructor(code, message = code) { super(message); this.name = 'ProjectReferenceError'; this.code = code; }
+}
+export function parseProjectReferenceTokens(prompt) {
+    const out = [];
+    const pattern = /(?:^|\s)@(?:"([^"\r\n]+)"|([^\s"'<>]+))/gu;
+    for (const match of prompt.matchAll(pattern)) {
+        const value = match[1] ?? match[2];
+        if (value)
+            out.push(value);
+    }
+    return out;
+}
+function portableAbsolute(value) { return path.isAbsolute(value) || path.win32.isAbsolute(value); }
+function relativeProjectPath(root, target) { return path.relative(root, target).split(path.sep).join('/'); }
+export async function resolveProjectReferences({ projectRoot, prompt }) {
+    const tokens = parseProjectReferenceTokens(prompt);
+    if (tokens.length === 0)
+        return [];
+    const workspace = await resolveWorkspaceIdentity({ projectRoot });
+    const seen = new Set();
+    const attachments = [];
+    for (const raw of tokens) {
+        if (portableAbsolute(raw))
+            throw new ProjectReferenceError('PROJECT_REFERENCE_OUTSIDE_WORKSPACE', 'Absolute project references are not allowed.');
+        const lexical = path.resolve(workspace.requestedRoot, raw);
+        if (!isPathInsideWorkspace(workspace, lexical))
+            throw new ProjectReferenceError('PROJECT_REFERENCE_OUTSIDE_WORKSPACE', 'Project reference escapes the workspace.');
+        let info;
+        try {
+            info = await stat(lexical);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                throw new ProjectReferenceError('PROJECT_REFERENCE_NOT_FOUND', `Project reference not found: ${raw}`);
+            throw error;
+        }
+        const canonical = await resolvePathInsideWorkspace(workspace, lexical);
+        if (!canonical)
+            throw new ProjectReferenceError('PROJECT_REFERENCE_OUTSIDE_WORKSPACE', 'Project reference resolves outside the workspace.');
+        try {
+            info = await stat(canonical);
+        }
+        catch {
+            throw new ProjectReferenceError('PROJECT_REFERENCE_NOT_FOUND', `Project reference not found: ${raw}`);
+        }
+        if (!info.isFile())
+            throw new ProjectReferenceError('PROJECT_REFERENCE_NOT_FILE', `Project reference is not a regular file: ${raw}`);
+        if (info.size > IMAGE_ATTACHMENT_MAX_BYTES)
+            throw new ProjectReferenceError('ATTACHMENT_ITEM_TOO_LARGE', 'Referenced file is larger than the maximum supported attachment.');
+        if (seen.has(canonical))
+            continue;
+        seen.add(canonical);
+        const bytes = await readFile(canonical);
+        const canonicalAfter = await resolvePathInsideWorkspace(workspace, canonical);
+        if (canonicalAfter !== canonical)
+            throw new ProjectReferenceError('PROJECT_REFERENCE_CHANGED', 'Project reference changed while it was being read.');
+        const mime = imageMimeFromBytes(bytes);
+        const stablePath = relativeProjectPath(workspace.canonicalRoot, canonical);
+        if (!stablePath || /[\0\r\n]/u.test(stablePath))
+            throw new ProjectReferenceError('ATTACHMENT_INVALID', 'Project reference path is invalid.');
+        if (mime) {
+            attachments.push({ kind: 'image', path: stablePath, mimeType: mime, bytes: bytes.length, dataBase64: bytes.toString('base64') });
+            continue;
+        }
+        if (bytes.length > TEXT_ATTACHMENT_MAX_BYTES)
+            throw new ProjectReferenceError('ATTACHMENT_TEXT_TOO_LARGE', `Text reference is larger than ${TEXT_ATTACHMENT_MAX_BYTES} bytes.`);
+        let text;
+        try {
+            text = new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+        }
+        catch {
+            throw new ProjectReferenceError('ATTACHMENT_BINARY_UNSUPPORTED', `Unsupported binary project reference: ${stablePath}`);
+        }
+        if (text.includes('\0'))
+            throw new ProjectReferenceError('ATTACHMENT_BINARY_UNSUPPORTED', `Unsupported binary project reference: ${stablePath}`);
+        attachments.push({ kind: 'text', path: stablePath, mimeType: 'text/plain', bytes: bytes.length, text });
+    }
+    return validateCliAttachments(attachments);
+}

package/dist/tui/project-trust-prompt.js

@@ -0,0 +1,287 @@
+import { t, tn } from "../i18n/index.js";
+import { createTerminalSizeStore, frameRowsFor, terminalFrameProps } from "./components/terminal-shell.js";
+import { detectTerminalCapabilities } from "./terminal-capabilities.js";
+import { createTerminalSessionPlan } from "./terminal-session.js";
+import { displayWidth, truncateDisplay, truncateMiddle, wrapDisplay } from "./text-width.js";
+import { liveTheme } from "./theme-store.js";
+export const PROJECT_TRUST_GRACE_MS = 300;
+/* E4: paths are shown as the person types them. Control, C1, line/paragraph separators, bidi controls and
+   default-ignorable characters are shown as `\uXXXX`; a backslash is doubled only where it would read as such an escape
+   (a folder named `u0041`), so every escape on screen is unambiguous and every other backslash is single. */
+const TERMINAL_UNSAFE = /[\x00-\x1f\x7f-\x9f\u2028\u2029\p{Bidi_Control}\p{Default_Ignorable_Code_Point}]/gu;
+const ESCAPE_LOOKALIKE = /\\(?=u(?:[0-9a-fA-F]{4}|\{[0-9a-fA-F]+\}))/gu;
+const BACKSLASH = String.fromCharCode(92);
+export function inertProjectTrustText(value) {
+    return value.replace(ESCAPE_LOOKALIKE, () => BACKSLASH + BACKSLASH).replace(TERMINAL_UNSAFE, character => {
+        const code = character.codePointAt(0);
+        return code > 0xffff ? `${BACKSLASH}u{${code.toString(16)}}` : `${BACKSLASH}u${code.toString(16).padStart(4, '0')}`;
+    });
+}
+function reasonText(assessment) {
+    if (assessment.reason === 'PROJECT_UNTRUSTED')
+        return t('firstrun.trust.reason.untrusted');
+    if (assessment.trusted)
+        return t('firstrun.trust.plain');
+    if (assessment.reason === 'RESOURCE_FINGERPRINT_CHANGED')
+        return t('firstrun.trust.reason.fingerprint');
+    if (assessment.reason === 'RESOURCE_SET_CHANGED')
+        return t('firstrun.trust.reason.set');
+    if (assessment.reason === 'RESOURCE_IDENTITY_MISMATCH')
+        return t('firstrun.trust.reason.identity');
+    if (assessment.reason === 'NESTED_REPOSITORY_BOUNDARY_CHANGED')
+        return t('firstrun.trust.reason.nested');
+    return t('firstrun.trust.reason.other', { reason: assessment.reason });
+}
+/* E4: each resource once — `kind · path`, and `kind · id · path` only when the id is not the path (an MCP server or a
+   hook named inside a shared config file: the trust center lists them the same way). */
+function resourceLine(resource) {
+    const where = inertProjectTrustText(resource.relativePath);
+    return resource.id === resource.relativePath ? `${resource.kind} · ${where}` : `${resource.kind} · ${inertProjectTrustText(resource.id)} · ${where}`;
+}
+export function projectTrustPromptModel({ assessment, nestedRepositories }) {
+    const counts = new Map();
+    for (const resource of assessment.resources)
+        counts.set(resource.kind, (counts.get(resource.kind) ?? 0) + 1);
+    const detail = [...counts.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([kind, count]) => `${kind} ${count}`).join(', ');
+    const folder = assessment.folder;
+    const sessionOnly = folder?.sessionOnly === true;
+    /* The parent is offered for a folder being decided for the first time, and only when it may be saved. */
+    const parent = !sessionOnly && folder && !folder.decided && folder.parent ? inertProjectTrustText(folder.parent) : null;
+    const choices = [
+        { id: 'cancel', label: t('firstrun.trust.choice.cancel'), shortcut: 'c' },
+        { id: 'trust', label: t(sessionOnly ? 'firstrun.trust.choice.trustSession' : 'firstrun.trust.choice.trust'), shortcut: 't' },
+        ...(parent ? [{ id: 'trust-parent', label: t('firstrun.trust.choice.parent', { path: parent }), shortcut: 'p' }] : []),
+    ];
+    const firstTime = assessment.trusted || assessment.reason === 'PROJECT_UNTRUSTED';
+    return {
+        title: t(firstTime ? 'firstrun.trust.title' : 'firstrun.trust.titleChanged'),
+        project: inertProjectTrustText(assessment.workspace.canonicalRoot),
+        reason: reasonText(assessment),
+        resourceSummary: assessment.resources.length ? tn('firstrun.trust.files', assessment.resources.length, { detail }) : '',
+        resources: assessment.resources.map(resourceLine),
+        nestedRepositories: nestedRepositories.map(entry => inertProjectTrustText(entry.relativePath)),
+        session: sessionOnly ? t('firstrun.trust.session') : null,
+        choices,
+        parent,
+        defaultSelection: 'cancel',
+    };
+}
+/** Moves the highlight; Tab wraps around, the arrows stop at the ends. Two choices when `choices` is omitted (pre-R4). */
+export function nextProjectTrustSelection(current, direction, choices = ['cancel', 'trust']) {
+    const index = Math.max(0, choices.indexOf(current));
+    if (direction === 'toggle')
+        return choices[(index + 1) % choices.length];
+    return choices[Math.min(choices.length - 1, Math.max(0, index + (direction === 'next' ? 1 : -1)))];
+}
+/* Word wrap by display width; a word longer than the row is broken inside. */
+function wrapWords(text, width) {
+    const limit = Math.max(1, width);
+    const rows = [];
+    let row = '';
+    for (const word of text.split(/ +/u).filter(Boolean)) {
+        const candidate = row ? `${row} ${word}` : word;
+        if (displayWidth(candidate) <= limit) {
+            row = candidate;
+            continue;
+        }
+        if (row)
+            rows.push(row);
+        if (displayWidth(word) <= limit) {
+            row = word;
+            continue;
+        }
+        const pieces = wrapDisplay(word, limit);
+        row = pieces.pop();
+        rows.push(...pieces);
+    }
+    if (row || !rows.length)
+        rows.push(row);
+    return rows;
+}
+/* A long value squeezed into one row: cut with an ellipsis. */
+function oneRow(rows, width) { return rows.length <= 1 ? rows : [truncateDisplay(rows.join(' '), width)]; }
+/**
+ * The question's rows for a terminal of `columns`×`rows` (inside a round border with one column of padding, in a frame of
+ * the R1 height). What does not fit is given up in this order: the blank row, the keys row, nested repositories (counted);
+ * then the folder path, the summary and the reason shrink to one row each; then listed files go one by one (counted
+ * instead) and the session line shrinks; at last the rest goes. The title and every choice always show, and the files a
+ * folder holds are named for as long as there is room (measured at 40×12: the list went first and the one file was lost).
+ */
+export function layoutProjectTrustPrompt(model, { columns, rows, selected, platform = process.platform }) {
+    const width = Math.max(1, Math.floor(columns) - 4);
+    const budget = Math.max(1, frameRowsFor(rows, platform) - 2);
+    const choiceRows = model.choices.map(choice => {
+        let label = choice.label;
+        if (choice.id === 'trust-parent' && model.parent && displayWidth(label) > width - 2) {
+            const room = Math.max(4, width - 2 - displayWidth(t('firstrun.trust.choice.parent', { path: '' })));
+            label = t('firstrun.trust.choice.parent', { path: truncateMiddle(model.parent, room) });
+        }
+        return { kind: 'choice', text: truncateDisplay(`${choice.id === selected ? '>' : ' '} ${label}`, width), selected: choice.id === selected };
+    });
+    const title = truncateDisplay(t('firstrun.trust.heading', { title: model.title }), width);
+    let path = wrapDisplay(model.project, width);
+    let reason = wrapWords(model.reason, width);
+    let summary = model.resourceSummary ? wrapWords(model.resourceSummary, width) : [];
+    let session = model.session ? wrapWords(model.session, width) : [];
+    let shown = Math.min(model.resources.length, 8);
+    let nestedList = model.nestedRepositories.length > 0;
+    let nestedCount = false;
+    let blank = true;
+    let keys = true;
+    const more = () => shown < model.resources.length && shown > 0 ? 1 : 0;
+    const nestedRows = () => nestedList ? 1 + model.nestedRepositories.length : nestedCount ? 1 : 0;
+    const total = () => 1 + path.length + reason.length + summary.length + shown + more() + nestedRows() + session.length + (blank ? 1 : 0) + choiceRows.length + (keys ? 1 : 0);
+    /* Each step gives up one thing and says whether it could. */
+    const steps = [
+        () => { if (!blank)
+            return false; blank = false; return true; },
+        () => { if (!keys)
+            return false; keys = false; return true; },
+        () => { if (!nestedList)
+            return false; nestedList = false; nestedCount = true; return true; },
+        () => { if (path.length <= 1)
+            return false; path = [truncateMiddle(model.project, width)]; return true; },
+        () => { if (summary.length <= 1)
+            return false; summary = oneRow(summary, width); return true; },
+        () => { if (reason.length <= 1)
+            return false; reason = oneRow(reason, width); return true; },
+        () => { if (shown === 0)
+            return false; shown -= 1; return true; },
+        () => { if (session.length <= 1)
+            return false; session = oneRow(session, width); return true; },
+        () => { if (!nestedCount)
+            return false; nestedCount = false; return true; },
+        () => { if (!summary.length)
+            return false; summary = []; return true; },
+        () => { if (!reason.length)
+            return false; reason = []; return true; },
+        () => { if (!session.length)
+            return false; session = []; return true; },
+        () => { if (!path.length)
+            return false; path = []; return true; },
+    ];
+    for (const step of steps) {
+        while (total() > budget && step()) { /* keep giving up this part */ }
+        if (total() <= budget)
+            break;
+    }
+    const out = [{ kind: 'title', text: title }];
+    for (const row of path)
+        out.push({ kind: 'path', text: row });
+    for (const row of reason)
+        out.push({ kind: 'text', text: row });
+    for (const row of summary)
+        out.push({ kind: 'dim', text: row });
+    for (const resource of model.resources.slice(0, shown))
+        out.push({ kind: 'dim', text: truncateMiddle(`  - ${resource}`, width) });
+    if (more())
+        out.push({ kind: 'dim', text: truncateDisplay(`  - ${t('firstrun.trust.more', { count: model.resources.length - shown })}`, width) });
+    if (nestedList) {
+        out.push({ kind: 'warning', text: truncateDisplay(t('firstrun.trust.nested'), width) });
+        for (const nested of model.nestedRepositories)
+            out.push({ kind: 'text', text: truncateMiddle(`  - ${nested}`, width) });
+    }
+    else if (nestedCount)
+        out.push({ kind: 'warning', text: truncateDisplay(tn('firstrun.trust.nestedCount', model.nestedRepositories.length), width) });
+    for (const row of session)
+        out.push({ kind: 'warning', text: row });
+    if (blank)
+        out.push({ kind: 'blank', text: '' });
+    out.push(...choiceRows);
+    if (keys)
+        out.push({ kind: 'keys', text: truncateDisplay(t('firstrun.trust.keys'), width) });
+    return out;
+}
+export async function runProjectTrustPrompt(input, io = {}) {
+    const stdin = io.stdin ?? process.stdin;
+    const stdout = io.stdout ?? process.stdout;
+    const env = io.env ?? process.env;
+    const clock = io.clock ?? Date.now;
+    if (!stdin.isTTY || !stdout.isTTY)
+        return 'cancel';
+    let React, Ink;
+    try {
+        React = await import('react');
+        Ink = await import('ink');
+    }
+    catch {
+        throw new Error('TUI_DEPENDENCY_UNAVAILABLE');
+    }
+    const capabilities = detectTerminalCapabilities({ stdinIsTTY: true, stdoutIsTTY: true, color: input.color !== false, env });
+    const session = createTerminalSessionPlan({ capabilities, env });
+    const theme = liveTheme(capabilities, input.theme ?? 'calm').theme;
+    const model = projectTrustPromptModel(input);
+    const ids = model.choices.map(choice => choice.id);
+    const sizeStore = createTerminalSizeStore(stdout, { rows: 24, columns: 80 });
+    let settled = false;
+    let settle = () => { };
+    const choicePromise = new Promise(resolve => { settle = choice => { if (settled)
+        return; settled = true; resolve(choice); }; });
+    /* The grace runs from when the question is drawn: set now, and again when the first frame is committed. */
+    const opened = { at: clock() };
+    function Prompt() {
+        const size = React.useSyncExternalStore(sizeStore.subscribe, sizeStore.getSnapshot, sizeStore.getSnapshot);
+        const [selected, setSelected] = React.useState(model.defaultSelection);
+        /* Read by the key handler synchronously: Ink's input handler may close over an older render. */
+        const selectedRef = React.useRef(model.defaultSelection);
+        const { exit } = Ink.useApp();
+        React.useEffect(() => { opened.at = clock(); }, []);
+        const choose = (choice) => { selectedRef.current = choice; setSelected(choice); };
+        const finish = (choice) => { settle(choice); exit(); };
+        Ink.useInput((value, key) => {
+            if (clock() - opened.at < PROJECT_TRUST_GRACE_MS)
+                return;
+            const lower = typeof value === 'string' ? value.toLowerCase() : '';
+            if (key.escape || (key.ctrl && lower === 'c')) {
+                finish('cancel');
+                return;
+            }
+            if (key.return) {
+                finish(selectedRef.current);
+                return;
+            }
+            if (key.upArrow || key.leftArrow || (key.tab && key.shift)) {
+                choose(nextProjectTrustSelection(selectedRef.current, 'previous', ids));
+                return;
+            }
+            if (key.downArrow || key.rightArrow) {
+                choose(nextProjectTrustSelection(selectedRef.current, 'next', ids));
+                return;
+            }
+            if (key.tab) {
+                choose(nextProjectTrustSelection(selectedRef.current, 'toggle', ids));
+                return;
+            }
+            if (key.ctrl || key.meta)
+                return;
+            const shortcut = model.choices.find(choice => choice.shortcut === lower);
+            if (shortcut)
+                choose(shortcut.id);
+        });
+        const rows = layoutProjectTrustPrompt(model, { columns: size.columns, rows: size.rows, selected });
+        const style = (row) => row.kind === 'title' ? { bold: true, color: theme.colors.warning }
+            : row.kind === 'choice' ? (row.selected ? { bold: true, color: theme.colors.accent } : {})
+                : row.kind === 'warning' ? { color: theme.colors.warning }
+                    : row.kind === 'dim' || row.kind === 'keys' ? { dimColor: true } : {};
+        const children = rows.map((row, index) => React.createElement(Ink.Text, { key: `row-${index}`, wrap: 'truncate', ...style(row) }, row.text || ' '));
+        const box = React.createElement(Ink.Box, { flexDirection: 'column', borderStyle: capabilities.unicode ? 'round' : 'classic', ...(theme.colors.warning ? { borderColor: theme.colors.warning } : {}), paddingX: 1, flexShrink: 0 }, ...children);
+        const frame = terminalFrameProps({ session, ...(theme.colors.background ? { background: theme.colors.background } : {}), rows: size.rows, columns: size.columns });
+        return React.createElement(Ink.Box, frame, box);
+    }
+    const rendered = Ink.render(React.createElement(Prompt), {
+        stdin, stdout, exitOnCtrlC: false,
+        interactive: session.mode === 'plain' ? false : capabilities.interactive,
+        alternateScreen: session.alternateScreen,
+    });
+    const exitPromise = rendered.waitUntilExit().then(() => { if (!settled)
+        settle('cancel'); }, () => { if (!settled)
+        settle('cancel'); });
+    try {
+        const choice = await choicePromise;
+        await exitPromise;
+        return choice;
+    }
+    finally {
+        sizeStore.dispose();
+    }
+}