@lamemind/loom-deck 0.55.0 → 0.56.1

package/dist/ui/screens.js

@@ -0,0 +1,201 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+// Le SCHERMATE SOSTITUTIVE del deck e i due frammenti che le accompagnano.
+//
+// Una schermata sostitutiva prende il frame intero invece di stare in un box
+// sopra i due pane: assegnazione, detail della task, project status, ricerca e
+// reader. Il criterio è la taglia del contenuto — una lista di occorrenze o un
+// task file non entrano in quattro righe — e la conseguenza è che il budget
+// d'altezza dei pane non viene nemmeno calcolato, perché il render esce prima.
+//
+// `screenFor` è il ROUTER: sceglie fra le cinque e restituisce `null` quando
+// nessuna è attiva, cioè quando si resta sulla lista. È una funzione e non un
+// componente proprio per questo — il chiamante deve poter distinguere «ecco la
+// schermata» da «non è il tuo turno», e un componente che rende `null` non gli
+// direbbe la differenza in tempo utile per il proprio `return`.
+//
+// Fino a T131 le cinque vivevano in `cli.tsx` come cinque `if` consecutivi, con
+// dentro le derivazioni di finestra di ognuna. Sono uscite insieme perché la
+// scelta fra le viste non è né vista né input: la vista disegna ciò che le
+// viene dato, l'input decide cosa cambiare, e chi sceglie quale albero tornare
+// è un terzo mestiere.
+//
+// Direzione della dipendenza: questo file importa i TIPI di ritorno degli hook
+// di `src/overlays/` (`import type` + `ReturnType`, nessun import a runtime).
+// È lecito nell'asse — la vista sta a valle dell'input, mai a monte — ed è il
+// primo file di `ui/` a farlo, quindi va detto invece che scoperto a grep.
+import { Box, Text } from 'ink';
+import { rowIndexOfKey, selectedRow } from '../search.js';
+import { isCompact, searchPreviewCapacity, windowRange } from '../viewport.js';
+import { conversationLabel } from '../layout.js';
+import { taskColumns } from '../view.js';
+import { AssignScreen } from './assign-screen.js';
+import { DetailScreen } from './detail-screen.js';
+import { StatusScreen } from './status-screen.js';
+import { ReaderScreen, SearchScreen } from './search-screen.js';
+/**
+ * Il ripiego per un terminale troppo basso: una riga sola al posto della
+ * cornice. Perdere il layout è meglio che sfondare `rows` — oltre quella
+ * soglia Ink smette di aggiornare per differenza e pulisce lo schermo a ogni
+ * redraw, versando un frame intero nello scrollback a ogni tick del poll.
+ *
+ * Sei call site lo usavano in copia (le cinque schermate più la lista), identici
+ * tranne il soggetto e il verbo di `esc`. `dot` esiste perché la sesta copia —
+ * quella della lista — attacca al nome del programma la propria VERSIONE, e un
+ * punto in mezzo la staccherebbe da ciò di cui è la versione.
+ */
+export function CompactNotice({ what, esc, rows, columns, dot = true, }) {
+    return (_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { bold: true, color: "cyan", children: "loom-deck" }), _jsxs(Text, { dimColor: true, children: [dot ? ' · ' : ' ', what, " \u00B7 terminale ", rows, "\u00D7", columns, ": troppo basso, allarga", esc ? ` · esc ${esc}` : ''] })] }));
+}
+/**
+ * La riga sotto la testata: in `normal` la legenda dei tasti, in un modale in
+ * flusso le sue istruzioni. I modali sostitutivi non arrivano qui — hanno già
+ * preso il frame.
+ *
+ * La legenda di `normal` la calcola il chiamante (`deckLegend` in `frame.ts`),
+ * perché dipende da cosa è selezionato; le sette righe dei modali sono testo
+ * fisso e vivono qui, accanto alla forma che le rende.
+ */
+export function HintBar({ mode, purge, keyLegend, }) {
+    if (mode === 'create') {
+        return (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["nuova task \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " crea \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] }));
+    }
+    if (mode === 'sort') {
+        return (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["sort \u00B7 ", _jsx(Text, { color: "yellow", children: "p" }), " pri ", _jsx(Text, { color: "yellow", children: "s" }), " stato", ' ', _jsx(Text, { color: "yellow", children: "i" }), " id (asc\u2192desc\u2192off) \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " ok \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] }));
+    }
+    if (mode === 'filter') {
+        return (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["filtri \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2191\u2193\u2190\u2192" }), " naviga \u00B7 ", _jsx(Text, { color: "yellow", children: "spazio" }), ' ', "mostra/nascondi \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " ok \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] }));
+    }
+    if (mode === 'note') {
+        return (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["titolo conversazione \u00B7 ", _jsx(Text, { color: "yellow", children: "^U" }), " svuota \u00B7", ' ', _jsx(Text, { color: "yellow", children: "\u23CE" }), " salva (vuoto = rimuove) \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] }));
+    }
+    if (mode === 'purge') {
+        return (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["elimina task \u00B7", ' ', purge?.ignored ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: "yellow", children: "\u2190\u2192" }), " keep/purge dei file non tracciati \u00B7", ' '] })) : null, _jsx(Text, { color: "yellow", children: "\u23CE" }), " conferma \u00B7 ", _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] }));
+    }
+    if (mode === 'edit') {
+        return (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["edit \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2191\u2193" }), " campo \u00B7 ", _jsx(Text, { color: "yellow", children: "\u2190\u2192" }), " valore, o cursore sul testo \u00B7 ", _jsx(Text, { color: "yellow", children: "^A/^E" }), " inizio/fine \u00B7", ' ', _jsx(Text, { color: "yellow", children: "^D" }), " canc \u00B7 ", _jsx(Text, { color: "yellow", children: "\u23CE" }), " salva+commit \u00B7", ' ', _jsx(Text, { color: "yellow", children: "esc" }), " annulla"] }));
+    }
+    return (_jsx(Text, { dimColor: true, wrap: "truncate-end", children: keyLegend }));
+}
+/**
+ * Sceglie la schermata sostitutiva attiva, o `null` per restare sulla lista.
+ *
+ * L'ordine dei rami è quello che avevano in `cli.tsx` e non è indifferente: i
+ * modi si escludono a vicenda, ma `detail` e `status` chiedono anche che il
+ * proprio contenuto esista (`sheet.sheet`, `status.view`) — un modo dichiarato
+ * senza contenuto deve cadere alla lista, non a una schermata vuota.
+ */
+export function screenFor(input) {
+    const { mode, rows, columns, note, overlays } = input;
+    const { assign, sheet, search, status } = overlays;
+    // ── T57 · schermata di assegnazione ─────────────────────────────────────
+    // Sostitutiva come ricerca e reader (D3): la lista task non entra in un box
+    // sopra i due pane, e prendendo l'intero frame non costa nulla al loro budget.
+    // Conseguenza obbligata della scelta: la sessione in assegnazione non è più
+    // visibile, quindi va RIPETUTA nel titolo — senza, non si sa più su cosa si
+    // sta agendo.
+    if (mode === 'assign') {
+        if (isCompact(assign.capacity)) {
+            return _jsx(CompactNotice, { what: "assegna", esc: "annulla", rows: rows, columns: columns });
+        }
+        const at = assign.list.findIndex((t) => (t?.id ?? null) === assign.sel);
+        const win = windowRange(assign.list.length, at, assign.capacity);
+        const s = assign.sid
+            ? input.sessions.find((x) => x.sessionId === assign.sid) ?? null
+            : null;
+        // Etichetta della conversazione: la nota umana se c'è (è il nome con cui la
+        // riconosci), altrimenti la stessa derivazione della ricerca. Su una pinnata
+        // stale non resta nulla: il titolo si accontenta dell'hash.
+        const label = (assign.sid ? input.sessionNotes.get(assign.sid) : '') ||
+            (s
+                ? conversationLabel(s, input.projectCore, assign.sid ? input.bindings.get(assign.sid) : undefined)
+                : '');
+        // T124 — le colonne si misurano sulla lista FILTRATA di questa schermata,
+        // non su `paneTasks`: la popolazione è un'altra, e riusare le larghezze del
+        // pane darebbe una colonna dimensionata su righe che qui non ci sono.
+        // `assign.list` porta in testa la riga `detach` (`null`), che non è una task.
+        const assignCols = taskColumns(assign.list.filter((t) => t !== null), input.taskRowData);
+        return (_jsx(AssignScreen, { sessionId: assign.sid ?? '', label: label, current: assign.sid ? input.bindings.get(assign.sid) ?? null : null, filter: assign.filter, rows: assign.list.slice(win.start, win.end), selected: assign.sel, matched: assign.list.length - 1, hidden: input.hiddenTasks, above: win.start, below: assign.list.length - win.end, idW: assignCols.id, tailW: assignCols.tail, data: input.taskRowData, columns: columns, note: note }));
+    }
+    // ── T66 · detail della task ─────────────────────────────────────────────
+    // Quarta schermata sostitutiva, stessa ragione delle altre tre: un task file
+    // non entra in un box sopra i due pane. Il budget dei pane non viene nemmeno
+    // calcolato — il render esce di qui prima.
+    if (mode === 'detail' && sheet.sheet) {
+        if (isCompact(sheet.capacity)) {
+            return (_jsx(CompactNotice, { what: sheet.sheet.id, esc: "chiude", rows: rows, columns: columns }));
+        }
+        // Niente `windowRange`: quella centra la finestra su una selezione, qui la
+        // posizione è lo scroll mosso a mano. Il clamp serve comunque — un resize
+        // può accorciare il testo sotto uno scroll già dato.
+        const start = Math.min(sheet.top, sheet.maxTop);
+        return (_jsx(DetailScreen, { id: sheet.sheet.id, title: sheet.sheet.title, missing: sheet.sheet.text === null, lines: sheet.lines.slice(start, start + sheet.capacity), spans: sheet.doc?.spans ?? [], top: start, total: sheet.lines.length, capacity: sheet.capacity, action: sheet.action, model: sheet.model, spawnNote: sheet.spawnNote, prompt: sheet.prompt, cursor: sheet.cursor, columns: columns, find: sheet.find, occ: sheet.findRes.occ, occCur: sheet.occCur }));
+    }
+    // ── T121 · viewer del project status ────────────────────────────────────
+    // Quinta schermata sostitutiva, stessa ragione delle altre quattro: un recap
+    // di progetto è lungo quanto un task file e non entra in un box sopra i pane.
+    if (mode === 'status' && status.view) {
+        if (isCompact(status.capacity)) {
+            return (_jsx(CompactNotice, { what: "project status", esc: "chiude", rows: rows, columns: columns }));
+        }
+        // Il clamp serve anche qui: un resize può accorciare il testo sotto uno
+        // scroll già dato.
+        const start = Math.min(status.top, status.maxTop);
+        return (_jsx(StatusScreen, { name: input.projectCore ?? input.projectName, label: status.label, building: status.building, failed: status.failed, view: status.view, lines: status.lines.slice(start, start + status.capacity), spans: status.doc?.spans ?? [], top: start, total: status.lines.length, capacity: status.capacity, columns: columns }));
+    }
+    // ── T52 · ricerca e reader ──────────────────────────────────────────────
+    // Gli unici modali che NON stanno in flusso sopra i pane: una lista di
+    // occorrenze non entra in un box da 4 righe. Prendono l'intero frame, quindi
+    // escono di qui — il budget dei due pane sotto non serve nemmeno calcolarlo,
+    // e la loro altezza la distribuiscono `searchListCapacity` / `readerCapacity`.
+    if (mode === 'search' || mode === 'reader') {
+        const hit = mode === 'reader' && search.readerRow?.kind === 'hit' ? search.readerRow.hit : null;
+        // Terminale sotto la cornice: riga singola invece del box, per lo stesso
+        // motivo del `budget.compact` del deck — un frame più alto di `rows` fa
+        // pulire lo schermo a Ink a ogni redraw, e il poll lo versa nello scrollback.
+        if (isCompact(hit ? search.readerCap : search.listCap)) {
+            return (_jsx(CompactNotice, { what: hit ? 'reader' : 'ricerca', esc: hit ? 'torna' : 'chiude', rows: rows, columns: columns }));
+        }
+        if (hit) {
+            // Niente `windowRange`: quella centra la finestra su una SELEZIONE, qui
+            // la posizione è lo scroll che l'utente muove a mano. Il clamp serve
+            // comunque — un resize può accorciare il testo sotto uno scroll già dato.
+            const start = Math.min(search.readerTop, search.readerMaxTop);
+            return (_jsx(ReaderScreen, { hit: hit, lines: search.readerLines.slice(start, start + search.readerCap), top: start, total: search.readerLines.length, capacity: search.readerCap, bound: input.bindings.get(hit.sessionId) ?? null }));
+        }
+        const selIdx = rowIndexOfKey(search.rows, search.selKey);
+        const win = windowRange(search.rows.length, selIdx, search.listCap);
+        // Anteprima dell'occorrenza selezionata: prende le righe che la lista non
+        // usa. Con molti risultati `spare` è 0 e il pannello non esiste — la lista
+        // se le riprende tutte, che è la priorità giusta quando c'è molto da
+        // scorrere. La finestra si CENTRA sul match (`windowRange`), così il
+        // contesto arriva da entrambi i lati.
+        const spare = searchPreviewCapacity(search.listCap, win.end - win.start);
+        let preview = null;
+        if (spare >= 1 && search.selRow?.kind === 'hit') {
+            const h = search.selRow.hit;
+            const mline = Math.max(0, search.previewBody.findIndex((l) => l.end > h.matchStart));
+            const pw = windowRange(search.previewBody.length, mline, spare);
+            preview = {
+                hit: h,
+                lines: search.previewBody.slice(pw.start, pw.end),
+                from: pw.start,
+                total: search.previewBody.length,
+                ts: input.sessions.find((s) => s.sessionId === h.sessionId)?.ts ?? 0,
+            };
+        }
+        return (_jsx(SearchScreen, { preview: preview, hash: search.hash, query: search.query, field: search.field, opts: search.opts, result: search.result, rows: search.rows.slice(win.start, win.end), selectedKey: search.selKey, selectedKind: selectedRow(search.rows, search.selKey)?.kind ?? null, above: win.start, below: search.rows.length - win.end, capacity: search.listCap, bindings: input.bindings, pinned: input.pinned, sessionNotes: input.sessionNotes, projectCore: input.projectCore, columns: columns, note: note }));
+    }
+    return null;
+}
+/**
+ * I due box di testo in flusso — create e nota — e i tre modali che li
+ * accompagnano stanno in `ui/modals.tsx`; qui resta il solo `CreateBox`, che
+ * non aveva una casa perché nato come JSX inline nel corpo del deck.
+ *
+ * Il cursore sta in coda al testo (append only): un cursore mobile vorrebbe
+ * gestire frecce e Home/End, e `Home`/`End` non sono nemmeno esposte da
+ * `useInput`.
+ */
+export function TextBox({ glyph, value }) {
+    return (_jsxs(Box, { borderStyle: "round", borderColor: "yellow", paddingX: 1, marginTop: 1, children: [_jsxs(Text, { color: "yellow", children: [glyph, " \u203A "] }), _jsx(Text, { children: value }), _jsx(Text, { inverse: true, children: " " })] }));
+}

