@ruimte/agents-react 0.0.0 → 0.7.0

package/dist/locales/nl/agent-providers.json

@@ -0,0 +1,131 @@
+{
+  "status": {
+    "checking": "Controleren",
+    "disabled": "Uitgezet",
+    "notFound": "CLI niet gevonden",
+    "signedOut": "Niet ingelogd",
+    "ready": "Ingelogd",
+    "readyPlan": "Ingelogd · {{plan}}",
+    "available": "Klaar",
+    "folderMissing": "Map ontbreekt",
+    "unavailable": "Niet beschikbaar",
+    "failed": "Controle mislukt"
+  },
+  "failed": "De instellingen van de providers konden niet worden getekend",
+  "list": {
+    "label": "Agent-CLI's en hun accounts",
+    "default": "Standaard",
+    "addAccount": "Een {{provider}}-account toevoegen",
+    "notInstalled": "Niet geïnstalleerd",
+    "missing": "Ontbreekt",
+    "notInstalledNote": "Installeer er een en start Ruimte op die machine opnieuw om hem toe te voegen.",
+    "none": "Geen agent-CLI's gevonden op deze machine.",
+    "noAccounts": "Deze machine houdt nog geen accounts bij. Werk Ruimte daar bij om er een toe te voegen."
+  },
+  "abilities": {
+    "version": "Versie {{version}}.",
+    "chatAndTerminal": "Chat en terminal.",
+    "terminalOnly": "Alleen terminal.",
+    "reportsStatus": "Meldt de agentstatus.",
+    "noStatus": "Meldt geen agentstatus."
+  },
+  "cli": {
+    "addAccount": "Account toevoegen",
+    "onlyDefault": "{{provider}} heeft geen instelling voor zijn configuratiemap, dus alleen zijn standaardaccount.",
+    "defaults": {
+      "title": "Standaarden voor nieuwe chats",
+      "description": "Een model of account kiezen in een chat verandert hier ook de standaard.",
+      "account": "Account",
+      "accountFor": "Standaardaccount voor {{provider}}",
+      "model": "Model",
+      "modelFor": "Standaardmodel voor {{provider}}",
+      "shared": "Gedeeld door elk {{provider}}-account.",
+      "usesCliDefault": "Gebruikt het standaardmodel van de CLI zelf.",
+      "providerDefault": "Standaard van de provider",
+      "legacyModel": "{{name}} (legacy)"
+    },
+    "accounts": "Accounts"
+  },
+  "account": {
+    "kind": "{{provider}}-account",
+    "enabled": {
+      "label": "Dit account gebruiken",
+      "description": "Uitgezet wordt het niet aangeboden voor nieuwe chats en agents."
+    },
+    "showFolder": "Map tonen",
+    "folderCopied": "Pad van de map gekopieerd",
+    "name": "Naam",
+    "color": "Kleur",
+    "login": {
+      "title": "Login",
+      "signedInAs": "Ingelogd als {{email}}",
+      "signedIn": "Ingelogd",
+      "planDetail": "{{plan}}-abonnement. Opnieuw inloggen opent een terminal-node met de login van de CLI zelf.",
+      "detail": "Opnieuw inloggen opent een terminal-node met de login van de CLI zelf.",
+      "signedOut": "Niet ingelogd",
+      "signedOutDetail": "Opent een terminal-node die de login van de CLI met deze map draait.",
+      "logIn": "Inloggen",
+      "logInAgain": "Opnieuw inloggen"
+    },
+    "folder": {
+      "label": "Map",
+      "detail": "Aan de CLI gegeven als <code>{{variable}}</code>. De CLI bewaart hier zijn eigen login, instellingen en geschiedenis.",
+      "detailPlain": "De CLI bewaart hier zijn eigen login, instellingen en geschiedenis."
+    },
+    "variables": {
+      "title": "Variabelen",
+      "description": "Extra omgeving voor alleen dit account. Gevoelige waarden blijven in de sleutelhanger.",
+      "add": "Variabele toevoegen",
+      "name": "Naam van variabele {{index}}",
+      "value": "Waarde van {{name}}",
+      "kept": "Bewaard in de sleutelhanger",
+      "lock": "{{name}} in de sleutelhanger bewaren",
+      "unlock": "{{name}} als platte tekst bewaren",
+      "noKeychain": "Deze machine heeft geen sleutelhanger, dus een waarde kan niet geheim blijven.",
+      "remove": "{{name}} verwijderen",
+      "none": "Geen variabelen",
+      "discard": "Weggooien",
+      "problem": {
+        "noName": "Elke variabele heeft een naam nodig.",
+        "invalidName": "{{name}} is geen naam voor een variabele.",
+        "duplicate": "{{name}} staat er twee keer in.",
+        "noValue": "{{name}} heeft een waarde nodig."
+      }
+    },
+    "remove": {
+      "label": "Account verwijderen",
+      "description": "Chats die het gebruiken vragen bij hun volgende turn om een ander account. De map blijft op de schijf.",
+      "defaultNote": "Het standaardaccount gebruikt de eigen map van de CLI en kan niet weg. Zet het in plaats daarvan hierboven uit.",
+      "button": "Verwijderen",
+      "confirmTitle": "{{account}} verwijderen?",
+      "confirmDescription": "Ruimte vergeet dit account. De map blijft op de schijf staan op {{folder}}, met de login erin.",
+      "confirm": "Account verwijderen"
+    },
+    "saveFailed": "Kon het account niet opslaan"
+  },
+  "add": {
+    "title": "Een {{provider}}-account toevoegen",
+    "description": "Ruimte maakt er een map voor op de machine en opent dan een terminal-node waarin je inlogt.",
+    "name": "Naam",
+    "namePlaceholder": "Werk",
+    "color": "Kleur",
+    "advanced": "Geavanceerd",
+    "link": {
+      "label": "Een bestaande map koppelen",
+      "description": "Gebruik een configuratiemap die al op de machine staat in plaats van een nieuwe. Ruimte verplaatst of verwijdert hem nooit.",
+      "placeholder": "Pad op de machine"
+    },
+    "create": "Account toevoegen",
+    "linkButton": "Map koppelen",
+    "failed": "Kon het account niet toevoegen"
+  },
+  "section": {
+    "label": "Providers",
+    "description": "De agent-CLI's op deze machine en de accounts waarmee ze inloggen."
+  },
+  "notAnswering": "Geeft geen antwoord. Pas dit aan zodra de machine terug is.",
+  "common": {
+    "save": "Opslaan",
+    "cancel": "Annuleren"
+  }
+}

