soja-cli 1.4.0

package/dist/ui/mascot/scenes/syncing.js

@@ -0,0 +1,116 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion -- scene arrays are indexed within their declared bounds. */
+import { blink, drawCloud, drawGround, mirror, rng, soilLine, withFace } from '../engine.js';
+const W = 78;
+const H = 12;
+const G = 10;
+const LAPTOP = [' .-------. ', ' |       | ', ' |_______| ', '/_________\\'];
+const SERVER = [' .------. ', ' |[    ]| ', ' |[    ]| ', ' |[    ]| ', " '------' "];
+const LOAD_REACH = mirror([' .-.  ', '(o.o) ', '(   )_', " ' '  "]);
+const LOAD_PUT = [' .-.  ', '(o.o) ', '(   )_', " ' '  "];
+const BELT_L = 18;
+const BELT_R = 60;
+const WIRE_Y = 2;
+export const syncing = {
+    id: 'syncing',
+    title: 'Sincronizando',
+    useFor: 'Cargando / sincronizando datos',
+    width: W,
+    height: H,
+    create(seed = 7) {
+        const r = rng(seed);
+        const soil = [soilLine(W, r)];
+        let t = 0;
+        let progress = 0;
+        let doneT = 0;
+        let up = [];
+        let down = [];
+        let loadT = 0;
+        let unloadT = 0;
+        return {
+            step() {
+                t++;
+                if (doneT) {
+                    doneT--;
+                    if (!doneT)
+                        progress = 0;
+                    return;
+                }
+                if (t % 14 === 0) {
+                    up.push({ x: BELT_L });
+                    loadT = 6;
+                }
+                if (t % 22 === 11)
+                    down.push({ x: 66 });
+                for (const p of up)
+                    p.x += 0.5;
+                for (const p of down)
+                    p.x -= 0.6;
+                if (up.length && up[0].x >= BELT_R - 1) {
+                    up.shift();
+                    unloadT = 6;
+                    progress = Math.min(100, progress + 7);
+                }
+                if (down.length && down[0].x <= 10) {
+                    down.shift();
+                    progress = Math.min(100, progress + 3);
+                }
+                if (loadT)
+                    loadT--;
+                if (unloadT)
+                    unloadT--;
+                if (progress >= 100) {
+                    doneT = 30;
+                    up = [];
+                    down = [];
+                }
+            },
+            draw(c) {
+                drawCloud(c, t, 0.05, 20, 0, false);
+                drawGround(c, G, soil);
+                c.sprite(0, G - 4, LAPTOP, 'rock');
+                const bars = Math.floor(t / 2) % 5;
+                c.put(3, G - 3, '>'.padEnd(bars + 1, '_'), 'accent');
+                c.sprite(68, G - 5, SERVER, 'rock');
+                for (let i = 0; i < 3; i++) {
+                    const on = (Math.floor(t / 3) + i) % 3 === 0 || doneT > 0;
+                    c.put(71, G - 4 + i, on ? '■■■■' : '····', on ? 'good' : 'cloud');
+                }
+                for (let x = 6; x < 73; x++)
+                    c.put(x, WIRE_Y, '-', 'cloud');
+                c.put(5, WIRE_Y, '+', 'rock');
+                c.put(73, WIRE_Y, '+', 'rock');
+                for (let y = WIRE_Y + 1; y < G - 4; y++) {
+                    c.put(5, y, '|', 'rock');
+                    c.put(73, y, '|', 'rock');
+                }
+                for (const p of down) {
+                    c.put(p.x + 1, WIRE_Y, 'T', 'rock');
+                    c.put(p.x, WIRE_Y + 1, '[=]', 'accent');
+                }
+                const phase = Math.floor(t / 2) % 3;
+                for (let x = BELT_L; x <= BELT_R + 2; x++)
+                    c.put(x, G - 1, (x + phase) % 3 === 0 ? 'o' : '=', 'rock');
+                for (const p of up)
+                    c.put(p.x, G - 2, '[#]', 'dirt');
+                c.sprite(11, G - 4, withFace(loadT > 3 ? LOAD_PUT : LOAD_REACH, doneT ? '^.^' : blink(t, 1)), 'agent');
+                c.sprite(62, G - 4, withFace(unloadT > 3 ? mirror(LOAD_PUT) : LOAD_PUT, doneT ? '^.^' : blink(t, 2)), 'agent');
+                const cx = 36 + Math.round(Math.sin(t * 0.05) * 6);
+                c.sprite(cx, G - 7, withFace([' .-. ', '(o.o)', '(   )[='], doneT ? '^.^' : blink(t, 3, 'o.O')), 'agent');
+                c.put(cx + 1, G - 4, "' '", 'agent');
+                for (let y = WIRE_Y + 1; y < G - 3; y++) {
+                    c.put(cx - 1, y, '|', 'rock');
+                    c.put(cx + 7, y, '|', 'rock');
+                }
+                c.put(cx - 1, WIRE_Y, 'Y', 'rock');
+                c.put(cx + 7, WIRE_Y, 'Y', 'rock');
+                c.put(cx - 1, G - 3, '\\_______/', 'wood');
+                if (doneT && t % 10 < 6)
+                    c.put(cx + 9, G - 7, '(listo!)', 'good');
+            },
+            status() {
+                const lv = Math.round(progress / 20);
+                return doneT ? 'sincronizado ✓' : `sincronizando ${'▮'.repeat(lv)}${'▯'.repeat(5 - lv)} ${progress}%`;
+            },
+        };
+    },
+};

