@lamemind/loom-deck 0.33.0 → 0.34.1

package/dist/spawn.js

@@ -0,0 +1,250 @@
+// Effetti VERSO L'ESTERNO del deck: processi spawnati, comandi git. Nessun React
+// qui — è la fase a monte del ciclo, quindi non importa nulla della vista.
+import { spawn } from 'node:child_process';
+import { EventEmitter } from 'node:events';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+// scripts/deck-run è un sibling della dir del bundle: src/ (dev, tsx) e dist/
+// (build, node) stanno entrambi sotto la package root → risalita di un livello.
+export const DECK_RUN = join(dirname(fileURLToPath(import.meta.url)), '..', 'scripts', 'deck-run');
+/**
+ * Freno agli effetti VERSO L'ESTERNO (tab Ptyxis, sessioni Claude, git commit).
+ *
+ * Il gate di larghezza avvia il deck vero in uno pseudo-terminale e gli manda
+ * tasti — e in questa TUI un tasto è un'azione: `⏎` su una riga sessione apre
+ * una tab Ptyxis, `t` un terminale, `⏎` nel modale edit committa. Ogni run dei
+ * test apriva quindi finestre reali sulla macchina di chi li lanciava, in
+ * qualunque progetto avesse in focus.
+ *
+ * Il gate va tenuto sul deck VERO (è tutto il suo valore: misura il frame che
+ * VTE disegna davvero), quindi il freno sta qui: `LOOM_DECK_NO_SPAWN=1` fa
+ * restituire un figlio finto e inerte invece di lanciare il processo. Non è un
+ * mock del comportamento — l'azione semplicemente non avviene, e il frame che il
+ * test misura resta identico.
+ */
+export const NO_SPAWN = process.env.LOOM_DECK_NO_SPAWN === '1';
+export function spawnOut(cmd, args, opts) {
+    if (!NO_SPAWN)
+        return spawn(cmd, args, opts);
+    // Figlio inerte: emette nulla, quindi i `.on('error'|'close')` dei chiamanti
+    // restano appesi senza mai scattare — che è esattamente "non è successo niente".
+    const fake = new EventEmitter();
+    fake.unref = () => fake;
+    return fake;
+}
+// T66 — le azioni del detail. Non sono un catalogo nuovo: ognuna è un
+// `--prompt-kind` già esistente più `checkpoint`, e tutte passano dallo stesso
+// `spawnForTask` dei CTRL della lista — una superficie in più, zero percorsi di
+// spawn in più.
+//
+// L'etichetta è distinta dal kind dove il kind è il nome del MECCANISMO e
+// l'etichetta quello dell'INTENZIONE: `none` è "aprire la task a mani nude",
+// `recap` è "vedere a che punto sta".
+export const DETAIL_ACTIONS = [
+    { kind: 'none', label: 'open' },
+    { kind: 'preflight', label: 'preflight' },
+    { kind: 'run', label: 'run' },
+    { kind: 'recap', label: 'status' },
+    { kind: 'checkpoint', label: 'checkpoint' },
+];
+// Spawn detached: il deck spawna ma NON contiene la sessione (la possiede
+// ptyxis-agent). unref + stdio ignore → ritorna subito, la TUI resta viva.
+// sessionId pinnato (T27) → il binding sidecar è deterministico allo spawn.
+// Il kind è OBBLIGATORIO e non ha default qui: il default vive in deck-run (per
+// le invocazioni a mano), mentre dal deck ogni tasto dichiara il proprio intento
+// — un default silenzioso renderebbe indistinguibili `⏎` e `^K`.
+export function deckArgs(id, sessionId, kind) {
+    return [id, '--session-id', sessionId, '--prompt-kind', kind];
+}
+export function spawnDeck(id, cwd, sessionId, kind) {
+    const child = spawnOut(DECK_RUN, deckArgs(id, sessionId, kind), {
+        cwd,
+        detached: true,
+        stdio: 'ignore',
+    });
+    child.unref();
+    return child;
+}
+// T49 — resume di una sessione esistente come nuova tab Ptyxis. Scoped (taskId
+// presente) → `deck-run <task> --resume <sid>`: la ripresa eredita LOOM_TASK +
+// titolo `· <task>` (D2 preflight, l'hook SessionStart ricarica il contesto
+// task). Spot → `--no-task --resume`: resume nudo, solo label progetto. Nessun
+// prompt iniziale in entrambi i casi: riprendere una conversazione significa
+// continuarla, non iniettarle un messaggio (lo salta deck-run).
+//
+// T64 — la NOTA della conversazione (se c'è) viaggia nel titolo della tab. Più
+// sessioni sulla stessa task hanno oggi titoli identici (`label · T81`): la nota
+// è già ciò con cui l'utente le distingue in lista, quindi è anche ciò che
+// distingue le tab. La passa il DECK e non la legge deck-run perché la nota vive
+// nel sidecar `session-tasks.jsonl`, che deck-run non tocca (legge solo
+// `.claude/loom-works.json`): tenerlo così evita di dare al primitive un secondo
+// file da conoscere. Il titolo si congela qui — `claude --name` lo setta una
+// volta sola, quindi una nota cambiata DOPO non ri-titola la tab già aperta.
+export function resumeArgs(taskId, sessionId, note) {
+    const args = taskId ? [taskId, '--resume', sessionId] : ['--no-task', '--resume', sessionId];
+    if (note)
+        args.push('--title-note', note);
+    return args;
+}
+export function spawnDeckResume(taskId, cwd, sessionId, note) {
+    const child = spawnOut(DECK_RUN, resumeArgs(taskId, sessionId, note), {
+        cwd,
+        detached: true,
+        stdio: 'ignore',
+    });
+    child.unref();
+    return child;
+}
+// T28 — FORK: `deck-run <task|--no-task> --resume <origine> --fork --session-id
+// <nuovo>`. Variante del resume, non una terza forma: cambia solo che CC apre un
+// id nuovo (`--fork-session`) invece di riprendere a scrivere sull'origine —
+// due writer sullo stesso JSONL non esistono mai, che è l'intero punto del fork.
+// Il nuovo id lo genera il DECK e lo pinna, come in spawnDeck: è l'unico modo di
+// conoscerlo prima che la sessione esista, e senza conoscerlo non si possono
+// scrivere né il binding task né il record di lineage (il transcript del fork
+// non nomina da nessuna parte la sessione d'origine).
+// Nessun `--title-note` (T64): il ramo nasce con un sessionId proprio e SENZA
+// nota nel sidecar — ereditare quella dell'origine metterebbe nel titolo una
+// maniglia che nella lista non compare, cioè una promessa falsa. Il fork si
+// distingue col suo marcatore, `· fork`.
+export function forkArgs(taskId, originId, newId) {
+    return [
+        ...(taskId ? [taskId] : ['--no-task']),
+        '--resume',
+        originId,
+        '--fork',
+        '--session-id',
+        newId,
+    ];
+}
+export function spawnDeckFork(taskId, cwd, originId, newId) {
+    const child = spawnOut(DECK_RUN, forkArgs(taskId, originId, newId), {
+        cwd,
+        detached: true,
+        stdio: 'ignore',
+    });
+    child.unref();
+    return child;
+}
+// T42 — sessione Claude NUDA: nessuna task, nessun prompt iniziale, nessun
+// sessionId pinnato (quindi nessuna entry nel sidecar session-tasks.jsonl: senza
+// task non c'è nulla da legare). Funzione separata e non un parametro opzionale
+// di spawnDeck: i tre argomenti mancano tutti insieme, un `if` per ciascuno
+// sporcherebbe il percorso bound. Il titolo tab resta la label loom — lo mette
+// deck-run, perché il match compass è window-level e non sa nulla di task.
+export function spawnClaudeEmpty(cwd) {
+    const child = spawnOut(DECK_RUN, ['--no-task'], {
+        cwd,
+        detached: true,
+        stdio: 'ignore',
+    });
+    child.unref();
+    return child;
+}
+// T39/T32: voce `launch` custom del file config, eseguita con cwd = project root.
+// Spawn detached come spawnDeck: il deck lancia ma non possiede il processo.
+// Shell login+interattiva (bash -lic) perché i comandi tipici sono alias o
+// funzioni di ~/.bashrc (`codium`=alias flatpak, `idea`=funzione) — con `bash -c`
+// non risolverebbero. Il comando NON è input utente: viene dal file committato
+// `.claude/loom-works.json`, fidato quanto un custom-command Ptyxis (contratto
+// esplicito in project-config-architecture.md). La project root arriva via cwd,
+// non interpolata nella stringa.
+export function runLaunch(entry, cwd) {
+    const child = spawnOut('bash', ['-lic', entry.command], {
+        cwd,
+        detached: true,
+        stdio: 'ignore',
+    });
+    child.unref();
+    return child;
+}
+// T37 — surface STANDARD LAUNCH `terminal`: built-in e universale (nessuna
+// dichiarazione in `launch[]`), ma di natura launch — fire-once, nessuno stato.
+// Il deck gira già DENTRO una tab Ptyxis → `--tab` mette il terminale accanto a
+// sé nella stessa finestra, invece di sparpagliare finestre.
+// Nessun `-- CMD`: l'azione È aprire la shell (differenza dalle launch custom,
+// che eseguono un comando dentro `bash -lic`).
+// `-T <title>` con la chiave `🖥️ <name>` tiene la finestra matchabile da compass
+// anche mentre la tab attiva è il terminale; senza identità nel file config si
+// spawna senza titolo (la surface resta funzionante, il progetto risulta assente
+// dal radar finché quella tab è in primo piano).
+export function terminalArgs(cwd, title) {
+    return title ? ['--tab', '-T', title, '-d', cwd] : ['--tab', '-d', cwd];
+}
+export function spawnTerminal(cwd, title) {
+    const child = spawnOut('ptyxis', terminalArgs(cwd, title), {
+        cwd,
+        detached: true,
+        stdio: 'ignore',
+    });
+    child.unref();
+    return child;
+}
+// Comando claude (override per ambienti dove non è su PATH; loom-deck → NPM).
+export const CLAUDE_CMD = process.env.LOOM_DECK_CLAUDE_CMD ?? 'claude';
+// T30: create-task inline. Spawna CC HEADLESS (`-p`) con `--session-id` pinnato
+// che invoca la skill create-task. Differenze da spawnDeck:
+//  - headless (`-p`), non una tab Ptyxis interattiva → il deck osserva l'esito;
+//  - `yolo` FORZATO: create-task è interattiva di default (AskUserQuestion) e in
+//    `-p` non può ricevere risposte → si impianterebbe. yolo = zero domande.
+//  - `--output-format stream-json` (richiede `--verbose`): l'ultima riga è
+//    `{type:"result", is_error}`, segnale di completamento robusto (> exit code).
+//  - detached (own process-group) → il create sopravvive alla chiusura del deck e
+//    completa commit+push da sé; stdout in pipe SOLO per leggere il result event.
+// Il prompt viaggia come singolo argv (no shell) → nessuna injection dal testo utente.
+export function spawnCreateTask(text, cwd, sessionId, onResult) {
+    const child = spawnOut(CLAUDE_CMD, [
+        '-p',
+        '--output-format',
+        'stream-json',
+        '--verbose',
+        '--session-id',
+        sessionId,
+        `/loom-works:create-task yolo ${text}`,
+    ], { cwd, detached: true, stdio: ['ignore', 'pipe', 'pipe'] });
+    let buf = '';
+    let isError = null;
+    child.stdout?.on('data', (chunk) => {
+        buf += chunk.toString();
+        let nl;
+        while ((nl = buf.indexOf('\n')) >= 0) {
+            const line = buf.slice(0, nl).trim();
+            buf = buf.slice(nl + 1);
+            if (!line)
+                continue;
+            try {
+                const obj = JSON.parse(line);
+                if (obj.type === 'result')
+                    isError = obj.is_error ?? false;
+            }
+            catch {
+                // riga parziale / non-json → skip
+            }
+        }
+    });
+    // Drena stderr per non riempire il buffer pipe (deadlock del figlio).
+    child.stderr?.on('data', () => { });
+    child.on('error', () => onResult(false));
+    child.on('close', (code) => {
+        onResult(isError === null ? code === 0 : !isError);
+    });
+    return child;
+}
+// T41 — Commit dell'edit. `git commit -- <paths>` committa lo stato working-tree
+// SOLO di quei path, ignorando l'index: se l'utente ha altro in stage (o altri
+// file sporchi) non finisce dentro per errore. NON detached: è un'operazione
+// veloce e il suo esito va riportato nella nota. stderr raccolto per dire perché
+// ha fallito (identità git assente, hook che rifiuta, …) invece di un generico ⚠.
+export function commitTaskEdit(cwd, paths, message, onResult) {
+    const child = spawnOut('git', ['commit', '-m', message, '--', ...paths], {
+        cwd,
+        stdio: ['ignore', 'ignore', 'pipe'],
+    });
+    let err = '';
+    child.stderr?.on('data', (c) => {
+        err += c.toString();
+    });
+    child.on('error', () => onResult(false, 'git non lanciabile'));
+    child.on('close', (code) => onResult(code === 0, err.trim().split('\n')[0] ?? ''));
+    return child;
+}