package/dist/wrap-scan.js

@@ -0,0 +1,122 @@
+// T134 — l'hard-wrap dei `.md` come dato del deck.
+//
+// Lo scanner è `scripts/docs/md-wrap.py` del plugin, e resta lì per intero: il
+// riconoscimento del wrap sta in tre euristiche tarate su un collaudo (la
+// colonna è una banda con tolleranza, si stima sul 90° percentile, lo
+// srotolamento itera a colonna ferma) e replicarle qui darebbe due misure
+// destinate a divergere in silenzio.
+//
+// A differenza della coda inbox, questa misura è CARA: cammina l'albero del
+// progetto intero, submodule compresi. Da qui la forma già in casa per il
+// project status — generare e aprire su due tasti distinti, con una cache su
+// disco in mezzo — invece di uno scan all'avvio che rallenterebbe proprio il
+// momento in cui si vuole vedere qualcosa subito.
+import { execFile } from 'node:child_process';
+import { mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { promisify } from 'node:util';
+import { pluginScript } from './plugin-cache.js';
+const execFileAsync = promisify(execFile);
+export const WRAP_SCRIPT = 'scripts/docs/md-wrap.py';
+const FIELD_RE = /^(col|ratio|breaks|prose)=(.*)$/;
+/**
+ * Il TSV di `md-wrap.py --scan`: una riga per file NON `libero`, nella forma
+ * `verdetto ⇥ path ⇥ col=N ⇥ ratio=N ⇥ breaks=N ⇥ prose=N`.
+ *
+ * I campi si leggono per nome e non per posizione: sono già etichettati
+ * nell'output, e leggerli per indice trasformerebbe una colonna aggiunta in
+ * fondo in numeri sbagliati invece che in un campo ignorato.
+ */
+export function parseWrapTsv(stdout) {
+    const out = [];
+    for (const line of stdout.split('\n')) {
+        if (!line.trim())
+            continue;
+        const cells = line.split('\t');
+        const verdict = cells[0];
+        if (verdict !== 'WRAP' && verdict !== 'misto')
+            continue;
+        if (!cells[1])
+            continue;
+        const fields = {};
+        for (const cell of cells.slice(2)) {
+            const m = FIELD_RE.exec(cell.trim());
+            if (m)
+                fields[m[1]] = m[2];
+        }
+        const column = Number(fields.col);
+        out.push({
+            verdict,
+            path: cells[1],
+            column: Number.isFinite(column) ? column : null,
+            ratio: Number(fields.ratio) || 0,
+            breaks: Number(fields.breaks) || 0,
+            prose: Number(fields.prose) || 0,
+        });
+    }
+    // I peggiori in cima: chi apre la lista srotola da lì.
+    return out.sort((a, b) => {
+        if (a.verdict !== b.verdict)
+            return a.verdict === 'WRAP' ? -1 : 1;
+        return b.breaks - a.breaks;
+    });
+}
+/**
+ * D4 — il contatore conta i soli `WRAP`.
+ *
+ * `misto` ospita il falso allarme strutturale: file di note scritte una riga per
+ * pensiero, che nessuno vuole srotolare. Sommarlo darebbe un numero che non si
+ * può portare a zero, e un contatore che non arriva mai a zero smette di essere
+ * letto.
+ */
+export function wrapCount(files) {
+    return files.filter((f) => f.verdict === 'WRAP').length;
+}
+/**
+ * Cartella della cache, una per utente e con `mode 0700` — stessa ragione del
+ * project status: `/tmp` è condivisa, e un file a nome prevedibile può essere
+ * preceduto dal symlink di un altro utente.
+ */
+export function wrapCacheDir() {
+    return join(tmpdir(), `loom-deck-wrap-${process.getuid?.() ?? 0}`);
+}
+export function wrapCacheFile(projectRoot) {
+    const env = process.env.LOOM_DECK_WRAP_FILE;
+    if (env)
+        return env;
+    return join(wrapCacheDir(), `${projectRoot.replace(/[^a-zA-Z0-9]/g, '-')}.tsv`);
+}
+/** File assente o illeggibile → nessuna cache: `missing` è lo stato di partenza. */
+export function readWrapCache(path) {
+    try {
+        const raw = readFileSync(path, 'utf8');
+        return { files: parseWrapTsv(raw), mtime: statSync(path).mtimeMs };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Lo scan, in headless. `false` = guasto — plugin assente, `python3` assente,
+ * script in errore: i tre casi collassano, perché a schermo non cambiano la
+ * prima mossa di chi li vede.
+ *
+ * La cache si riscrive SOLO su successo: un tentativo fallito lascia in piedi
+ * l'esito dell'ultimo scan riuscito, che resta vero e ancora apribile.
+ */
+export async function runWrapScan(projectRoot) {
+    const script = pluginScript(WRAP_SCRIPT);
+    if (!script)
+        return false;
+    try {
+        const { stdout } = await execFileAsync('python3', [script, '--root', projectRoot, '--scan'], { cwd: projectRoot, maxBuffer: 16 * 1024 * 1024 });
+        const path = wrapCacheFile(projectRoot);
+        mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+        writeFileSync(path, stdout, { mode: 0o600 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lamemind/loom-deck",
-  "version": "0.55.0",
+  "version": "0.56.1",
   "description": "Deck TUI Ink per-progetto della famiglia loom: legge tasks.md e spawna sessioni Claude Code bound via LOOM_TASK",
   "type": "module",
   "bin": {