package/dist/locales/nl/agent-usage.json

@@ -0,0 +1,131 @@
+{
+  "limits": {
+    "title": "Limieten",
+    "explain": "Het streepje op een balk laat zien hoeveel van het venster voorbij is. Een balk voorbij dat streepje verbruikt sneller dan het venster teruggeeft.",
+    "loading": "Limieten laden…",
+    "used": "{{percent}}% gebruikt",
+    "bar": "{{window}}, {{percent}}% gebruikt",
+    "windowPassed": "{{percent}}% van het venster voorbij",
+    "faster": "Verbruikt sneller dan het venster teruggeeft.",
+    "slower": "Verbruikt langzamer dan het venster teruggeeft.",
+    "resets": "Reset {{at}}",
+    "none": "Nog geen limieten gemeld.",
+    "notInstalled": "Niet geïnstalleerd op deze machine.",
+    "noSubscription": "Dit account gebruikt een API-sleutel en kent geen abonnementslimieten.",
+    "unreachable": "De CLI was niet bereikbaar.",
+    "filter": "Accounts waarvan je de limieten ziet",
+    "signedOut": "Niet ingelogd",
+    "signedOutDetail": "Niet ingelogd. Log in om de limieten te zien.",
+    "logIn": "Inloggen",
+    "nextReset": "{{window}} reset {{at}}",
+    "checked": {
+      "now": "nu",
+      "ago": "{{duration}} geleden",
+      "fromTurn": "Uit een turn · {{when}}"
+    }
+  },
+  "settings": {
+    "currency": {
+      "label": "Valuta",
+      "dollars": "Prijzen zoals gepubliceerd, in dollars.",
+      "noRate": "Nog geen wisselkoers. De pagina toont dollars zolang die er niet is.",
+      "converted": "Omgerekend met de ECB-referentiekoers van {{date}}.",
+      "options": {
+        "USD": "Dollars",
+        "EUR": "Euro's"
+      }
+    },
+    "page": {
+      "label": "Verbruikspagina",
+      "description": "Kosten, tokens en planlimieten, per account.",
+      "open": "Verbruik openen"
+    }
+  },
+  "section": {
+    "label": "Verbruik",
+    "description": "De valuta van de verbruikspagina."
+  },
+  "dialog": {
+    "title": "Verbruik",
+    "description": "Kosten, tokens en limieten van je abonnement",
+    "close": "Verbruik sluiten",
+    "rescan": "Opnieuw scannen",
+    "period": "Periode",
+    "metric": "Eenheid",
+    "failed": "Verbruik kon niet worden getekend",
+    "periods": {
+      "today": "Vandaag",
+      "7d": "7 dagen",
+      "30d": "30 dagen",
+      "90d": "90 dagen"
+    },
+    "metrics": {
+      "cost": "Kosten",
+      "tokens": "Tokens"
+    },
+    "accounts": {
+      "label": "Account",
+      "all": "Alle accounts"
+    }
+  },
+  "empty": {
+    "noTranscripts": "Geen transcripts van Claude of Codex gevonden. De machine leest ~/.claude/projects en ~/.codex/sessions.",
+    "noUsage": "Nog geen verbruik op deze machine."
+  },
+  "agents": {
+    "none": "Op deze machine staat geen agent-CLI.",
+    "installed": "Deze machine heeft {{list}}.",
+    "settings": "Agent-instellingen"
+  },
+  "provenance": {
+    "failed": "Kon de transcripts niet lezen. Dit is de laatste scan die wel lukte.",
+    "scanned_one": "Gescand om {{time}}, {{files}} bestand",
+    "scanned_other": "Gescand om {{time}}, {{files}} bestanden",
+    "bundledPrices": "Prijzen uit de meegeleverde tabel",
+    "fetchedPrices": "Prijzen van LiteLLM, {{date}}",
+    "rate": "{{currency}} tegen de ECB-koers van {{date}}"
+  },
+  "summary": {
+    "sessions_one": "{{sessions}} sessie",
+    "sessions_other": "{{sessions}} sessies",
+    "calls_one": "{{calls}} aanroep",
+    "calls_other": "{{calls}} aanroepen",
+    "apiRates": "tegen API-tarieven"
+  },
+  "tiles": {
+    "processed": "Verwerkt",
+    "uncachedInput": "Input zonder cache",
+    "cachedInput": "Input uit cache",
+    "cacheWrites": "Naar cache geschreven",
+    "output": "Output",
+    "cacheSavings": "Bespaard met cache"
+  },
+  "chart": {
+    "total": "Totaal"
+  },
+  "breakdown": {
+    "title": "Uitsplitsing",
+    "tabs": {
+      "models": "Modellen",
+      "projects": "Projecten",
+      "day": "Dag"
+    },
+    "models": {
+      "model": "Model",
+      "calls": "Aanroepen",
+      "input": "Input",
+      "output": "Output",
+      "cache": "Cache R/W",
+      "cost": "Kosten",
+      "share": "Aandeel",
+      "pricedAs": "Geprijsd als {{model}}",
+      "noPrice": "Geen prijs bekend voor dit model"
+    },
+    "days": {
+      "day": "Dag",
+      "total": "Totaal",
+      "tokens": "Tokens",
+      "empty": "Geen activiteit in deze periode."
+    }
+  }
+}

