@lamemind/loom-deck 0.33.0 → 0.34.1

package/dist/overlays/search.js

@@ -0,0 +1,259 @@
+// Overlay RICERCA e READER (T52): stato, derivati e input nello stesso file.
+//
+// I due lati stanno insieme perché sono la stessa cosa vista da due angoli — lo
+// stato descrive cosa il modale mostra, l'handler cosa lo cambia — e separarli
+// metterebbe ogni modifica a cavallo di due file.
+//
+// Reader e ricerca condividono un hook solo perché il primo è un modale DENTRO
+// il secondo: l'occorrenza aperta nel reader è una riga della lista sottostante,
+// e `esc` deve ritrovare quella lista esattamente com'era.
+//
+// Ciò che esce dal deck (il resume di una conversazione) NON sta qui: arriva
+// come callback `onResume`. È il confine del criterio di partizione — gli
+// effetti verso l'esterno stanno a monte, e un overlay li chiede invece di
+// eseguirli.
+import { useEffect, useMemo, useState } from 'react';
+import { buildRows, firstRowKey, moveRowSelection, rowIndexOfKey, searchSessions, selectedRow, DEFAULT_OPTIONS, } from '../search.js';
+import { readerCapacity, searchListCapacity } from '../viewport.js';
+import { wrapWithOffsets } from '../width.js';
+import { searchExcerptWidth } from '../layout.js';
+import { sanitizeTyped } from '../glyphs.js';
+import { SEARCH_KIND_KEYS, SEARCH_TOGGLE_KEYS } from '../model.js';
+export function useSearchOverlay(deps) {
+    const { sessions, rows, columns, hasNote, setMode, setNote, onResume } = deps;
+    // T52 — stato del modale ricerca. VOLATILE per decisione (D4): vive in
+    // memoria, quindi riaprendo il modale ritrovi query e toggle come li avevi
+    // lasciati, ma un riavvio del deck riporta ai default. Niente schema nuovo su
+    // `deck-view.json` e nessuna scrittura implicita su disco — che
+    // contraddirebbe la regola T39 «il disco si tocca solo su `w`», qui non
+    // trasportabile perché dentro il modale `w` è un carattere digitabile.
+    const [hash, setHash] = useState('');
+    const [query, setQuery] = useState('');
+    const [field, setField] = useState('query');
+    const [opts, setOpts] = useState(DEFAULT_OPTIONS);
+    const [selKey, setSelKey] = useState(null);
+    // Occorrenza aperta nel reader; null = reader chiuso. Tenerla separata dalla
+    // selezione della lista è ciò che permette a `esc` di tornare indietro
+    // trovando la lista esattamente com'era.
+    const [readerRow, setReaderRow] = useState(null);
+    const [readerTop, setReaderTop] = useState(0);
+    // T52 — ricerca EAGER: rigira a ogni carattere digitato, non su ⏎. È
+    // sostenibile perché i corpi sono già in RAM dentro la cache mtime-keyed
+    // dell'adapter (D5): misurato su questo progetto, 0,8 ms sui soli corpi IA e
+    // ≤9 ms su tutti i tipi — sotto il tempo fra due battute. Il memo evita di
+    // rifarla sui re-render che non toccano né query né opzioni (il poll delle
+    // sessioni ogni 1,5s è già filtrato dalla signature in `useSessions`).
+    const result = useMemo(() => searchSessions(sessions, hash, query, opts, searchExcerptWidth(columns)), [sessions, hash, query, opts, columns]);
+    // Con l'hash valorizzato la conversazione è una sola e già nominata nel campo:
+    // la riga-sessione ripeterebbe un dato costante rubando una riga per gruppo.
+    const flat = hash.trim().length > 0;
+    const searchRows = useMemo(() => buildRows(result, flat), [result, flat]);
+    // T52 — riga selezionata e, se è un'occorrenza, il suo corpo wrappato per
+    // l'anteprima sotto la lista. Memoizzato per (testo, larghezza): navigando
+    // con le frecce si ri-wrappa solo quando cambia davvero l'occorrenza.
+    const selRow = useMemo(() => selectedRow(searchRows, selKey), [searchRows, selKey]);
+    const previewWidth = Math.max(20, (columns || 80) - 8);
+    const previewBody = useMemo(() => (selRow?.kind === 'hit' ? wrapWithOffsets(selRow.hit.text, previewWidth) : []), [selRow, previewWidth]);
+    // T52 — corpo del messaggio aperto nel reader, wrappato UNA volta per (testo,
+    // larghezza). Senza memo ogni pressione di freccia rifarebbe l'a-capo di un
+    // messaggio che nella coda lunga arriva a 150k char.
+    const readerWidth = Math.max(20, (columns || 80) - 6);
+    const readerLines = useMemo(() => (readerRow?.kind === 'hit' ? wrapWithOffsets(readerRow.hit.text, readerWidth) : []), [readerRow, readerWidth]);
+    const readerCap = readerCapacity(rows);
+    const readerMaxTop = Math.max(0, readerLines.length - readerCap);
+    const listCap = searchListCapacity(rows, hasNote);
+    // T52 — invariante di validità della selezione, più stretta che altrove: la
+    // lista si RICOSTRUISCE a ogni carattere digitato, quindi la chiave
+    // selezionata sparisce di continuo. Persa → prima riga, mai una posizione
+    // ereditata (che qui punterebbe a un'altra conversazione, non a un'altra riga).
+    useEffect(() => {
+        if (rowIndexOfKey(searchRows, selKey) < 0) {
+            setSelKey(firstRowKey(searchRows));
+        }
+    }, [searchRows, selKey]);
+    // T52 — `⏎` contestuale al TIPO di riga: la lista ne mescola due e l'azione
+    // giusta dipende da quale è selezionata. Riga sessione → resume, identico al
+    // `⏎` della lista sessioni (stessa funzione, T49). Riga occorrenza → reader.
+    function submitRow() {
+        const row = selectedRow(searchRows, selKey);
+        if (!row) {
+            setNote(result.error ? '⚠ regex non valida' : 'nessuna occorrenza selezionata');
+            return;
+        }
+        if (row.kind === 'session') {
+            onResume(row);
+            return;
+        }
+        // D8 — il reader si apre POSIZIONATO sull'occorrenza, non in cima. Il 94%
+        // dei messaggi entra in una schermata e la differenza non si vede; è sul 6%
+        // lungo (p99 ≈ 88 righe, max ≈ 1547) che aprire in cima costringerebbe a
+        // rifare a mano la ricerca appena fatta — cioè proprio il lavoro che questa
+        // feature esiste per evitare.
+        const lines = wrapWithOffsets(row.hit.text, readerWidth);
+        const cap = readerCapacity(rows);
+        const matchLine = lines.findIndex((l) => l.end > row.hit.matchStart);
+        const maxTop = Math.max(0, lines.length - cap);
+        setReaderRow(row);
+        setReaderTop(Math.max(0, Math.min(maxTop, Math.max(0, matchLine) - Math.floor(cap / 2))));
+        setNote('');
+        setMode('reader');
+    }
+    function scrollReader(delta) {
+        setReaderTop((t) => Math.max(0, Math.min(readerMaxTop, t + delta)));
+    }
+    // T52 — toggle di tipo messaggio. Spegnerli tutti è uno stato lecito (lista
+    // vuota, nessun errore): è l'utente che ha chiuso ogni canale, non un guasto.
+    function toggleKind(kind) {
+        setOpts((o) => ({ ...o, kinds: { ...o.kinds, [kind]: !o.kinds[kind] } }));
+    }
+    function editField(fn) {
+        // La nota racconta l'esito di un'AZIONE su una lista che, con l'eager, si
+        // ricostruisce a ogni carattere: appena la query cambia è già scaduta.
+        // Lasciarla lì la fa leggere come se descrivesse lo stato corrente — nello
+        // specifico «nessuna occorrenza selezionata» sopra una lista con una riga
+        // visibilmente selezionata, cioè una contraddizione a schermo.
+        setNote('');
+        if (field === 'hash')
+            setHash(fn);
+        else
+            setQuery(fn);
+    }
+    // `useInput` consegna il CHUNK letto da stdin, non un tasto: un incollaggio —
+    // o una raffica di tasti piu' veloce di una read — arriva come stringa unica,
+    // byte di controllo compresi. Due conseguenze, entrambe verificate su pty:
+    //
+    //  1. I byte di controllo finiscono DENTRO il campo se non li si filtra. Non
+    //     si vedono, ma Ink li conta nella larghezza della riga e nessun match li
+    //     soddisfa -> la ricerca smette di trovare senza dire perche'. Le newline
+    //     diventano spazio invece di sparire: incollare due righe deve separare
+    //     le parole, non fonderle.
+    //
+    //  2. Un TAB digitato subito dopo una lettera (~60 ms, cioe' battitura veloce
+    //     normale) arriva incollato ad essa: `key.tab` resta falso e il ramo del
+    //     cambio campo non scatta mai. Trattarlo come testo lo renderebbe uno
+    //     spazio, per giunta nel campo sbagliato — e' cosi' che `70897aff` + Tab
+    //     + `congelat` finiva tutto quanto nel campo hash.
+    //
+    // Si spezza quindi il chunk SUL TAB applicando il cambio campo in mezzo: il
+    // risultato e' identico alla battitura lenta. Stessa lezione del modale sort
+    // (T39), che cicla sui caratteri del chunk invece di leggerlo intero.
+    function typeIntoField(chunk) {
+        setNote('');
+        const parts = chunk.split('\t');
+        let cur = field;
+        const add = { hash: '', query: '' };
+        for (let k = 0; k < parts.length; k++) {
+            if (k > 0)
+                cur = cur === 'hash' ? 'query' : 'hash';
+            add[cur] += sanitizeTyped(parts[k]);
+        }
+        if (add.hash)
+            setHash((v) => v + add.hash);
+        if (add.query)
+            setQuery((v) => v + add.query);
+        setField(cur);
+    }
+    /** Apertura del modale dal modo normale: `^F`. */
+    function open() {
+        setNote('');
+        setMode('search');
+    }
+    // Handler del modo `reader`. Sta prima di quello della ricerca nel catalogo di
+    // `input-modes.ts`, ma la precedenza la porta ormai il modo: `mode` è un
+    // valore solo, quindi i due non possono essere attivi insieme.
+    function onReaderKey(input, key) {
+        if (key.escape) {
+            setMode('search');
+            setReaderRow(null);
+        }
+        else if (key.upArrow) {
+            scrollReader(-1);
+        }
+        else if (key.downArrow) {
+            scrollReader(1);
+        }
+        else if (key.pageUp) {
+            scrollReader(-readerCap);
+        }
+        else if (key.pageDown) {
+            scrollReader(readerCap);
+        }
+        else if (input === 'g') {
+            // Estremi su lettera e non su Home/End: Ink RICONOSCE quelle due (le
+            // mappa a 'home'/'end' nel parser) ma NON le espone — `nonAlphanumericKeys`
+            // azzera l'input e nessun flag le rappresenta, quindi arrivano
+            // indistinguibili da qualunque tasto ignoto. Verificato su pty reale.
+            // Nel reader non c'è input di testo, quindi le lettere sono libere.
+            setReaderTop(0);
+        }
+        else if (input === 'G') {
+            setReaderTop(readerMaxTop);
+        }
+    }
+    // T52 — modale ricerca. I due campi di testo mangiano ogni lettera nuda:
+    // ogni comando che deve restare vivo MENTRE si digita passa da CTRL, dai
+    // tasti freccia o da Tab. `esc` chiude il modale, non il deck.
+    function onSearchKey(input, key) {
+        if (key.escape) {
+            setMode('normal');
+            setNote('');
+            return;
+        }
+        if (key.ctrl) {
+            const flag = SEARCH_TOGGLE_KEYS[input];
+            if (flag) {
+                setOpts((o) => ({ ...o, [flag]: !o[flag] }));
+                return;
+            }
+            const kind = SEARCH_KIND_KEYS[input];
+            if (kind)
+                toggleKind(kind);
+            return; // ogni altra combo ctrl (^F incluso: siamo già dentro) = no-op
+        }
+        if (key.tab) {
+            setField((f) => (f === 'hash' ? 'query' : 'hash'));
+        }
+        else if (key.upArrow) {
+            setSelKey((k) => moveRowSelection(searchRows, k, -1));
+        }
+        else if (key.downArrow) {
+            setSelKey((k) => moveRowSelection(searchRows, k, 1));
+        }
+        else if (key.pageUp) {
+            setSelKey((k) => moveRowSelection(searchRows, k, -Math.max(1, listCap)));
+        }
+        else if (key.pageDown) {
+            setSelKey((k) => moveRowSelection(searchRows, k, Math.max(1, listCap)));
+        }
+        else if (key.return) {
+            submitRow();
+        }
+        else if (key.backspace || key.delete) {
+            editField((s) => s.slice(0, -1));
+        }
+        else if (input && !key.meta) {
+            typeIntoField(input);
+        }
+    }
+    return {
+        hash,
+        query,
+        field,
+        opts,
+        selKey,
+        setSelKey,
+        result,
+        rows: searchRows,
+        selRow,
+        previewBody,
+        readerRow,
+        readerTop,
+        readerLines,
+        readerCap,
+        readerMaxTop,
+        listCap,
+        open,
+        onReaderKey,
+        onSearchKey,
+    };
+}

