@lamemind/loom-deck 0.31.0 → 0.33.0

package/dist/markdown.js

@@ -0,0 +1,260 @@
+// Rendering del markdown per il detail della task (T75): dal sorgente al
+// testo VISIBILE più gli intervalli da colorare.
+//
+// PERCHÉ IL PARSER PRODUCE TESTO E NON COLORE. La tentazione naturale è
+// restituire una stringa già colorata con escape ANSI dentro. Sarebbe il modo
+// più corto e il più sbagliato: `width.ts` misura CARATTERI per contare le
+// colonne del terminale, e una sequenza `ESC[1m` le violerebbe tutte —
+// `termWidth` conterebbe colonne che il terminale non disegna, quindi l'a-capo
+// cadrebbe nel posto sbagliato e il bordo del pane verrebbe mangiato.
+//
+// Da qui la separazione: qui si producono `(testo-visibile, span tipizzati)`,
+// il colore lo mette il render intersecando gli span con le righe wrappate.
+//
+// PERCHÉ I MARKER VANNO VIA PRIMA DEL WRAP, non dopo. `**foo**` occupa 3
+// colonne rese e 7 grezze. Wrappare sul testo con i marker manderebbe a capo
+// contando 7, cioè ogni riga uscirebbe più corta del budget di 4 colonne per
+// ogni `**` — un a-capo sbagliato, non un difetto estetico. La catena è quindi
+// obbligata:
+//
+//   sanitize(raw)  →  parseMarkdown  →  wrapWithOffsets  →  interseca
+//
+// `sanitize` sta PRIMA (T75 · D1) perché non conserva la lunghezza: timbra col
+// VS16 ogni glifo BMP largo 2 e sostituisce i discordi (`⚠`→`❗️`, `✔`→`✅️`),
+// quindi applicarla dopo sposterebbe gli offset appena calcolati. Applicarla
+// prima è sicuro perché i marker markdown sono ASCII e cadono fuori dal suo
+// insieme di rischio. Nel deck la sanificazione avviene già al confine di
+// caricamento (`loadTaskFileText`), quindi qui il testo arriva timbrato.
+//
+// GLI SPAN SONO PIATTI E DISGIUNTI. Il nesting del markdown (codice dentro un
+// heading, grassetto dentro un bullet) è risolto QUI, non al render: ogni
+// carattere del testo reso appartiene al più a uno span. Il render diventa
+// così una mappa `kind → attributi Ink` senza logica di merge, ed è la stessa
+// proprietà che permette di comporre questi span con quelli della ricerca
+// (`sliceLine` in `text-search.ts`) senza che le due segmentazioni si
+// contendano lo stesso carattere.
+/** Apertura o chiusura di un blocco di codice: almeno tre backtick a inizio
+ *  riga, eventualmente indentati. La info-string dopo i backtick (` ```bash `)
+ *  fa parte del delimitatore e sparisce con lui. */
+const FENCE = /^\s*```/;
+/** `# ` … `###### ` — lo spazio è obbligatorio, o `#tag` diventerebbe un
+ *  titolo. Il livello non si conserva: la resa è la stessa per tutti (D4). */
+const HEADING = /^(#{1,6})\s+(.*)$/;
+/** Voce di elenco: indentazione + marker + almeno uno spazio. Lo spazio
+ *  obbligatorio è ciò che tiene fuori `---` (riga orizzontale) e `**bold**` a
+ *  inizio riga, che altrimenti passerebbero per bullet. Indentazione e spazio
+ *  dopo il marker sono catturati per essere RIMESSI identici: il glifo occupa
+ *  una colonna come il marker che sostituisce, quindi conservare i due lati
+ *  conserva la colonna d'inizio del testo, che è ciò che tiene allineato un
+ *  elenco scritto a mano. */
+const BULLET = /^(\s*)[-*+](\s+)/;
+/** Il glifo del bullet. Concorde (`stringWidth` 1, `termWidth` 1), quindi si
+ *  può inserire DOPO `sanitize` senza violare l'invariante ① di `width.ts`. */
+const BULLET_GLYPH = '•';
+/**
+ * Testo reso e span di stile a partire dal markdown grezzo.
+ *
+ * Due livelli, e l'ordine fra loro non è negoziabile: il blocco decide se
+ * l'inline gira o è sospeso. Dentro un fence `**` e i backtick sono contenuto,
+ * non marcatura — una regex per riga non potrebbe saperlo, perché il fence ha
+ * stato multi-riga.
+ *
+ * Fuori scope per scelta (T75): tabelle — l'inline ci gira sopra come ovunque,
+ * ma le colonne non vengono allineate — corsivo e link.
+ */
+export function parseMarkdown(src) {
+    const out = [];
+    const spans = [];
+    /** Offset del reso a cui inizierà la prossima riga emessa. */
+    let base = 0;
+    let inFence = false;
+    const emit = (text, lineSpans) => {
+        for (const s of lineSpans) {
+            spans.push({ start: base + s.start, end: base + s.end, kind: s.kind });
+        }
+        out.push(text);
+        base += text.length + 1; // +1 = il '\n' che unirà questa riga alla prossima
+    };
+    for (const line of src.split('\n')) {
+        if (FENCE.test(line)) {
+            // D2 — il delimitatore è un marker quanto `**` e `#`, quindi sparisce
+            // come gli altri: il confine del blocco lo porta il colore uniforme.
+            // Conseguenza contabile: due righe in meno per fence nel totale che
+            // alimenta il contatore `righe N-M di T`.
+            inFence = !inFence;
+            continue;
+        }
+        if (inFence) {
+            emit(line, line.length > 0 ? [{ start: 0, end: line.length, kind: 'fence' }] : []);
+            continue;
+        }
+        const h = HEADING.exec(line);
+        if (h) {
+            const body = h[2];
+            const r = scanInline(body, 'heading');
+            emit(r.text, r.spans);
+            continue;
+        }
+        const b = BULLET.exec(line);
+        if (b) {
+            const r = scanInline(line.slice(b[0].length), null);
+            const prefix = b[1] + BULLET_GLYPH + b[2];
+            emit(prefix + r.text, r.spans.map((s) => ({ ...s, start: s.start + prefix.length, end: s.end + prefix.length })));
+            continue;
+        }
+        const r = scanInline(line, null);
+        emit(r.text, r.spans);
+    }
+    return { text: out.join('\n'), spans };
+}
+/**
+ * Livello inline: `**grassetto**` e `` `codice` `` su UNA riga.
+ *
+ * `base` è il costrutto che avvolge la riga (`heading`) o `null` per il testo
+ * normale, e serve a due cose: riempire i tratti non marcati con lo stile del
+ * blocco, e assorbire il grassetto quando il blocco è già enfatizzato — un
+ * `**` dentro un titolo non deve spezzarlo in un pezzo cyan e uno bianco.
+ *
+ * **Il perimetro è la riga, e questo è il presidio contro il marker spaiato.**
+ * Un `**` che non si chiude non può mangiare il resto del documento perché la
+ * ricerca del chiudente non esce dalla riga: resta letterale, il testo non si
+ * perde e il documento sotto è intatto.
+ *
+ * Precedenza al codice, come in CommonMark: dentro `` `**x**` `` gli asterischi
+ * sono contenuto. Ne discende l'ordine dei rami qui sotto.
+ */
+function scanInline(src, base) {
+    let text = '';
+    const spans = [];
+    /** Inizio del tratto corrente non ancora coperto da uno span inline. */
+    let plain = 0;
+    let i = 0;
+    const closePlain = () => {
+        if (base && text.length > plain)
+            spans.push({ start: plain, end: text.length, kind: base });
+        plain = text.length;
+    };
+    while (i < src.length) {
+        const ch = src[i];
+        if (ch === '`') {
+            // Delimitatore a N backtick: chiude su una sequenza di ESATTAMENTE N.
+            // Serve davvero, non è zelo — la doc di questo progetto cita i backtick
+            // scrivendo `` `code` ``, e un parser a un backtick solo la ridurrebbe a
+            // poltiglia.
+            let n = 0;
+            while (src[i + n] === '`')
+                n++;
+            const close = findFenceRun(src, i + n, n);
+            if (close >= 0) {
+                closePlain();
+                const start = text.length;
+                text += stripPadding(src.slice(i + n, close));
+                if (text.length > start)
+                    spans.push({ start, end: text.length, kind: 'code' });
+                plain = text.length;
+                i = close + n;
+                continue;
+            }
+            // Non si chiude entro la riga: i backtick sono testo.
+            text += src.slice(i, i + n);
+            i += n;
+            continue;
+        }
+        if (ch === '*' && src[i + 1] === '*') {
+            const close = src.indexOf('**', i + 2);
+            if (close >= 0) {
+                closePlain();
+                const start = text.length;
+                // Il contenuto si riparsa: `**testo con `codice`**` è legittimo, e il
+                // codice dentro vince sul grassetto perché è più specifico.
+                const inner = scanInline(src.slice(i + 2, close), base ?? 'bold');
+                text += inner.text;
+                for (const s of inner.spans) {
+                    spans.push({ start: start + s.start, end: start + s.end, kind: s.kind });
+                }
+                plain = text.length;
+                i = close + 2;
+                continue;
+            }
+            text += '**';
+            i += 2;
+            continue;
+        }
+        text += ch;
+        i++;
+    }
+    closePlain();
+    return { text, spans: coalesce(spans) };
+}
+/** Prima sequenza di ESATTAMENTE `n` backtick a partire da `from`; -1 se non
+ *  c'è. Una sequenza più lunga non chiude — è la regola CommonMark, ed è ciò
+ *  che permette a `` `` ` `` `` di contenere un backtick singolo. */
+function findFenceRun(s, from, n) {
+    for (let i = from; i < s.length; i++) {
+        if (s[i] !== '`')
+            continue;
+        let k = 0;
+        while (s[i + k] === '`')
+            k++;
+        if (k === n)
+            return i;
+        i += k - 1;
+    }
+    return -1;
+}
+/** Uno spazio di cortesia in testa e in coda si toglie: serve a scrivere
+ *  `` ` `` senza incollarlo ai delimitatori, non a spaziare il risultato. */
+function stripPadding(s) {
+    if (s.length > 1 && s.startsWith(' ') && s.endsWith(' ') && s.trim().length > 0) {
+        return s.slice(1, -1);
+    }
+    return s;
+}
+/** Fonde gli intervalli adiacenti dello stesso kind: il riempimento del tratto
+ *  base ne produce a raffica, e ognuno costerebbe un `<Text>` in più al
+ *  render. */
+function coalesce(spans) {
+    const out = [];
+    for (const s of spans) {
+        const last = out[out.length - 1];
+        if (last && last.kind === s.kind && last.end === s.start)
+            last.end = s.end;
+        else
+            out.push({ ...s });
+    }
+    return out;
+}
+/**
+ * Taglia una riga wrappata nei pezzi da colorare, intersecando gli offset.
+ *
+ * Gemello di `sliceLine` (`text-search.ts`), che fa lo stesso lavoro con un
+ * intervallo booleano invece che tipizzato: la riga è una fetta CONTIGUA del
+ * testo reso, quindi uno span a cavallo dell'a-capo si colora su entrambe le
+ * righe senza nessun caso speciale — entrambe lo intersecano.
+ *
+ * Restituisce sempre la copertura completa della riga, buchi inclusi come
+ * segmenti `kind: null`: chi renderizza concatena e basta, senza dover
+ * ricostruire ciò che è rimasto fuori.
+ */
+export function sliceSpans(line, spans) {
+    const out = [];
+    const { text, start } = line;
+    let pos = 0;
+    for (const s of spans) {
+        if (s.end <= start)
+            continue;
+        if (s.start >= start + text.length)
+            break; // `spans` è ordinato: il resto è oltre
+        const a = Math.max(0, Math.min(text.length, s.start - start));
+        const b = Math.max(0, Math.min(text.length, s.end - start));
+        if (b <= a || a < pos)
+            continue;
+        if (a > pos)
+            out.push({ text: text.slice(pos, a), kind: null });
+        out.push({ text: text.slice(a, b), kind: s.kind });
+        pos = b;
+    }
+    if (pos < text.length)
+        out.push({ text: text.slice(pos), kind: null });
+    return out;
+}

package/dist/pane-views.js

@@ -0,0 +1,135 @@
+// 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 ←/→.
+//
+// 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
+// due gruppi — qui c'è solo la mappa di quali sottoinsiemi esistono, come si
+// chiamano e con che numero.
+//
+// Invarianti (decisioni congelate al create-task e al preflight):
+//  - D1 create — catalogo FISSO: le voci ci sono tutte anche a contatore 0. Un
+//    catalogo che si accorcia quando un numero va a zero sposta le voci sotto le
+//    dita e può far svanire la vista corrente mentre la guardi (togliere un
+//    filtro mentre sei su `nascoste`).
+//  - D1 preflight — navigazione CICLICA, come `DETAIL_ACTIONS` e le righe di
+//    scelta del modale edit.
+//  - Il numero di una voce si misura SEMPRE sulla vista di default, mai su
+//    quella attiva: altrimenti navigare cambierebbe i contatori che si sta
+//    navigando, e il catalogo tornerebbe dinamico per la via di dietro.
+//  - `↑N`/`↓N` non stanno qui: contano elementi fuori finestra per altezza del
+//    terminale, cioè una POSIZIONE, non un insieme.
+import { isVisible, compareTasks } from './view.js';
+export const TASK_VIEWS = [
+    {
+        id: 'tasks',
+        label: (c) => `Tasks (${c.hidden > 0 ? `${c.filtered}/${c.total}` : c.filtered})`,
+        count: (c) => c.filtered,
+        has: (t, ctx) => isVisible(t, ctx.view),
+        empty: 'nessuna task in vista: i filtri le escludono tutte',
+    },
+    {
+        // `yellow` come prima: avverte che la vista è distorta da un filtro.
+        id: 'hidden',
+        label: (c) => `${c.hidden} nascoste`,
+        count: (c) => c.hidden,
+        has: (t, ctx) => !isVisible(t, ctx.view),
+        color: 'yellow',
+        empty: 'nessuna task nascosta: nessun filtro ne esclude',
+    },
+    {
+        // T61 — dim: le Done oltre soglia non alterano ciò che stai guardando.
+        id: 'archivable',
+        label: (c) => `${c.archivable} archiviabili`,
+        count: (c) => c.archivable,
+        has: (t, ctx) => ctx.archivable.has(t.id),
+        dim: true,
+        empty: "nessuna Done oltre la soglia d'età",
+    },
+];
+/**
+ * Le task della vista `id`, filtrate col predicato e ordinate con la chain
+ * corrente. L'ordinamento vale per ogni vista, non solo la principale: una lista
+ * di task ordinata in un modo e l'altra in un altro sarebbe un secondo asse che
+ * si muove da solo.
+ */
+export function selectTasks(tasks, id, ctx) {
+    const entry = taskView(id);
+    const picked = tasks.filter((t) => entry.has(t, ctx));
+    picked.sort((a, b) => compareTasks(a, b, ctx.view.sort));
+    return picked;
+}
+/** Glifo della sessione viva, gemello di `LIVE_IDLE` del render. Duplicato qui
+ *  perché il catalogo è puro e non può importare da `cli.tsx`; è un carattere
+ *  concorde (largo 1 per entrambe le contabilità), quindi non passa da
+ *  `sanitize`. */
+const LIVE_GLYPH = '●';
+/** Righe selezionabili della lista assemblata (il separatore non è una riga di
+ *  contenuto: fuori dalla vista di default i due gruppi non ci sono più). */
+function selectable(rows) {
+    return rows.filter((r) => r.kind !== 'separator');
+}
+export const SESSION_VIEWS = [
+    {
+        id: 'context',
+        label: (c, parent) => `${parent} (${c.total})`,
+        count: (c) => c.total,
+        rows: (ctx) => ctx.assembled.rows,
+        empty: null,
+    },
+    {
+        id: 'live',
+        label: (c) => `${LIVE_GLYPH}${c.live} vive`,
+        count: (c) => c.live,
+        rows: (ctx) => selectable(ctx.assembled.rows).filter((r) => ctx.isLive(r.sessionId)),
+        color: 'green',
+        empty: 'nessuna conversazione viva in questa lista',
+    },
+    {
+        id: 'pinned',
+        label: (c) => `📌${c.pinned}`,
+        count: (c) => c.pinned,
+        rows: (ctx) => ctx.assembled.rows.filter((r) => r.kind === 'pinned'),
+        color: 'yellow',
+        empty: 'nessuna conversazione pinnata',
+    },
+    {
+        // D4 preflight — la coda troncata, non la lista intera senza cap: il numero
+        // dell'header e il numero di righe devono coincidere.
+        id: 'older',
+        label: (c) => `+${c.older} più vecchie`,
+        count: (c) => c.older,
+        rows: (ctx) => ctx.assembled.contextOverflow.map((s) => ({
+            kind: 'context',
+            sessionId: s.sessionId,
+            session: s,
+        })),
+        dim: true,
+        empty: 'nessuna conversazione oltre il cap',
+    },
+];
+export function selectSessionRows(id, ctx) {
+    return sessionView(id).rows(ctx);
+}
+// ── lookup e navigazione ───────────────────────────────────────────────────
+export function taskView(id) {
+    return TASK_VIEWS.find((v) => v.id === id) ?? TASK_VIEWS[0];
+}
+export function sessionView(id) {
+    return SESSION_VIEWS.find((v) => v.id === id) ?? SESSION_VIEWS[0];
+}
+/** Scorrimento ciclico del catalogo: `→` sull'ultima voce torna alla prima. Id
+ *  ignoto → prima voce, mai un indice negativo. */
+function cycle(catalog, current, delta) {
+    const at = catalog.findIndex((v) => v.id === current);
+    if (at < 0)
+        return catalog[0];
+    return catalog[(at + delta + catalog.length) % catalog.length];
+}
+export function cycleTaskView(current, delta) {
+    return cycle(TASK_VIEWS, current, delta).id;
+}
+export function cycleSessionView(current, delta) {
+    return cycle(SESSION_VIEWS, current, delta).id;
+}

package/dist/session-list.js

@@ -134,7 +134,9 @@ export function assembleSessionList(childSessions, allSessions, pinned, maxConte
     });
     const pinnedSet = new Set(pinnedIds);
     const dedupedContext = childSessions.filter((s) => !pinnedSet.has(s.sessionId));