package/dist/locales.d.ts

@@ -0,0 +1,5 @@
+type Bundle = Record<string, unknown>;
+export declare const AGENTS_NAMESPACES: readonly ['agent-chat', 'agent-prompts', 'agent-providers', 'agent-usage'];
+export type AgentsNamespace = (typeof AGENTS_NAMESPACES)[number];
+export declare const AGENTS_LOCALES: Record<string, () => Promise<Record<AgentsNamespace, Bundle>>>;
+export {};

package/dist/locales.js

@@ -0,0 +1,18 @@
+/* The words of this package, a namespace per surface, which the app adds to its i18next beside its own namespaces. */
+export const AGENTS_NAMESPACES = ['agent-chat', 'agent-prompts', 'agent-providers', 'agent-usage'];
+const open = async (files) => Object.fromEntries(await Promise.all(Object.entries(files).map(async ([namespace, file]) => [namespace, (await file()).default])));
+/* One loader per language that answers every namespace of it, so a bundler splits them and a window only downloads the language it shows. */
+export const AGENTS_LOCALES = {
+    en: () => open({
+        'agent-chat': () => import('./locales/en/agent-chat.json'),
+        'agent-prompts': () => import('./locales/en/agent-prompts.json'),
+        'agent-providers': () => import('./locales/en/agent-providers.json'),
+        'agent-usage': () => import('./locales/en/agent-usage.json')
+    }),
+    nl: () => open({
+        'agent-chat': () => import('./locales/nl/agent-chat.json'),
+        'agent-prompts': () => import('./locales/nl/agent-prompts.json'),
+        'agent-providers': () => import('./locales/nl/agent-providers.json'),
+        'agent-usage': () => import('./locales/nl/agent-usage.json')
+    })
+};