package/dist/overlays/sheet.js

@@ -0,0 +1,222 @@
+// Overlay DETAIL della task (T66) con la sua ricerca interna (T91).
+//
+// Lo `sheet` è la task FOTOGRAFATA all'apertura — id, titolo e testo integrale
+// del task file — e non una vista sulla selezione corrente: l'overlay copre la
+// lista, quindi l'oggetto dell'azione deve restare quello che si è scelto anche
+// se un tick del poll spostasse la selezione sotto.
+//
+// Si chiama `sheet` e non `detail` perché in `Deck` `detail` è già il
+// `TaskDetail` del blocco preview sotto i pane: due cose vicine con lo stesso
+// nome sono una trappola di lettura.
+//
+// Lo spawn della sessione dalla barra azioni NON sta qui: arriva come callback
+// `onAction`, per lo stesso confine di `useSearchOverlay`.
+import { useEffect, useMemo, useState } from 'react';
+import { detailCapacity } from '../viewport.js';
+import { wrapWithOffsets } from '../width.js';
+import { scanText, topForOffset } from '../text-search.js';
+import { parseMarkdown } from '../markdown.js';
+import { cpLen, insertAt, removeAt } from '../layout.js';
+import { sanitizeTyped } from '../glyphs.js';
+import { DETAIL_ACTIONS } from '../spawn.js';
+export function useSheetOverlay(deps) {
+    const { rows, columns, setMode, setNote, onAction } = deps;
+    const [sheet, setSheet] = useState(null);
+    const [top, setTop] = useState(0);
+    const [action, setAction] = useState(0);
+    // T91 — ricerca dentro il detail. `open` distingue i due modi in cui la si
+    // lascia: `esc` butta via ciò che il modale ha prodotto (`find` a null,
+    // evidenziazione via), `⏎` lo congela e restituisce il controllo allo strato
+    // sotto — campo chiuso, occorrenze ancora colorate, scroll dov'era. Senza il
+    // flag i due gesti collasserebbero su uno solo.
+    const [find, setFind] = useState(null);
+    const [occIdx, setOccIdx] = useState(0);
+    // Cornici da scalare: box esterno (2 bordi + 2 padding) + box testo (2 bordi +
+    // 2 padding) = 8. Sottostimare tronca un carattere, sovrastimare manda a capo
+    // una riga che il budget d'altezza non ha contato.
+    const width = Math.max(20, (columns || 80) - 8);
+    // T75 — il markdown si rende PRIMA del wrap, e il resto della catena lavora
+    // sul testo reso: `**foo**` occupa 3 colonne rese e 7 grezze, quindi
+    // wrappare sui marker manderebbe a capo su un conteggio che il terminale non
+    // disegna. Memo separato dal wrap perché il parse dipende solo dal testo: un
+    // resize ri-wrappa 9KB, non li ri-parsa.
+    const doc = useMemo(() => (sheet?.text ? parseMarkdown(sheet.text) : null), [sheet]);
+    // Le righe conservano i propri offset invece di essere appiattite a stringa
+    // (T66 le buttava con `.map((l) => l.text)`): è ciò che rende
+    // l'evidenziazione un'intersezione di intervalli invece di un caso speciale
+    // per il match spezzato dall'a-capo. Dopo T75 gli offset indicizzano il testo
+    // RESO, ed è l'unica coordinata coerente che resti — il sorgente non è più
+    // ciò che sta a schermo.
+    const lines = useMemo(() => (doc ? wrapWithOffsets(doc.text, width) : []), [doc, width]);
+    const capacity = detailCapacity(rows, find?.open === true);
+    const maxTop = Math.max(0, lines.length - capacity);
+    // Lo scan gira sulla STESSA stringa che si renderizza: cercare su un testo
+    // diverso da quello a schermo darebbe offset che indicizzano un altro
+    // documento, cioè un'evidenziazione spostata di N caratteri e nessun errore.
+    //
+    // Dopo T75 quella stringa è il testo RESO, non più il sorgente: si cerca ciò
+    // che si vede. Ne discende che `**` non è più cercabile — è la conseguenza
+    // voluta, perché a schermo non c'è; e `Priority`, che prima era `**Priority**`
+    // e si trovava lo stesso, continua a trovarsi.
+    const findRes = useMemo(() => (find && doc ? scanText(doc.text, find.q) : { occ: [], error: '' }), [find?.q, doc]);
+    // L'indice si clampa qui invece di essere corretto a ogni `setOccIdx`: la
+    // lista si accorcia da sola mentre si digita, e un indice fuori range vivrebbe
+    // per il tempo di un render.
+    const occCur = findRes.occ.length > 0 ? Math.min(occIdx, findRes.occ.length - 1) : -1;
+    // Salto all'occorrenza corrente, centrata. Non dipende da `top`, quindi non si
+    // auto-rilancia; dipende da `lines` e `capacity`, quindi un resize ricalcola
+    // la posizione senza toccare le occorrenze — che sono offset del sorgente e il
+    // resize non le sposta.
+    useEffect(() => {
+        const o = occCur >= 0 ? findRes.occ[occCur] : undefined;
+        if (!o)
+            return;
+        setTop(topForOffset(lines, o.start, capacity));
+    }, [findRes, occCur, lines, capacity]);
+    /** Apre il detail su una task, azzerando scroll, azione e ricerca. */
+    function open(next) {
+        setSheet(next);
+        setTop(0);
+        setAction(0);
+        setFind(null);
+        setOccIdx(0);
+        setNote('');
+        setMode('detail');
+    }
+    function close() {
+        setMode('normal');
+        setSheet(null);
+        setFind(null);
+    }
+    function scroll(delta) {
+        setTop((t) => Math.max(0, Math.min(maxTop, t + delta)));
+    }
+    /** Modifica la query: l'insieme delle occorrenze cambia, quindi si riparte
+     *  dalla prima. Il movimento del caret NON passa di qui — sposta il cursore,
+     *  non i risultati. */
+    function editFind(next) {
+        setFind((f) => (f ? next(f) : f));
+        setOccIdx(0);
+    }
+    function moveOcc(d) {
+        const n = findRes.occ.length;
+        if (n === 0)
+            return;
+        setOccIdx((i) => (Math.min(i, n - 1) + d + n) % n);
+    }
+    // T91 — il campo di ricerca è un modale DENTRO il detail, e lo intercetta per
+    // intero: mentre è aperto mangia ogni lettera nuda, `g`/`G` compresi.
+    function onFindKey(input, key) {
+        if (key.escape) {
+            // Annulla: butta via ciò che il modale ha prodotto. Lo scroll resta dove
+            // la ricerca l'ha portato — riavvolgerlo sarebbe una terza semantica che
+            // nessun tasto ha chiesto.
+            setFind(null);
+        }
+        else if (key.return) {
+            // Congela: campo chiuso, occorrenze ancora colorate, scroll intatto.
+            setFind((f) => (f ? { ...f, open: false } : f));
+        }
+        else if (key.upArrow) {
+            moveOcc(-1);
+        }
+        else if (key.downArrow) {
+            moveOcc(1);
+        }
+        else if (key.leftArrow || key.rightArrow) {
+            const d = key.leftArrow ? -1 : 1;
+            setFind((f) => (f ? { ...f, caret: Math.max(0, Math.min(cpLen(f.q), f.caret + d)) } : f));
+        }
+        else if (key.backspace || key.delete) {
+            editFind((f) => f.caret > 0 ? { ...f, q: removeAt(f.q, f.caret - 1), caret: f.caret - 1 } : f);
+        }
+        else if (key.ctrl) {
+            // `^U` svuota, come il filtro del modale assegnazione; ogni altra combo
+            // è no-op — `^F` incluso, siamo già dentro.
+            if (input === 'u')
+                editFind((f) => ({ ...f, q: '', caret: 0 }));
+        }
+        else if (input && !key.meta) {
+            const ins = sanitizeTyped(input);
+            editFind((f) => ({ ...f, q: insertAt(f.q, f.caret, ins), caret: f.caret + cpLen(ins) }));
+        }
+    }
+    // T66 — detail della task: due zone (testo scrollabile + barra azioni) e una
+    // selezione per ognuna. Il modo cattura TUTTO, acceleratori `^K`/`^P`/`^R`
+    // compresi: chi è già nel detail ha i bottoni. L'unica deroga è `^F`, che qui
+    // apre la ricerca nel testo invece di quella sulle conversazioni.
+    function onKey(input, key) {
+        if (find?.open) {
+            onFindKey(input, key);
+            return;
+        }
+        if (key.ctrl && input === 'f') {
+            // Fuori dal detail `^F` è la ricerca conversazioni; qui è la ricerca nel
+            // testo. La query sopravvive a una chiusura con `⏎`, quindi riaprire
+            // riprende da dov'era invece di ricominciare.
+            setFind((f) => (f ? { ...f, open: true } : { q: '', caret: 0, open: true }));
+            return;
+        }
+        if (key.escape) {
+            // Uno strato alla volta: se resta un'evidenziazione congelata, `esc`
+            // smonta quella; il detail lo chiude il secondo.
+            // Nessun reset di `sel`: la selezione della lista non è mai stata
+            // toccata, quindi si ritrova esattamente dov'era.
+            if (find)
+                setFind(null);
+            else
+                close();
+        }
+        else if (key.return) {
+            // `⏎` esegue SEMPRE l'azione selezionata, mai "scrolla" o "chiudi": il
+            // testo non è un campo attivo (si scorre, non si edita), quindi nessuna
+            // competizione sul tasto.
+            const act = DETAIL_ACTIONS[action];
+            const id = sheet?.id;
+            close();
+            if (id)
+                onAction(id, act.kind, `⏎ ${act.label}`);
+        }
+        else if (key.leftArrow || key.rightArrow) {
+            // Scorrimento CICLICO come le righe di scelta del modale edit: cinque
+            // voci, arrivare in fondo e ripartire costa meno che invertire direzione.
+            const d = key.leftArrow ? -1 : 1;
+            setAction((i) => (i + d + DETAIL_ACTIONS.length) % DETAIL_ACTIONS.length);
+        }
+        else if (key.upArrow) {
+            scroll(-1);
+        }
+        else if (key.downArrow) {
+            scroll(1);
+        }
+        else if (key.pageUp) {
+            scroll(-capacity);
+        }
+        else if (key.pageDown) {
+            scroll(capacity);
+        }
+        else if (input === 'g') {
+            // Estremi su lettera per lo stesso motivo del reader: Ink riconosce
+            // `Home`/`End` ma non le espone, e qui non c'è input di testo che
+            // contenda le lettere.
+            setTop(0);
+        }
+        else if (input === 'G') {
+            setTop(maxTop);
+        }
+    }
+    return {
+        sheet,
+        doc,
+        top,
+        action,
+        find,
+        lines,
+        capacity,
+        maxTop,
+        findRes,
+        occCur,
+        open,
+        onKey,
+    };
+}

package/dist/pane-views.js

@@ -1,7 +1,7 @@
 // T100 — Catalogo delle viste dei due pane. L'header smette di essere una riga
 // di contatori e diventa un SELETTORE: ogni segmento che nomina un sottoinsieme
 // calcolabile (`nascoste`, `archiviabili`, `vive`, `📌`, `+più vecchie`) è una
-// vista raggiungibile con ←/→.
+// vista raggiungibile con `tab`.
 //
 // Modulo PURO: nessun import da ink/react, nessun I/O. Il calcolo resta dove
 // stava — `view.ts` per i filtri task, `session-list.ts` per l'assemblaggio a