package/dist/ui/mascot/scenes/working.js

@@ -0,0 +1,193 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion -- scene arrays are indexed within their declared bounds. */
+import { blink, drawCloud, drawGround, mirror, rng, soilLine, withFace, } from '../engine.js';
+const W = 78;
+const H = 15;
+const G = 10;
+const PICK_UP = [' .-.  _.', '(o.o)/  ', '(   )   ', " ' '    "];
+const PICK_DOWN = [' .-.    ', '(o.o)   ', '(   )\\_ ', " ' '  ' "];
+const SHOVEL_DIG = [' .-.     ', '(o.o)    ', '(   )\\   ', " ' ' \\_  "];
+const SHOVEL_LIFT = [' .-. _.:_', '(o.o)/   ', '(   )    ', " ' '     "];
+const CARRY_A = [' .-.  ', '(o.o) ', '(   )=', " ' '  "];
+const CARRY_B = [' .-.  ', '(o.o) ', '(   )=', "  ' ' "];
+const PLACE = [' .-.    ', '(o.o)__ ', '(   )   ', " ' '    "];
+const BACK_A = mirror([' .-. ', '(o.o)', '(   )', " ' ' "]);
+const BACK_B = mirror([' .-. ', '(o.o)', '(   )', "  ' '"]);
+const CROUCH = mirror(['      ', ' .-.  ', '(o.o)\\', " ' '  "]);
+const ROCK = ['  ▄▓▄  ', ' ▓▓▒▓▓ ', '▓▒▓▓▓▒▓', '▓▓▓▒▓▓▓'];
+const BLOCKS = ['▓▒▓', '▓▓▒', '▒▓▓'];
+const PILE = [
+    [],
+    ['  .  '],
+    [' .:. '],
+    ['.:::.', '  .  '],
+    [':::::', '.:::.', ' .:. '],
+    [':::::::', ':::::', '.:::.', ' .:. '],
+];
+const WALL_X = 68;
+const WALL_COLS = 3;
+const WALL_MAX = 15;
+export const working = {
+    id: 'working',
+    title: 'Trabajando',
+    useFor: 'Tareas en progreso',
+    width: W,
+    height: H,
+    create(seed = 1) {
+        const r = rng(seed);
+        const soil = Array.from({ length: H - G - 1 }, () => soilLine(W, r));
+        const miners = [
+            { x: 1, off: 0, m: false, sx: 8, n: 1 },
+            { x: 14, off: 5, m: true, sx: 14, n: 2 },
+        ];
+        const shovelers = [
+            { x: 24, off: 0, m: false, hole: 29, px: 31, vx: 0.55, n: 3 },
+            { x: 37, off: 6, m: true, hole: 38, px: 39, vx: -0.55, n: 4 },
+        ];
+        const carriers = [
+            { x: 52, st: 'pick', k: 0, n: 5, happy: -99 },
+            { x: 59, st: 'back', k: 0, n: 6, happy: -99 },
+        ];
+        let t = 0;
+        let placed = 0;
+        let dirt = 0;
+        let hits = 0;
+        let hold = 0;
+        let msg = '';
+        let parts = [];
+        let sparks = [];
+        return {
+            step() {
+                t++;
+                for (const a of miners) {
+                    if ((t + a.off) % 10 === 6) {
+                        hits++;
+                        sparks.push({ x: a.sx, y: G - 2, l: 2 });
+                        for (let i = 0; i < 2; i++) {
+                            parts.push({
+                                x: a.sx,
+                                y: G - 3,
+                                vx: (a.m ? 1 : -1) * (0.3 + r() * 0.5),
+                                vy: -0.5 - r() * 0.3,
+                                ch: ".'`"[i % 3],
+                                tone: 'rock',
+                            });
+                        }
+                        msg = `agente-0${a.n}: picando roca`;
+                    }
+                }
+                for (const a of shovelers) {
+                    const p = (t + a.off) % 12;
+                    if (p === 6 || p === 7) {
+                        parts.push({ x: a.px, y: G - 4, vx: a.vx + (r() - 0.5) * 0.1, vy: -0.5, ch: p === 6 ? ':' : '.', tone: 'dirt' });
+                        if (p === 6) {
+                            dirt++;
+                            msg = `agente-0${a.n}: sacando tierra`;
+                        }
+                    }
+                }
+                for (const a of carriers) {
+                    a.k++;
+                    if (a.st === 'pick' && a.k > 4) {
+                        a.st = 'go';
+                        a.k = 0;
+                    }
+                    else if (a.st === 'go') {
+                        a.x += 0.5;
+                        if (a.x >= 59) {
+                            a.st = 'place';
+                            a.k = 0;
+                        }
+                    }
+                    else if (a.st === 'place' && a.k === 2) {
+                        if (placed < WALL_MAX && !hold) {
+                            placed++;
+                            a.happy = t;
+                            msg = `agente-0${a.n}: bloque ${placed} colocado`;
+                        }
+                    }
+                    else if (a.st === 'place' && a.k > 4) {
+                        a.st = 'back';
+                        a.k = 0;
+                    }
+                    else if (a.st === 'back') {
+                        a.x -= 0.5;
+                        if (a.x <= 52) {
+                            a.st = 'pick';
+                            a.k = 0;
+                        }
+                    }
+                }
+                if (placed >= WALL_MAX && !hold) {
+                    hold = 30;
+                    msg = 'muro completo';
+                }
+                if (hold) {
+                    hold--;
+                    if (!hold) {
+                        placed = 0;
+                        dirt = 0;
+                    }
+                }
+                for (const p of parts) {
+                    p.x += p.vx;
+                    p.y += p.vy;
+                    p.vy += 0.12;
+                }
+                parts = parts.filter((p) => p.y < G - 0.5 && p.x >= 0 && p.x < W);
+                for (const s of sparks)
+                    s.l--;
+                sparks = sparks.filter((s) => s.l > 0);
+            },
+            draw(c) {
+                drawCloud(c, t, 0.06, 0, 1);
+                drawCloud(c, t, 0.04, 40, 3, false);
+                drawGround(c, G, soil);
+                for (const a of shovelers) {
+                    for (let i = a.hole; i < a.hole + 3; i++) {
+                        c.set(i, G, ' ');
+                        c.set(i, G + 1, '▀', 'soil');
+                    }
+                }
+                c.sprite(8, G - 4, ROCK, 'rock');
+                const pile = PILE[Math.min(5, Math.floor(dirt / 4))];
+                pile.forEach((l, i) => c.put(34 - Math.floor(l.length / 2), G - 1 - i, l, 'dirt'));
+                c.put(46, G - 1, '▓▒▓▓▓▒', 'rock');
+                c.put(47, G - 2, '▓▓▒', 'rock');
+                for (let i = 0; i < placed; i++) {
+                    c.put(WALL_X + 3 * (i % WALL_COLS), G - 1 - Math.floor(i / WALL_COLS), BLOCKS[i % 3], 'rock');
+                }
+                if (hold) {
+                    c.put(WALL_X + 4, G - 7, '|', 'good');
+                    c.put(WALL_X + 4, G - 8, '|>', 'good');
+                }
+                miners.forEach((a, i) => {
+                    let sp = (t + a.off) % 10 < 6 ? PICK_UP : PICK_DOWN;
+                    if (a.m)
+                        sp = mirror(sp);
+                    c.sprite(a.x, G - 4, withFace(sp, blink(t, i)), 'agent');
+                });
+                shovelers.forEach((a, i) => {
+                    let sp = (t + a.off) % 12 < 6 ? SHOVEL_DIG : SHOVEL_LIFT;
+                    if (a.m)
+                        sp = mirror(sp);
+                    c.sprite(a.x, G - 4, withFace(sp, blink(t, i + 2)), 'agent');
+                });
+                carriers.forEach((a, i) => {
+                    const face = t - a.happy < 8 ? '^.^' : blink(t, i + 4);
+                    const w = Math.floor(t / 2) % 2;
+                    const sp = a.st === 'pick' ? CROUCH : a.st === 'go' ? (w ? CARRY_A : CARRY_B) : a.st === 'place' ? PLACE : w ? BACK_A : BACK_B;
+                    c.sprite(a.x, G - 4, withFace(sp, face), 'agent');
+                    if (a.st === 'go')
+                        c.put(a.x + 6, G - 2, '▓▒▓', 'rock');
+                });
+                for (const p of parts)
+                    c.put(p.x, p.y, p.ch, p.tone);
+                for (const s of sparks)
+                    c.put(s.x, s.y, '*', 'spark');
+            },
+            status() {
+                return `bloques ${placed}/${WALL_MAX} · golpes ${hits} · paladas ${dirt}${msg ? ' · ' + msg : ''}`;
+            },
+        };
+    },
+};