package/dist/mounted-registry.d.ts

@@ -0,0 +1,7 @@
+export interface MountedEntry {
+    attached: boolean;
+}
+export declare class MountedRegistry<T extends MountedEntry> extends Map<string, T> {
+    detachAll(report?: (id: string, entry: T) => void): void;
+    reattachAll(reattach: (id: string, entry: T) => Promise<void>): Promise<void>;
+}

package/dist/mounted-registry.js

@@ -0,0 +1,39 @@
+// Enough to hide the round trips of a slow link, few enough that a first screen is not queued behind twenty.
+const REATTACH_CONCURRENCY = 4;
+/*
+ * What a client keeps for the nodes it has open on one machine, and the reconnect discipline they
+ * all share: a lost socket detaches everything, and the socket that comes back attaches it again.
+ * The host on the other side is a fresh one as far as this client knows, so nothing is assumed.
+ */
+export class MountedRegistry extends Map {
+    /* Nothing is attached over a link that is gone; `report` is how a store hears about it. */
+    detachAll(report) {
+        for (const [id, entry] of this) {
+            entry.attached = false;
+            report?.(id, entry);
+        }
+    }
+    /*
+     * One pass over what is mounted but not attached, in mount order, a few at a time. It works on a
+     * copy, because attaching mounts and unmounts as it goes. An entry that left in the meantime is
+     * skipped, since a node may leave the canvas while its attach is on the wire.
+     */
+    async reattachAll(reattach) {
+        const queue = [...this];
+        const work = async () => {
+            for (let next = queue.shift(); next !== undefined; next = queue.shift()) {
+                const [id, entry] = next;
+                if (entry.attached || this.get(id) !== entry) {
+                    continue;
+                }
+                try {
+                    await reattach(id, entry);
+                }
+                catch {
+                    // A socket that dropped again brings the next pass; anything else surfaces on the next mount.
+                }
+            }
+        };
+        await Promise.all(Array.from({ length: REATTACH_CONCURRENCY }, work));
+    }
+}

package/dist/port-transport.d.ts

@@ -0,0 +1,6 @@
+import type { FramePort } from '@ruimte/agent-contracts/port';
+import { type ChatTransport } from './transport';
+export interface PortTransport extends ChatTransport {
+    close(): void;
+}
+export declare const portTransport: (port: FramePort) => PortTransport;

package/dist/port-transport.js