package/dist/ui/assign-screen.js

@@ -0,0 +1,40 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// Schermata di assegnazione conversazione → task (T57).
+import { Box, Text } from 'ink';
+import { cut, sanitize, termWidth } from '../width.js';
+import { assignTextWidth, isDone } from '../layout.js';
+import { CARET, CARET_OFF, displayProg } from '../glyphs.js';
+/**
+ * Schermata di assegnazione di una conversazione a una task (T57).
+ *
+ * Fullscreen sostitutiva (D3) come la ricerca: la lista task non entra in un
+ * box sopra i due pane. Da lì discende che l'oggetto dell'azione — la sessione
+ * selezionata, che non è più a schermo — va ripetuto nel titolo.
+ *
+ * L'header della lista conta le task escluse dai filtri della vista (D4): la
+ * scelta di mostrare `viewTasks` e non tutte le task ha come prezzo noto che un
+ * filtro può nascondere proprio il bersaglio, e quel prezzo non deve essere
+ * silenzioso — stessa convenzione del `+N più vecchie` del pane sessioni.
+ */
+export function AssignScreen({ sessionId, label, current, filter, rows, selected, matched, hidden, above, below, childCount, columns, note, }) {
+    const width = assignTextWidth(columns);
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["assegna ", _jsx(Text, { color: "cyan", children: sessionId.slice(0, 8) }), label ? ` «${cut(sanitize(label), Math.max(10, Math.floor(width / 4)))}»` : '', " \u00B7 ora", ' ', current ? _jsx(Text, { color: "green", children: current }) : 'spot', " \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), ' ', "assegna \u00B7 ", _jsx(Text, { color: "yellow", children: "^U" }), " pulisci \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] }), _jsx(Box, { borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: _jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { dimColor: true, children: "filtro " }), _jsx(Text, { color: "yellow", children: cut(filter, Math.max(8, width - 24)) }), _jsx(Text, { inverse: true, children: " " }), !filter ? _jsx(Text, { dimColor: true, children: "  (id o titolo)" }) : null] }) }), _jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, marginTop: 1, children: [_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [matched, " task", hidden > 0 ? _jsxs(Text, { color: "yellow", children: [" \u00B7 +", hidden, " fuori dai filtri"] }) : null, above > 0 ? _jsxs(Text, { dimColor: true, children: [" \u00B7 \u2191", above] }) : null, below > 0 ? _jsxs(Text, { dimColor: true, children: [" \u00B7 \u2193", below] }) : null] }), rows.map((task) => {
+                        // T57/D2 — `detach` è una VOCE della lista, non un tasto a parte: un
+                        // solo gesto (`A`), un solo modale. Speculare alla riga meta `spot`
+                        // del pane task, e nominata con l'AZIONE («detach») invece che con lo
+                        // stato d'arrivo — è ciò che si sta per fare.
+                        if (!task) {
+                            const sel = selected === null;
+                            // Le colonne fisse (caret + `○ detach` + i due spazi) sono 12: solo
+                            // la glossa si taglia, così su un terminale stretto resta comunque
+                            // il nome dell'azione invece di un moncone di frase.
+                            return (_jsxs(Text, { inverse: sel, wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, "\u25CB detach  ", cut('la sessione torna spot', width - 12)] }, "detach"));
+                        }
+                        const sel = selected === task.id;
+                        const n = childCount.get(task.id) ?? 0;
+                        const head = `${CARET_OFF}${task.id}  ${sanitize(task.pri)}  ${displayProg(task.prog)}  `;
+                        const tail = n > 0 ? ` (${n})` : '';
+                        const desc = cut(task.desc, Math.max(4, width - termWidth(head) - termWidth(tail)));
+                        return (_jsxs(Text, { inverse: sel, dimColor: !sel && isDone(task.prog), wrap: "truncate-end", children: [sel ? CARET : CARET_OFF, task.id, "  ", sanitize(task.pri), "  ", displayProg(task.prog), "  ", desc, tail] }, task.id));
+                    })] }), note ? _jsx(Text, { color: "green", wrap: "truncate-end", children: sanitize(note) }) : null] }));
+}