package/dist/ui/mascot/selection.js

@@ -0,0 +1,32 @@
+export function sceneForTask(task) {
+    if (task.status === 'done')
+        return 'celebrate';
+    if (task.status === 'blocked')
+        return 'bugHunt';
+    if (task.priority === 'urgent')
+        return 'fire';
+    switch (task.status) {
+        case 'in_progress': return 'working';
+        case 'review': return 'planning';
+        case 'cancelled': return 'cleaning';
+        case 'backlog':
+        case 'todo': return 'resting';
+    }
+}
+export function sceneForTaskList(tasks, filter, syncing) {
+    if (syncing)
+        return 'syncing';
+    if (tasks.length === 0)
+        return 'empty';
+    if (tasks.some((task) => task.priority === 'urgent'))
+        return 'fire';
+    if (tasks.some((task) => task.status === 'blocked'))
+        return 'bugHunt';
+    if (filter === 'archived' || filter === 'done')
+        return 'cleaning';
+    if (tasks.some((task) => task.status === 'in_progress'))
+        return 'working';
+    if (tasks.some((task) => task.status === 'review'))
+        return 'planning';
+    return 'resting';
+}

package/dist/ui/mascot/states.js

@@ -0,0 +1,25 @@
+/**
+ * Sugerencia de qué escena mostrar para cada estado de un task manager.
+ * Ajusta las claves a los estados reales de tu app.
+ */
+export const TASK_STATE_SCENES = {
+    inProgress: 'working',
+    idle: 'resting',
+    paused: 'resting',
+    booting: 'clockIn',
+    planning: 'planning',
+    urgent: 'fire',
+    incident: 'fire',
+    completed: 'celebrate',
+    syncing: 'syncing',
+    loading: 'syncing',
+    error: 'bugHunt',
+    blocked: 'bugHunt',
+    empty: 'empty',
+    overdue: 'deadline',
+    dueSoon: 'deadline',
+    archiving: 'cleaning',
+};
+export function sceneForState(state) {
+    return TASK_STATE_SCENES[state];
+}