@@ -0,0 +1,120 @@
+import i18next from 'i18next';
+import { parseServerFrame } from '@ruimte/agent-contracts/envelope';
+import { AGENT_EVENT_SCHEMAS, AGENT_REQUEST_SCHEMAS } from '@ruimte/agent-contracts/protocol';
+import { ChatTransportError } from './transport';
+const isEventType = (event) => Object.hasOwn(AGENT_EVENT_SCHEMAS, event);
+/*
+ * A chat host at the other end of a port, such as a process that runs the chats beside the window.
+ * A port does not drop and come back the way a socket does, so it is open from the first request
+ * until `close`. Frames are checked where they arrive, and a frame that does not hold up is dropped
+ * with a warning, the way the socket transport of an app drops one.
+ */
+export const portTransport = (port) => {
+    let status = 'open';
+    let nextId = 1;
+    const pending = new Map();
+    const eventHandlers = new Map();
+    const statusHandlers = new Set();
+    const answer = (id, frame) => {
+        const entry = pending.get(id);
+        if (!entry) {
+            return;
+        }
+        pending.delete(id);
+        if (!frame.ok) {
+            entry.reject(new ChatTransportError(frame.error.code, frame.error.message));
+            return;
+        }
+        const result = AGENT_REQUEST_SCHEMAS[entry.type].result.safeParse(frame.result);
+        if (!result.success) {
+            entry.reject(new ChatTransportError('bad-reply', i18next.t('agent-chat:transport.badReply', { type: entry.type })));
+            return;
+        }
+        entry.resolve(result.data);
+    };
+    const dispatch = (event, payload) => {
+        if (!isEventType(event)) {
+            console.warn('Dropped an unknown event', event);
+            return;
+        }
+        const parsed = AGENT_EVENT_SCHEMAS[event].safeParse(payload);
+        if (!parsed.success) {
+            console.warn(`Dropped a malformed ${event} event`);
+            return;
+        }
+        // A copy, so a handler that unsubscribes while it runs does not change the set being walked.
+        for (const handler of [...(eventHandlers.get(event) ?? [])]) {
+            handler(parsed.data);
+        }
+    };
+    const stopListening = port.onFrame((raw) => {
+        if (status === 'closed') {
+            return;
+        }
+        const parsed = parseServerFrame(raw);
+        if (!parsed.ok) {
+            console.warn('Dropped a malformed frame', parsed.message);
+            return;
+        }
+        const frame = parsed.value;
+        if ('event' in frame) {
+            dispatch(frame.event, frame.payload);
+            return;
+        }
+        if (frame.id === null) {
+            // An answer without an id is about a frame the host could not read; nothing waits for it.
+            console.warn('The chat host refused a frame', frame);
+            return;
+        }
+        answer(frame.id, frame);
+    });
+    return {
+        get status() {
+            return status;
+        },
+        request(type, payload) {
+            if (status !== 'open') {
+                return Promise.reject(new ChatTransportError('not-connected', i18next.t('agent-chat:transport.notConnected')));
+            }
+            const id = String(nextId++);
+            const promise = new Promise((resolve, reject) => {
+                pending.set(id, { type, resolve: resolve, reject });
+            });
+            port.send({ id, type, payload });
+            return promise;
+        },
+        on(event, handler) {
+            let handlers = eventHandlers.get(event);
+            if (!handlers) {
+                handlers = new Set();
+                eventHandlers.set(event, handlers);
+            }
+            const set = handlers;
+            set.add(handler);
+            return () => {
+                set.delete(handler);
+            };
+        },
+        subscribeStatus(handler) {
+            statusHandlers.add(handler);
+            return () => {
+                statusHandlers.delete(handler);
+            };
+        },
+        close() {
+            if (status === 'closed') {
+                return;
+            }
+            status = 'closed';
+            stopListening();
+            const waiting = [...pending.values()];
+            pending.clear();
+            for (const entry of waiting) {
+                entry.reject(new ChatTransportError('disconnected', i18next.t('agent-chat:transport.closedBeforeAnswer')));
+            }
+            for (const handler of [...statusHandlers]) {
+                handler(status);
+            }
+        }
+    };
+};

package/dist/prompts/logic/focus.d.ts

@@ -0,0 +1 @@
+export declare const focusPromptStart: (root: ParentNode | null | undefined) => boolean;

package/dist/prompts/logic/focus.js

@@ -0,0 +1,17 @@
+/*
+ * Puts the keyboard on where a card is answered: a question's choice or field, else the first of a
+ * request's buttons. Allow is drawn last and filled, so it only gets the keyboard when it stands alone,
+ * and a stray Enter never grants anything. False when `root` holds no card.
+ */
+export const focusPromptStart = (root) => {
+    const card = root?.querySelector('.prompt-card');
+    if (!card) {
+        return false;
+    }
+    const start = card.querySelector('[data-prompt-entry]:not(:disabled)') ??
+        card.querySelector('[role="toolbar"] button:not(:disabled):not([data-prompt-primary])') ??
+        card.querySelector('[data-prompt-primary]:not(:disabled)') ??
+        card.querySelector('.prompt-heading');
+    start?.focus({ preventScroll: true });
+    return start !== null;
+};