package/dist/ui/detail-screen.js

@@ -0,0 +1,97 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+// Detail della task (T66): quarta schermata sostitutiva, col markdown reso in
+// span tipizzati (T75) e la ricerca interna (T91).
+import { Box, Text } from 'ink';
+import { caretWindow, cut, cutParts, sanitize } from '../width.js';
+import { sliceLine } from '../text-search.js';
+import { sliceSpans } from '../markdown.js';
+import { DETAIL_ACTIONS } from '../spawn.js';
+import { WARN } from '../glyphs.js';
+/** Resa di ogni costrutto markdown (T75 · D4): un solo livello di enfasi per
+ *  costrutto, senza un secondo alfabeto da imparare. Heading uguali a ogni
+ *  livello — la gerarchia la porta già il testo. `code` e `fence` condividono
+ *  il giallo perché sono lo stesso costrutto a due granularità: dargli due
+ *  colori direbbe che sono due cose. */
+export const MD_STYLE = {
+    heading: { bold: true, color: 'cyan' },
+    bold: { bold: true },
+    code: { color: 'yellow' },
+    fence: { color: 'yellow' },
+};
+/**
+ * Una riga del detail (T75): markdown reso, con sopra l'evidenziazione della
+ * ricerca.
+ *
+ * Due segmentazioni sulla stessa riga, annidate e non fuse: prima si taglia sui
+ * costrutti markdown, poi ogni pezzo si ritaglia sulle occorrenze. L'ordine non
+ * è indifferente — così un match a cavallo di un `**grassetto**` resta
+ * evidenziato per intero e insieme conserva il grassetto sulla metà che ce
+ * l'ha, cosa che una segmentazione unica dovrebbe risolvere decidendo chi vince.
+ *
+ * Gli offset di `occ` e di `spans` indicizzano ENTRAMBI il testo reso: è ciò
+ * che permette di comporli senza rimappature. Vedi `sheetDoc` per il perché la
+ * ricerca del detail ha smesso di scandire il sorgente.
+ */
+export function DetailLine({ line, spans, occ, current, }) {
+    const styled = sliceSpans(line, spans);
+    // Riga vuota → uno spazio: un `<Text>` senza contenuto Ink non lo disegna, e
+    // il testo si compatterebbe perdendo la struttura del file.
+    if (styled.length === 0)
+        return _jsx(Text, { wrap: "truncate-end", children: " " });
+    let off = line.start;
+    return (_jsx(Text, { wrap: "truncate-end", children: styled.map((seg, i) => {
+            const st = seg.kind ? MD_STYLE[seg.kind] : undefined;
+            const at = off;
+            off += seg.text.length;
+            // Senza ricerca aperta il secondo taglio non ha niente da tagliare, e
+            // saltarlo evita di allocare tre array per ogni riga a ogni freccia.
+            if (occ.length === 0) {
+                return (_jsx(Text, { bold: st?.bold, color: st?.color, children: seg.text }, i));
+            }
+            return (_jsx(Text, { bold: st?.bold, color: st?.color, children: sliceLine(seg.text, at, occ, current).map((p, j) => p.hit ? (_jsx(Text, { backgroundColor: p.current ? 'cyan' : 'yellow', color: "black", children: p.text }, j)) : (_jsx(Text, { children: p.text }, j))) }, i));
+        }) }));
+}
+/** Campo della ricerca nel detail: finestra ancorata al caret, cursore inverso
+ *  sulla cella reale. Gemello di `EditTextField` senza la label, che qui sta
+ *  fuori perché il campo vive in FLUSSO su una riga condivisa col contatore —
+ *  non su una riga propria. */
+export function DetailFindField({ value, caret, cols }) {
+    const win = caretWindow(value, caret, cols);
+    return (_jsxs(_Fragment, { children: [_jsx(Text, { children: sanitize(win.head) }), _jsx(Text, { inverse: true, children: sanitize(win.at) }), _jsx(Text, { children: sanitize(win.tail) })] }));
+}
+/**
+ * Detail della task (T66): il task file scrollabile più la barra azioni.
+ *
+ * Unisce due gesti che erano due schermate — leggere la task e agire su di essa
+ * — perché convergono sullo stesso oggetto: si legge la Description proprio per
+ * decidere QUALE azione lanciare, e con due overlay separati quella decisione
+ * costava uscire dal viewer e ricordarsi la combo.
+ *
+ * Le azioni sono BOTTONI AFFIANCATI e non voci di un menu verticale: un
+ * rettangolo ha già coordinate e area cliccabile, quindi il layout sopravvive
+ * all'arrivo del mouse (T21 · SGR enable + hit-test) senza migrazione. La
+ * navigazione da tastiera ci si sovrappone senza conflitti.
+ */
+export function DetailScreen({ id, title, missing, lines, spans, top, total, capacity, action, columns, find, occ, occCur, }) {
+    const last = Math.min(total, top + capacity);
+    // Il taglio lo fa il chiamante (invariante ③ di width.ts): la riga bottoni è
+    // ASCII, quindi `truncate-end` oggi darebbe il risultato giusto per caso — ma
+    // la correttezza non deve dipendere dall'alfabeto che capita nella riga.
+    const width = Math.max(20, (columns || 80) - 4);
+    const segs = DETAIL_ACTIONS.map((a) => `[ ${a.label} ]`);
+    const parts = [];
+    segs.forEach((s, i) => {
+        if (i > 0)
+            parts.push('  ');
+        parts.push(s);
+    });
+    const dropped = (v) => segs.filter((s, i) => v[i * 2] !== s).length;
+    // Due passate: la seconda serve SOLO quando qualcosa cade, e riserva le
+    // colonne del contatore. Riservarle sempre costerebbe 6 colonne su ogni
+    // terminale largo per un avviso che lì non comparirà mai.
+    let shown = cutParts(parts, width);
+    if (dropped(shown) > 0)
+        shown = cutParts(parts, Math.max(0, width - 6));
+    const cutCount = dropped(shown);
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [_jsx(Text, { color: "cyan", children: id }), " \u00B7 ", cut(title, Math.max(10, width - 34)), missing ? '' : ` · righe ${total === 0 ? 0 : top + 1}-${last} di ${total}`] }), find?.open ? (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [_jsx(Text, { color: "yellow", children: "\u2191\u2193" }), " occorrenza \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2190\u2192" }), " caret \u00B7", ' ', _jsx(Text, { color: "yellow", children: "^U" }), " svuota \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " tieni \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] })) : (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [_jsx(Text, { color: "yellow", children: "\u2191\u2193" }), " riga \u00B7 ", _jsx(Text, { color: "yellow", children: "PgUp/PgDn" }), " pagina \u00B7", ' ', _jsx(Text, { color: "yellow", children: "g/G" }), " estremi \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2190\u2192" }), " azione \u00B7", ' ', _jsx(Text, { color: "yellow", children: "^F" }), " cerca \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " esegui \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " chiudi"] })), _jsx(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, marginTop: 1, children: missing ? (_jsxs(Text, { color: "yellow", wrap: "truncate-end", children: [WARN, " task file non trovato \u00B7 le azioni restano attive (deck-run risolve la task per id)"] })) : (lines.map((l, i) => (_jsx(DetailLine, { line: l, spans: spans, occ: occ, current: occCur }, top + i)))) }), find?.open ? (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { dimColor: true, children: "cerca " }), _jsx(DetailFindField, { value: find.q, caret: find.caret, cols: Math.max(10, width - 28) }), find.q.length === 0 ? (_jsx(Text, { dimColor: true, children: " \u00B7 digita per cercare" })) : occ.length === 0 ? (_jsx(Text, { color: "yellow", children: " \u00B7 nessuna occorrenza" })) : (_jsxs(Text, { color: "cyan", children: [' ', "\u00B7 ", occCur + 1, "/", occ.length] }))] }) })) : null, _jsx(Box, { marginTop: 1, children: _jsxs(Text, { wrap: "truncate-end", children: [shown.map((part, i) => i % 2 === 1 ? (_jsx(Text, { children: part }, i)) : (_jsx(Text, { inverse: i / 2 === action, color: i / 2 === action ? 'green' : 'gray', children: part }, i))), cutCount > 0 ? _jsxs(Text, { color: "yellow", children: [" \u00B7 +", cutCount] }) : null] }) })] }));
+}