package/dist/ui/navigation/routes.js

@@ -0,0 +1,17 @@
+const HOME = { name: 'home' };
+function sameRoute(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+}
+/** A stack of screens. Home is always at the bottom; you cannot pop past it. */
+export function navigate(stack, action) {
+    switch (action.type) {
+        case 'push':
+            return sameRoute(stack.at(-1), action.route) ? [...stack] : [...stack, action.route];
+        case 'pop':
+            return stack.length > 1 ? stack.slice(0, -1) : [...stack];
+        case 'reset':
+            if (!action.route)
+                return [HOME];
+            return action.route.name === 'home' ? [action.route] : [HOME, action.route];
+    }
+}

package/dist/ui/overlays/CommitOverlay.js

@@ -0,0 +1,93 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { useState } from 'react';
+import { useAppState } from '../app-state.js';
+import { useList } from '../hooks/use-list.js';
+import { useQuery } from '../hooks/use-query.js';
+import { Layer } from '../input/dispatcher.js';
+import { useKeys } from '../input/KeyProvider.js';
+import { Button } from '../kit/Button.js';
+import { Clickable } from '../kit/Clickable.js';
+import { palette, symbols, toneColors } from '../theme/theme.js';
+import { OverlayFrame, useOverlayHeight } from './OverlayFrame.js';
+const KIND = {
+    modified: { letter: 'M', tone: 'warning' },
+    added: { letter: 'A', tone: 'success' },
+    untracked: { letter: '?', tone: 'success' },
+    deleted: { letter: 'D', tone: 'danger' },
+    renamed: { letter: 'R', tone: 'info' },
+    copied: { letter: 'C', tone: 'info' },
+    typechange: { letter: 'T', tone: 'warning' },
+    conflicted: { letter: 'U', tone: 'danger' },
+};
+/** Step 1 of a commit: choose files (all selected by default). Step 2 asks for the message. */
+export function CommitOverlay({ spec }) {
+    const { services, session, cwd, closeOverlay, openOverlay, notify } = useAppState();
+    const task = spec.task;
+    const state = useQuery(() => services.git.workingState(session, task, cwd), `commit:${task.id}`);
+    const files = state.data?.files ?? [];
+    const [excluded, setExcluded] = useState(new Set());
+    const height = useOverlayHeight() - 3;
+    const list = useList(files.length, height);
+    const selected = files.filter((file) => !excluded.has(file.path));
+    const toggle = (path) => setExcluded((previous) => {
+        const next = new Set(previous);
+        if (next.has(path))
+            next.delete(path);
+        else
+            next.add(path);
+        return next;
+    });
+    const proceed = () => {
+        if (selected.length === 0) {
+            notify('Select at least one file.', 'error');
+            return;
+        }
+        const paths = selected.map((file) => file.path);
+        openOverlay({
+            kind: 'prompt',
+            title: 'Commit message',
+            context: `${task.ref} · ${selected.length} file${selected.length === 1 ? '' : 's'} · “(${task.ref})” is added`,
+            placeholder: 'Deduplicate Stripe webhook events',
+            onSubmit: (message) => openOverlay({
+                kind: 'git-run',
+                title: 'Commit',
+                context: task.ref,
+                run: async () => {
+                    const result = await services.git.commit(session, task, { cwd, message, paths });
+                    return `Committed ${result.hash.slice(0, 7)} “${result.subject}” (${result.files} file${result.files === 1 ? '' : 's'})`;
+                },
+            }),
+        });
+    };
+    useKeys(Layer.overlay, (input, key) => {
+        if (key.escape)
+            closeOverlay(spec);
+        else if (list.handleKey(input, key))
+            return true;
+        else if (input === ' ') {
+            const file = files[list.index];
+            if (file)
+                toggle(file.path);
+        }
+        else if (input === 'a')
+            setExcluded(selected.length === files.length ? new Set(files.map((file) => file.path)) : new Set());
+        else if (key.return)
+            proceed();
+        return true;
+    });
+    const context = state.data;
+    const onTaskBranch = context ? context.currentBranch === task.branch && task.branch !== null : true;
+    return (_jsxs(OverlayFrame, { title: "Commit", context: `${task.ref} · ${selected.length}/${files.length} selected`, width: 88, hints: [
+            ['j/k', 'move'],
+            ['space', 'toggle'],
+            ['a', 'all/none'],
+            ['enter', 'message'],
+            ['esc', 'cancel'],
+        ], children: [state.error ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: palette.danger, children: `${symbols.cross} ${state.error.message}` }), state.error.hint ? _jsx(Text, { dimColor: true, children: `  ${state.error.hint}` }) : null] })) : null, context && !onTaskBranch ? (_jsx(Text, { color: palette.warning, children: `${symbols.cross} You are on ${context.currentBranch ?? 'a detached HEAD'}, not on ${task.branch ?? 'the task branch'}. Press b in the task first.` })) : null, context?.merging ? _jsx(Text, { color: palette.warning, children: "A merge is in progress in this repository." }) : null, context && files.length === 0 ? _jsx(Text, { dimColor: true, children: "Nothing to commit. The working tree is clean." }) : null, files.slice(list.offset, list.offset + height).map((file, position) => {
+                const index = list.offset + position;
+                const kind = KIND[file.kind];
+                const checked = !excluded.has(file.path);
+                return (_jsx(Clickable, { onClick: () => { list.select(index); toggle(file.path); }, layer: Layer.overlay, children: _jsxs(Box, { gap: 1, flexGrow: 1, ...(index === list.index ? { backgroundColor: palette.selection } : {}), children: [_jsx(Text, { color: palette.accent, children: index === list.index ? symbols.pointer : ' ' }), _jsx(Text, { color: checked ? palette.accent : palette.faint, children: checked ? '☑' : '☐' }), _jsx(Text, { color: kind.tone ? toneColors(kind.tone).fg : palette.muted, bold: true, children: kind.letter }), _jsx(Text, { color: checked ? palette.text : palette.muted, bold: index === list.index, wrap: "truncate-end", children: file.previousPath ? `${file.previousPath} ${symbols.arrow} ${file.path}` : file.path })] }) }, file.path));
+            }), files.length ? (_jsxs(Box, { marginTop: 1, justifyContent: "flex-end", gap: 2, children: [_jsx(Button, { label: "Cancel", onPress: () => closeOverlay(spec) }), _jsx(Button, { label: `Write message ${symbols.arrow}`, variant: "primary", onPress: proceed })] })) : null] }));
+}