-    const shownContext = dedupedContext.slice(0, Math.max(0, maxContext));
+    const cap = Math.max(0, maxContext);
+    const shownContext = dedupedContext.slice(0, cap);
+    const overflowContext = dedupedContext.slice(cap);
     const contextRows = shownContext.map((s) => ({
         kind: 'context',
         sessionId: s.sessionId,
@@ -150,7 +152,8 @@ export function assembleSessionList(childSessions, allSessions, pinned, maxConte
         rows,
         pinnedCount: pinnedRows.length,
         contextTotal: dedupedContext.length,
-        contextHidden: dedupedContext.length - shownContext.length,
+        contextHidden: overflowContext.length,
+        contextOverflow: overflowContext,
     };
 }
 function isSelectable(r) {

package/dist/width.js

@@ -224,8 +224,16 @@ export function cut(s, cols) {
  * portano glifi larghi 2 (`📌` nelle sessioni, i glifi di priorità nei filtri
  * delle task), cioè la condizione esatta in cui `cli-truncate` restituisce una
  * riga più larga del budget e il bordo del pane sparisce.
+ *
+ * T100/D6 — `priority` è l'indice del pezzo che il budget serve PER PRIMO,
+ * quando la riga porta un segmento su cui si sta agendo (la vista attiva di un
+ * header-selettore). Gli altri si mostrano solo se avanza spazio, e cadono dalla
+ * coda come prima. L'ORDINE DI RESA non cambia — cambia chi paga il taglio: su
+ * un terminale stretto sparisce un contatore, mai la voce che dice dove sei.
+ * Riservare non allarga la riga: resta un tetto, e con `priority` da solo più
+ * largo del budget è lui a essere tagliato.
  */
-export function cutParts(parts, cols) {
+export function cutParts(parts, cols, priority = -1) {
     const empty = parts.map(() => '');
     if (cols <= 0)
         return empty;
@@ -234,10 +242,45 @@ export function cutParts(parts, cols) {
     const out = [...empty];
     const budget = cols - 1; // -1 = la colonna dell'ellissi, che qui c'è di sicuro
     let w = 0;
-    let full = false;
-    for (let i = 0; i < parts.length && !full; i++) {
+    const hasPriority = priority >= 0 && priority < parts.length;
+    if (hasPriority) {
+        // Il prioritario prende il suo spazio per primo, e se non ci sta intero è
+        // lui a essere tagliato: dev'esserci comunque, anche monco.
         let acc = '';
-        for (const ch of parts[i]) {
+        for (const ch of parts[priority]) {
+            const cw = termWidth(ch);
+            if (w + cw > budget)
+                break;
+            acc += ch;
+            w += cw;
+        }
+        out[priority] = acc;
+    }
+    for (let i = 0; i < parts.length; i++) {
+        if (hasPriority && i === priority)
+            continue;
+        const part = parts[i];
+        const pw = termWidth(part);
+        if (hasPriority) {
+            // Col prioritario già servito il taglio a metà di un altro segmento
+            // lascerebbe a schermo un moncone seguito da una voce intera, che si legge
+            // come due cose slegate invece che come una riga troncata: qui un pezzo o
+            // entra tutto o cede il posto.
+            //
+            // E chi cede si porta dietro tutti quelli dopo di lui, invece di lasciare
+            // passare il primo più corto: l'ordine dell'array È l'ordine di
+            // importanza (le voci navigabili prima dei contatori di scroll), e un
+            // riempimento a buchi lo scavalcherebbe — l'header mostrerebbe `↓46`
+            // avendo buttato la voce che si può selezionare.
+            if (w + pw > budget)
+                break;
+            out[i] = part;
+            w += pw;
+            continue;
+        }
+        let acc = '';
+        let full = false;
+        for (const ch of part) {
             const cw = termWidth(ch);
             if (w + cw > budget) {
                 full = true;
@@ -247,7 +290,15 @@ export function cutParts(parts, cols) {
             w += cw;
         }
         out[i] = acc;
+        if (full)
+            break;
     }
+    // Col prioritario servito per primo il primo pezzo a schermo può non essere il
+    // pezzo 0, e i segmenti portano il proprio separatore in testa: senza questa
+    // potatura la riga aprirebbe con un ` · ` appeso al nulla.
+    const first = out.findIndex((p) => p !== '');
+    if (first > 0)
+        out[first] = out[first].replace(/^[\s·]+/, '');
     // L'ellissi va sull'ultimo pezzo che ha davvero del testo: appiccicarla a un
     // pezzo vuoto la staccherebbe dal punto di taglio, e il lettore la leggerebbe
     // come un segmento a sé.

package/package.json

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