package/dist/prompts/logic/keys.d.ts

@@ -0,0 +1,42 @@
+import { type KeyLike } from '@ruimte/ui/shortcut';
+export declare const PROMPT_SHORTCUTS: {
+    readonly primary: import("@ruimte/ui/shortcut").Shortcut;
+    readonly previousPrompt: import("@ruimte/ui/shortcut").Shortcut;
+    readonly nextPrompt: import("@ruimte/ui/shortcut").Shortcut;
+};
+export type PromptKeyEvent = KeyLike & {
+    isComposing: boolean;
+};
+export type ListStep = 'previous' | 'next' | 'first' | 'last';
+export type ChoiceKeyAction = {
+    kind: 'move';
+    to: ListStep;
+} | {
+    kind: 'pick';
+} | {
+    kind: 'pick-and-commit';
+} | {
+    kind: 'commit';
+};
+export type AnswerFieldKeyAction = {
+    kind: 'to-last-choice';
+} | {
+    kind: 'commit';
+} | {
+    kind: 'ignore';
+};
+export declare const stepIndex: (index: number, count: number, to: ListStep) => number;
+export declare const choiceKey: (event: PromptKeyEvent, { multiSelect, anyChosen }: {
+    multiSelect: boolean;
+    anyChosen: boolean;
+}) => ChoiceKeyAction | null;
+export declare const answerFieldKey: (event: PromptKeyEvent, { belowChoices, caretAtStart, hasText }: {
+    belowChoices: boolean;
+    caretAtStart: boolean;
+    hasText: boolean;
+}) => AnswerFieldKeyAction | null;
+export declare const headingKey: (event: PromptKeyEvent) => boolean;
+export declare const toolbarKey: (event: PromptKeyEvent) => ListStep | null;
+export declare const isPrimaryKey: (event: PromptKeyEvent, apple: boolean) => boolean;
+export declare const pageKey: (event: PromptKeyEvent, apple: boolean, typing: boolean) => -1 | 1 | null;
+export declare const staysInCard: (event: PromptKeyEvent) => boolean;

package/dist/prompts/logic/keys.js