package/dist/ui/overlays/ConfirmOverlay.js

@@ -0,0 +1,42 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { useState } from 'react';
+import { useAppState } from '../app-state.js';
+import { Layer } from '../input/dispatcher.js';
+import { useKeys } from '../input/KeyProvider.js';
+import { Button } from '../kit/Button.js';
+import { palette } from '../theme/theme.js';
+import { wrapText } from '../../utils/text.js';
+import { OverlayFrame, useOverlayWidth } from './OverlayFrame.js';
+const WIDTH = 60;
+export function ConfirmOverlay({ spec }) {
+    const { closeOverlay } = useAppState();
+    // 0 = Cancel (the default), 1 = the action.
+    const [choice, setChoice] = useState(0);
+    const inner = useOverlayWidth(WIDTH);
+    const confirm = async () => {
+        const result = await spec.onConfirm();
+        if (result !== false)
+            closeOverlay(spec);
+    };
+    const decide = (yes) => (yes ? void confirm() : closeOverlay(spec));
+    useKeys(Layer.overlay, (input, key) => {
+        if (key.escape || input === 'n' || input === '1')
+            decide(false);
+        else if (input === 'y' || input === '2')
+            decide(true);
+        else if (key.leftArrow || key.rightArrow || key.tab || input === 'h' || input === 'l')
+            setChoice(choice === 0 ? 1 : 0);
+        else if (key.return)
+            decide(choice === 1);
+        return true;
+    });
+    return (_jsxs(OverlayFrame, { title: spec.title, context: spec.context, width: WIDTH, hints: [
+            ['←→', 'choose'],
+            ['enter', choice === 1 ? spec.confirmLabel : 'cancel'],
+            ['y/n', 'answer'],
+            ['esc', 'cancel'],
+        ], children: [spec.message
+                ? wrapText(spec.message, inner).map((line, index) => (_jsx(Text, { color: palette.text, children: line }, index)))
+                : null, _jsxs(Box, { marginTop: spec.message ? 1 : 0, justifyContent: "flex-end", gap: 2, children: [_jsx(Button, { label: "Cancel", focused: choice === 0, onPress: () => decide(false) }), _jsx(Button, { label: spec.confirmLabel, tone: spec.tone ?? 'success', focused: choice === 1, onPress: () => decide(true) })] })] }));
+}