package/dist/ui/modals.js

@@ -0,0 +1,59 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+// Modali in FLUSSO sopra i due pane (sort, filtri, edit): a differenza delle
+// schermate sostitutive costano righe al budget d'altezza, quindi ognuno ha un
+// costo dichiarato in `viewport.ts`.
+import { Box, Text } from 'ink';
+import { caretWindow, sanitize } from '../width.js';
+import { cpLen } from '../layout.js';
+import { CARET, CARET_OFF } from '../glyphs.js';
+import { EDIT_PRI, EDIT_PROG } from '../model.js';
+import { PRI_ENTRIES, PROG_ENTRIES } from '../view.js';
+import { progressText, PRI_GLYPH, PRI_LABEL, PROG_GLYPH } from '../task-edit.js';
+export const SORT_UI = { pri: 'pri', prog: 'stato', id: 'id' };
+// Modali resi IN FLUSSO (come l'input box di create), non in overlay assoluto:
+// spingono giù i pane invece di coprirli, così la lista che stai filtrando
+// resta sempre visibile mentre la componi.
+export function SortModal({ sort }) {
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsx(Text, { color: "yellow", children: "S \u203A sort chain" }), sort.length === 0 ? (_jsx(Text, { dimColor: true, children: "nessuna chiave \u00B7 resta l'ordine per id \u2191" })) : (_jsx(Text, { children: sort
+                    .map((e, i) => `${i + 1}. ${SORT_UI[e.key]} ${e.dir === 'asc' ? '↑' : '↓'}`)
+                    .join('    ') }))] }));
+}
+export function FilterModal({ view, cursor }) {
+    const rows = [
+        { label: 'pri  ', entries: PRI_ENTRIES, hidden: new Set(view.hiddenPri) },
+        { label: 'stato', entries: PROG_ENTRIES, hidden: new Set(view.hiddenProg) },
+    ];
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsx(Text, { color: "yellow", children: "F \u203A filtri" }), rows.map((row, r) => (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: row.label }), row.entries.map((e, c) => {
+                        const on = !row.hidden.has(e.name);
+                        const here = cursor.row === r && cursor.col === c;
+                        return (_jsxs(Text, { inverse: here, color: on ? 'green' : 'gray', dimColor: !on, children: ['  ', "[", on ? 'x' : ' ', "] ", sanitize(e.glyph)] }, e.name));
+                    })] }, row.label)))] }));
+}
+/**
+ * Campo di testo del modale edit: finestra ancorata al caret + cursore inverso
+ * nella posizione REALE.
+ *
+ * Il cursore non è più uno spazio inverso appiccicato in coda ma la cella `at`
+ * della finestra — cioè il carattere su cui il caret sta davvero. Fuori fuoco
+ * (`focused` falso) il caret non si disegna e la finestra si ancora in fondo,
+ * che è la vista utile per un campo che non si sta scrivendo.
+ */
+export function EditTextField({ label, value, caret, focused, cols, }) {
+    const win = caretWindow(value, focused ? caret : cpLen(value), cols);
+    return (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: label }), _jsxs(Text, { children: ['  ', sanitize(win.head)] }), focused ? _jsx(Text, { inverse: true, children: sanitize(win.at) }) : null, _jsx(Text, { children: sanitize(win.tail) })] }));
+}
+// T41 — modale edit, in flusso come gli altri (spinge giù i pane invece di
+// coprirli: la riga che stai modificando resta visibile sopra la lista).
+// La riga di anteprima mostra il testo ESATTO che finirà nel campo `Progress`
+// del task file — così il default (`✔️ Done at <oggi>`) non è una sorpresa.
+export function EditModal({ id, draft, row, columns, }) {
+    const mark = (r) => (row === r ? CARET : CARET_OFF);
+    // Budget dei campi di testo, DERIVATO da `columns` (mai una costante): il box
+    // del modale è ANNIDATO nella cornice del deck, quindi le cornici da scalare
+    // sono due — root (bordo 2 + paddingX 2) e modale (bordo 2 + paddingX 2) — più
+    // caret 2, etichetta 6, gap 2 e cursore 1. Totale 19.
+    // Un titolo di tasks.md arriva a ~64 caratteri: senza taglio la riga va a capo
+    // dentro il box, che si alza di una riga e sfonda il budget verticale (invariante ③).
+    const fieldBudget = Math.max(8, columns - 19);
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsxs(Text, { color: "yellow", children: ["E \u203A ", id, " \u00B7 titolo, priorit\u00E0 e stato"] }), _jsxs(Text, { children: [mark(0), _jsx(Text, { dimColor: true, children: "pri   " }), EDIT_PRI.map((p) => (_jsxs(Text, { inverse: draft.pri === p, color: draft.pri === p ? 'green' : 'gray', children: ['  ', sanitize(PRI_GLYPH[p]), " ", PRI_LABEL[p]] }, p)))] }), _jsxs(Text, { children: [mark(1), _jsx(Text, { dimColor: true, children: "stato " }), EDIT_PROG.map((p) => (_jsxs(Text, { inverse: draft.prog === p, color: draft.prog === p ? 'green' : 'gray', children: ['  ', sanitize(PROG_GLYPH[p]), " ", p] }, p)))] }), _jsxs(Text, { children: [mark(2), _jsx(EditTextField, { label: "prog  ", value: draft.detail, caret: draft.caret, focused: row === 2, cols: fieldBudget }), !draft.detail && row !== 2 ? _jsx(Text, { dimColor: true, children: "(default)" }) : null] }), _jsxs(Text, { children: [mark(3), _jsx(EditTextField, { label: "titolo", value: draft.title, caret: draft.caret, focused: row === 3, cols: fieldBudget })] }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["\u21B3 ", sanitize(progressText(draft.prog, draft.detail))] })] }));
+}