@@ -0,0 +1,84 @@
+import { matchesShortcut, shortcut } from '@ruimte/ui/shortcut';
+/*
+ * The keys inside a prompt card. Bare keys are allowed here and nowhere else on a canvas because a card
+ * is a widget the keyboard is already in. They only mean something while the focus is inside one.
+ */
+export const PROMPT_SHORTCUTS = {
+    primary: shortcut('Mod+Enter'),
+    previousPrompt: shortcut('Mod+Shift+ArrowLeft'),
+    nextPrompt: shortcut('Mod+Shift+ArrowRight')
+};
+const isPlain = (event) => !event.ctrlKey && !event.metaKey && !event.altKey && !event.shiftKey && !event.isComposing;
+const LIST_KEYS = { ArrowUp: 'previous', ArrowDown: 'next', Home: 'first', End: 'last' };
+const TOOLBAR_KEYS = { ArrowLeft: 'previous', ArrowRight: 'next', Home: 'first', End: 'last' };
+/* Both lists wrap, the way a radio group does. */
+export const stepIndex = (index, count, to) => {
+    if (count === 0) {
+        return -1;
+    }
+    switch (to) {
+        case 'first':
+            return 0;
+        case 'last':
+            return count - 1;
+        case 'previous':
+            return (index - 1 + count) % count;
+        case 'next':
+            return (index + 1) % count;
+    }
+};
+/*
+ * A choice of a question. Enter on a multi select question only moves on once something is chosen, so
+ * the first Enter on an empty question picks the choice instead of doing nothing.
+ */
+export const choiceKey = (event, { multiSelect, anyChosen }) => {
+    if (!isPlain(event)) {
+        return null;
+    }
+    const step = LIST_KEYS[event.key];
+    if (step) {
+        return { kind: 'move', to: step };
+    }
+    if (event.code === 'Space') {
+        return { kind: 'pick' };
+    }
+    if (event.key === 'Enter') {
+        if (!multiSelect) {
+            return { kind: 'pick-and-commit' };
+        }
+        return anyChosen ? { kind: 'commit' } : { kind: 'pick' };
+    }
+    return null;
+};
+/* A written answer: under the choices ("Something else…") or the only field of a question without choices. */
+export const answerFieldKey = (event, { belowChoices, caretAtStart, hasText }) => {
+    if (!isPlain(event)) {
+        return null;
+    }
+    if (event.key === 'ArrowUp' && belowChoices && caretAtStart) {
+        return { kind: 'to-last-choice' };
+    }
+    if (event.key === 'Enter') {
+        // An empty answer is not sent, and an empty line in front of the answer is never what Enter meant.
+        return hasText ? { kind: 'commit' } : { kind: 'ignore' };
+    }
+    return null;
+};
+export const headingKey = (event) => isPlain(event) && event.key === 'ArrowDown';
+export const toolbarKey = (event) => (isPlain(event) ? (TOOLBAR_KEYS[event.key] ?? null) : null);
+export const isPrimaryKey = (event, apple) => !event.isComposing && matchesShortcut(PROMPT_SHORTCUTS.primary, event, apple);
+/* Paging through a stack. In a text field these keys select to the start or end of the line, so they stay there. */
+export const pageKey = (event, apple, typing) => {
+    if (typing || event.isComposing) {
+        return null;
+    }
+    if (matchesShortcut(PROMPT_SHORTCUTS.previousPrompt, event, apple)) {
+        return -1;
+    }
+    return matchesShortcut(PROMPT_SHORTCUTS.nextPrompt, event, apple) ? 1 : null;
+};
+/*
+ * A key without Ctrl, Cmd or Alt never leaves a card: arrows would reach the canvas, Space would start a
+ * pan and Backspace would delete the selected nodes. Escape and Tab still go on, since they leave the card.
+ */
+export const staysInCard = (event) => !event.ctrlKey && !event.metaKey && !event.altKey && event.key !== 'Escape' && event.key !== 'Tab';

package/dist/prompts/logic/prompts.d.ts

@@ -0,0 +1,34 @@
+import type { ChatApprovalItem, ChatQuestionItem, ChatQuestion } from '@ruimte/agent-contracts';
+export type PendingPrompt = ChatApprovalItem | ChatQuestionItem;
+export type PromptAction = {
+    kind: 'approve';
+    decision: 'allow' | 'allow-always' | 'deny';
+    message?: string;
+} | {
+    kind: 'answer';
+    answers: Record<string, string>;
+} | {
+    kind: 'dismiss';
+} | {
+    kind: 'choose';
+    choiceId: string;
+};
+export interface PromptAnswer {
+    choices: string[];
+    text: string;
+    custom: boolean;
+}
+export interface PromptDraft {
+    index: number;
+    answers: Record<string, PromptAnswer>;
+    reason: string;
+    showReason: boolean;
+}
+export declare const emptyPromptDraft: () => PromptDraft;
+export declare const answerValue: (answer: PromptAnswer) => string;
+export declare const questionAnswer: (draft: PromptDraft, question: ChatQuestion) => PromptAnswer;
+export declare function pickPromptChoice(answer: PromptAnswer, question: ChatQuestion, label: string): PromptAnswer;
+export declare const isBlockingPrompt: (item: PendingPrompt) => boolean;
+export declare const orderPrompts: <T>(prompts: readonly T[], blocking: (prompt: T) => boolean, createdAt: (prompt: T) => number) => T[];
+export declare function nextPrompt(items: readonly PendingPrompt[], activeId: string | null): PendingPrompt | null;
+export declare function promptAnswers(item: ChatQuestionItem, draft: PromptDraft): Record<string, string> | null;

package/dist/prompts/logic/prompts.fixtures.d.ts

@@ -0,0 +1,5 @@
+import type { PendingPrompt } from './prompts';
+export declare const PROMPT_SAMPLES: Array<{
+    label: string;
+    items: PendingPrompt[];
+}>;