package/dist/ui/overlays/GitLogOverlay.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Text } from 'ink';
+import { useEffect, useState } from 'react';
+import { useAppState } from '../app-state.js';
+import { ConsoleLines } from '../components/ConsoleLines.js';
+import { Layer } from '../input/dispatcher.js';
+import { useKeys } from '../input/KeyProvider.js';
+import { palette } from '../theme/theme.js';
+import { OverlayFrame, useOverlayHeight } from './OverlayFrame.js';
+/** Everything SOJA has run in Git during this session, updating live. */
+export function GitLogOverlay({ spec }) {
+    const { services, closeOverlay } = useAppState();
+    const [lines, setLines] = useState(() => services.gitConsole.since());
+    const height = Math.min(20, useOverlayHeight());
+    useEffect(() => services.gitConsole.subscribe(() => setLines(services.gitConsole.since())), [services.gitConsole]);
+    useKeys(Layer.overlay, (_input, key) => {
+        if (key.escape || key.return)
+            closeOverlay(spec);
+        return true;
+    });
+    return (_jsx(OverlayFrame, { title: "Git log", context: "commands SOJA ran this session", width: 100, hints: [['esc', 'close']], children: lines.length === 0 ? _jsx(Text, { color: palette.faint, children: "Nothing yet. Git operations you run from SOJA show up here, live." }) : _jsx(ConsoleLines, { lines: lines.slice(-height) }) }));
+}

package/dist/ui/overlays/GitRunOverlay.js

@@ -0,0 +1,94 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { useEffect, useRef, useState } from 'react';
+import { GitError } from '../../git/types.js';
+import { toDisplayError } from '../../utils/errors.js';
+import { useAppState } from '../app-state.js';
+import { ConsoleLines } from '../components/ConsoleLines.js';
+import { Layer } from '../input/dispatcher.js';
+import { useExternalTerminal, useKeys } from '../input/KeyProvider.js';
+import { Button } from '../kit/Button.js';
+import { Spinner } from '../kit/Spinner.js';
+import { palette, symbols } from '../theme/theme.js';
+import { OverlayFrame, useOverlayHeight } from './OverlayFrame.js';
+export function GitRunOverlay({ spec }) {
+    const { services, closeOverlay, refresh } = useAppState();
+    const external = useExternalTerminal();
+    const [startId] = useState(() => services.gitConsole.lastId);
+    const [lines, setLines] = useState([]);
+    const [outcome, setOutcome] = useState({ phase: 'running' });
+    const started = useRef(false);
+    const height = useOverlayHeight();
+    useEffect(() => services.gitConsole.subscribe(() => setLines(services.gitConsole.since(startId))), [services.gitConsole, startId]);
+    const execute = async (mode) => {
+        try {
+            let message = '';
+            if (mode === 'normal') {
+                message = await spec.run(false);
+            }
+            else {
+                // Hand the terminal to Git/gh so they can ask for credentials, then come back.
+                await external(async () => {
+                    process.stdout.write(`\nSOJA is paused. ${mode === 'login' ? 'Log in to GitHub below.' : 'Git may ask for your credentials.'}\n\n`);
+                    if (mode === 'login')
+                        await services.git.loginGitHub();
+                    message = mode === 'login' ? await spec.run(false) : await spec.run(true);
+                });
+            }
+            services.gitConsole.write('success', message);
+            setOutcome({ phase: 'done', message });
+        }
+        catch (error) {
+            const display = toDisplayError(error);
+            setOutcome({
+                phase: 'failed',
+                message: display.message,
+                suggestions: error instanceof GitError ? error.suggestions : display.hint ? [display.hint] : [],
+                code: error instanceof GitError ? error.code : null,
+            });
+        }
+        finally {
+            refresh();
+        }
+    };
+    useEffect(() => {
+        if (started.current)
+            return;
+        started.current = true;
+        void execute('normal');
+        // Runs once when the overlay opens.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    const retry = (mode) => {
+        setOutcome({ phase: 'running' });
+        void execute(mode);
+    };
+    const recovery = [];
+    if (outcome.phase === 'failed') {
+        if (outcome.code === 'auth_required')
+            recovery.push({ key: 'i', label: 'retry with credentials', action: () => retry('interactive') });
+        if (outcome.code === 'gh_auth')
+            recovery.push({ key: 'i', label: 'gh auth login and retry', action: () => retry('login') });
+        const custom = outcome.code ? spec.recover?.[outcome.code] : undefined;
+        if (custom)
+            recovery.push(custom);
+        recovery.push({ key: 'r', label: 'retry', action: () => retry('normal') });
+    }
+    const actions = outcome.phase === 'done' ? (spec.next ?? []) : recovery;
+    useKeys(Layer.overlay, (input, key) => {
+        if (outcome.phase === 'running')
+            return true;
+        if (key.escape || key.return)
+            closeOverlay(spec);
+        else
+            actions.find((action) => action.key === input)?.action();
+        return true;
+    });
+    const suggestions = outcome.phase === 'failed' ? outcome.suggestions : [];
+    // The success line is shown below; the console keeps it for the Git log.
+    const visible = lines.filter((line) => line.kind !== 'success').slice(-Math.max(3, height - 3 - suggestions.length));
+    const hints = outcome.phase === 'running'
+        ? [['', 'running…']]
+        : [...actions.map((action) => [action.key, action.label]), ['esc', 'close']];
+    return (_jsxs(OverlayFrame, { title: spec.title, context: spec.context, hints: hints, width: 96, children: [_jsx(ConsoleLines, { lines: visible, minRows: 3 }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: outcome.phase === 'running' ? (_jsx(Spinner, { label: "Working\u2026" })) : outcome.phase === 'done' ? (_jsx(Text, { color: palette.success, bold: true, wrap: "truncate-end", children: `${symbols.check} ${outcome.message}` })) : (_jsxs(_Fragment, { children: [_jsx(Text, { color: palette.danger, bold: true, wrap: "truncate-end", children: `${symbols.cross} ${outcome.message}` }), suggestions.map((suggestion) => (_jsx(Text, { color: palette.muted, wrap: "truncate-end", children: `  ${symbols.arrow} ${suggestion}` }, suggestion)))] })) }), outcome.phase !== 'running' ? (_jsxs(Box, { marginTop: 1, justifyContent: "flex-end", gap: 2, children: [actions.map((action) => (_jsx(Button, { label: `${action.key}  ${action.label}`, onPress: () => action.action() }, action.key))), _jsx(Button, { label: "Close", variant: "primary", onPress: () => closeOverlay(spec) })] })) : null] }));
+}