@vascend/talos 0.1.0

package/dist/tools/team-tools.js

@@ -0,0 +1,348 @@
+import { readTeamHandoff } from "../vascend/team-handoff.js";
+import { resolveKingdomBus } from "../vascend/kingdom-channel.js";
+import { MemoryStore } from "../vascend/memory-store.js";
+import { pendingMembers, teamById, teamByKingdom, teamForSession } from "../vascend/team-session.js";
+import { memberSlug, parseTeamMembers } from "./team-input.js";
+import { kingdomLive } from "../vascend/kingdom-live.js";
+// La squadra come si lavora davvero: la si ingaggia, le si parla, si aspetta
+// solo quando non c'e' altro da fare.
+//
+// Prima ingaggiare voleva dire sparire dentro una tool call finche' l'ultimo
+// non aveva finito. Qui l'ingaggio TORNA SUBITO e il turno prosegue: chi ha
+// ingaggiato puo' assegnare parlando, correggere a meta' strada, rispondere a
+// una domanda. E' la differenza fra dare un compito e lavorare insieme.
+const WAIT_DEFAULT_S = 30;
+const WAIT_MAX_S = 60;
+const engagements = new Set();
+// Chi parla. In una sessione delegata e' lo slug del collaboratore; altrimenti
+// e' l'agente principale, che ora ha una voce sul canale come tutti gli altri:
+// senza, "assegnare il compito parlando" non era esprimibile.
+function speaker(ctx) {
+    return String(ctx.kingdom?.self || "orchestratore");
+}
+// Il canale su cui parla questa sessione: quello della squadra di cui fa parte,
+// oppure quello della squadra che ha ingaggiato.
+function channelId(ctx) {
+    if (ctx.kingdom?.id)
+        return ctx.kingdom.id;
+    const team = teamForSession(String(ctx.sessionId || ""));
+    return team ? team.id : "";
+}
+function noTeam() {
+    return "nessuna squadra al lavoro: ingaggiala con team_engage";
+}
+function bus(ctx) {
+    return resolveKingdomBus(process.env, ctx.sessionDir);
+}
+function fmt(m) {
+    return `${m.from} -> ${m.to ?? "tutti"}: ${m.text}`;
+}
+function text(input, key) {
+    const value = input[key];
+    return typeof value === "string" ? value.trim() : "";
+}
+async function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal.aborted) {
+            reject(new Error("interrotto"));
+            return;
+        }
+        const cleanup = () => { clearTimeout(timer); signal.removeEventListener("abort", onAbort); };
+        const onAbort = () => { cleanup(); reject(new Error("interrotto")); };
+        const timer = setTimeout(() => { cleanup(); resolve(); }, ms);
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+}
+function currentTeam(ctx) {
+    return ctx.kingdom?.id ? teamByKingdom(ctx.kingdom.id) : teamForSession(String(ctx.sessionId || ""));
+}
+function addressKey(value) {
+    return value.split("/").map(memberSlug).join("/");
+}
+function teamAddress(value, ctx) {
+    const members = [...new Set(["orchestratore", ...(currentTeam(ctx)?.members.map((member) => member.slug) ?? []),
+            ...(ctx.kingdom?.peers ?? []), ...kingdomLive.slugs(channelId(ctx))])];
+    const key = addressKey(value);
+    const parent = speaker(ctx).split("/").slice(0, -1).join("/");
+    const address = members.find((member) => addressKey(member) === key)
+        ?? (parent ? members.find((member) => addressKey(member) === addressKey(`${parent}/${value}`)) : undefined);
+    return { address: address ?? key, known: Boolean(address), members };
+}
+export const teamEngageTool = {
+    name: "team_engage",
+    description: "Ingaggia collaboratori quando l'utente richiede lavoro di team o delega. Assegna un mandate completo "
+        + "con risultato atteso e verifica, oppure group/tasks del piano esistente. Gli incarichi indipendenti "
+        + "partono in parallelo entro il limite; after attende il successo dei prerequisiti e ne riceve i risultati. "
+        + "Dichiara area con percorsi concreti: senza worktree le aree sovrapposte o mancanti si eseguono in sequenza. "
+        + "Le aree coordinano il lavoro, non sono una sandbox. Torna subito sull'host asincrono. "
+        + "Coordina con team_say/team_inbox, lavora su attivita' indipendenti e raccogli stato e risultati con "
+        + "team_report prima della consegna. Non duplicare una squadra ancora attiva.",
+    schema: {
+        type: "object",
+        properties: {
+            members: {
+                type: "array",
+                minItems: 1,
+                maxItems: 32,
+                description: "i collaboratori da ingaggiare",
+                items: {
+                    type: "object",
+                    properties: {
+                        slug: { type: "string", description: "nome breve, es. recon-frontend" },
+                        role: { type: "string", description: "di cosa si occupa" },
+                        mandate: { type: "string", description: "compito completo con risultato atteso e verifica; opzionale con group" },
+                        group: { type: "string", description: "gruppo del piano esistente assegnato al collaboratore" },
+                        tasks: { type: "array", items: { type: "string" }, description: "attivita del gruppo (T01 o bit); default tutte le aperte" },
+                        area: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "percorsi di competenza (es. src/api), senza glob. Aree disgiunte consentono concorrenza nella cartella condivisa",
+                        },
+                        after: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "slug dei prerequisiti nello stesso ingaggio; parte solo dopo il loro successo. Ometti per lavori indipendenti",
+                        },
+                        model: { type: "string", description: "modello dedicato; ometti per ereditare" },
+                        effort: { type: "string", enum: ["low", "medium", "high", "max"] },
+                        parent: { type: "string", description: "a chi risponde (default: chi ingaggia)" },
+                        instructions: { type: "string", description: "istruzioni aggiuntive in Markdown" },
+                        tools: {
+                            type: "object",
+                            description: "cosa puo' e non puo' usare",
+                            properties: {
+                                allow: { type: "array", items: { type: "string" } },
+                                deny: { type: "array", items: { type: "string" } },
+                            },
+                        },
+                    },
+                    required: ["slug"],
+                },
+            },
+            why: { type: "string", description: "perche' ti serve una mano: lo legge l'utente" },
+        },
+        required: ["members"],
+    },
+    handler: async (input, ctx) => {
+        if (!ctx.spawnKingdom)
+            return "non posso ingaggiare collaboratori in questo contesto";
+        let members;
+        try {
+            members = parseTeamMembers(input["members"], ctx);
+        }
+        catch (error) {
+            return { output: `errore: ${error.message}`, isError: true };
+        }
+        const session = String(ctx.sessionId ?? "");
+        const active = teamForSession(session);
+        if (engagements.has(session) || (active && !active.done)) {
+            return { output: "team gia' in avvio o al lavoro: usa team_report e team_say per coordinarlo", isError: true };
+        }
+        /* Ingaggiare costa: sono agenti veri che girano. Passa dal cancello dei
+           permessi come ogni altra azione che consuma, e la modalita' dell'host
+           decide se chiedere davvero o lasciar correre. */
+        engagements.add(session);
+        try {
+            const dettaglio = `${members.length} collaborator${members.length === 1 ? "e" : "i"}: `
+                + members.map((m) => m.slug).join(", ") + (text(input, "why") ? `; ${text(input, "why")}` : "");
+            const ok = await ctx.confirm("team_engage", dettaglio);
+            if (!ok)
+                return "Ingaggio rifiutato dall'utente";
+            if (ctx.signal.aborted)
+                return "ingaggio interrotto";
+            const result = await ctx.spawnKingdom(members, { detach: true });
+            for (const name of ["team_say", "team_inbox", "team_wait", "team_report", "vascend_status"])
+                ctx.tools?.promote?.(name);
+            return result;
+        }
+        finally {
+            engagements.delete(session);
+        }
+    },
+};
+export const teamSayTool = {
+    name: "team_say",
+    description: "Parla con la squadra mentre lavora: assegna un compito, precisa cosa serve, correggi una direzione "
+        + "sbagliata prima che diventi lavoro buttato. `to` = nome di un collaboratore, oppure ometti per "
+        + "dirlo a tutti. Vale anche fra collaboratori: annuncia cosa hai finito e cosa sblocca, o chiedi "
+        + "un prerequisito.",
+    schema: {
+        type: "object",
+        properties: {
+            to: { type: "string", description: "destinatario; ometti per tutti" },
+            text: { type: "string", description: "il messaggio" },
+        },
+        required: ["text"],
+    },
+    handler: async (input, ctx) => {
+        const id = channelId(ctx);
+        if (!id)
+            return noTeam();
+        const messaggio = text(input, "text");
+        if (!messaggio)
+            return "errore: messaggio vuoto";
+        const recipient = text(input, "to");
+        const routed = teamAddress(recipient, ctx);
+        const to = recipient ? routed.address : null;
+        if (to && !routed.known && (currentTeam(ctx) || ctx.kingdom?.peers?.length)) {
+            return { output: `destinatario sconosciuto: ${to}; membri: ${routed.members.join(", ")}`, isError: true };
+        }
+        const m = bus(ctx).post(id, speaker(ctx), to, messaggio, Date.now());
+        /* Quello che la squadra si dice entra anche in MEMORIA. Su un lavoro lungo
+           la decisione presa parlando vale quanto quella scritta in un file, e fra
+           due settimane la si ritrova solo se recall puo' pescarla. Best-effort: il
+           canale resta la fonte immediata, la persistenza non deve costare il turno. */
+        if (ctx.sessionDir) {
+            try {
+                MemoryStore.open(ctx.sessionDir, ctx.roomStoreId ?? id).append({
+                    type: "team.message",
+                    domain: "kingdom",
+                    subject: `${m.from}->${m.to ?? "tutti"}`,
+                    summary: messaggio,
+                    body: fmt(m),
+                    terms: [m.from, m.to ?? "tutti", ...messaggio.split(/\s+/)],
+                    links: [
+                        { rel: "from", target: m.from, domain: "kingdom" },
+                        ...(m.to ? [{ rel: "to", target: m.to, domain: "kingdom" }] : []),
+                    ],
+                    payload: { message: m },
+                    createdAt: m.ts,
+                });
+            }
+            catch {
+                // Senza memoria il messaggio e' comunque arrivato a destinazione.
+            }
+        }
+        return `detto ${fmt(m)}`;
+    },
+};
+export const teamInboxTool = {
+    name: "team_inbox",
+    description: "Leggi cosa ti hanno detto: risposte, domande, annunci di cio' che e' pronto. Non blocca. "
+        + "Controllalo prima di dare per fatto qualcosa che stava facendo un altro.",
+    schema: { type: "object", properties: {} },
+    handler: async (_input, ctx) => {
+        const id = channelId(ctx);
+        if (!id)
+            return noTeam();
+        const msgs = bus(ctx).inbox(id, speaker(ctx));
+        if (!msgs.length)
+            return "niente di nuovo";
+        return msgs.map(fmt).join("\n");
+    },
+};
+export const teamWaitTool = {
+    name: "team_wait",
+    description: "Aspetta che arrivi un messaggio, o che la squadra finisca. Usalo SOLO se non hai altro di utile da "
+        + "fare: se puoi andare avanti su un altro pezzo, vai avanti. Filtra per `from` e/o `contains`. "
+        + "Scade dopo `timeout_s` e torna dicendo cosa sta ancora girando.",
+    schema: {
+        type: "object",
+        properties: {
+            from: { type: "string", description: "aspetta solo da questo collaboratore" },
+            contains: { type: "string", description: "aspetta un messaggio che contiene questo testo" },
+            timeout_s: { type: "number", description: `secondi di attesa (default ${WAIT_DEFAULT_S}, max ${WAIT_MAX_S})` },
+        },
+    },
+    handler: async (input, ctx) => {
+        const id = channelId(ctx);
+        if (!id)
+            return noTeam();
+        const me = speaker(ctx);
+        const from = addressKey(teamAddress(text(input, "from"), ctx).address);
+        const contains = text(input, "contains").toLowerCase();
+        const richiesti = Number(input["timeout_s"]);
+        const secondi = Number.isFinite(richiesti) ? Math.min(WAIT_MAX_S, Math.max(1, richiesti)) : WAIT_DEFAULT_S;
+        const scadenza = Date.now() + secondi * 1000;
+        const combacia = (m) => (!from || addressKey(m.from) === from) && (!contains || m.text.toLowerCase().includes(contains));
+        const canale = bus(ctx);
+        for (;;) {
+            if (ctx.signal.aborted)
+                return "attesa interrotta";
+            const msgs = canale.inbox(id, me, combacia);
+            if (msgs.length)
+                return `arrivato:\n${msgs.map(fmt).join("\n")}`;
+            const team = currentTeam(ctx);
+            if (team && team.done)
+                return `${team.failed ? "squadra terminata con errori" : "la squadra ha finito"}.\n${team.report}`;
+            if (Date.now() >= scadenza) {
+                const ancora = team ? pendingMembers(team) : [];
+                return `nessuna risposta entro ${secondi}s`
+                    + (ancora.length ? `: stanno ancora lavorando ${ancora.join(", ")}` : "")
+                    + ". Vai avanti con quello che puoi.";
+            }
+            try {
+                await sleep(Math.min(250, Math.max(1, scadenza - Date.now())), ctx.signal);
+            }
+            catch {
+                return "attesa interrotta";
+            }
+        }
+    },
+};
+function reportResult(output, team, live = true) {
+    const references = team.members.flatMap((member) => (member.artifacts ?? []).slice(-6).map((ref) => `[${member.slug}] output_page id="${ref.id}" scope="${ref.scope}" (${ref.name}, ${ref.chars} char)`));
+    return {
+        output: output + (references.length ? "\nArtefatti recuperabili:\n" + references.join("\n") : "")
+            + ("persistenceError" in team && team.persistenceError ? "\nCheckpoint non salvato: " + team.persistenceError : ""),
+        structuredContent: { team_id: team.id, revision: team.revision ?? 0, runtime: live ? "live" : "offline",
+            done: team.done, failed: team.failed, members: team.members,
+            ...("persistenceError" in team && team.persistenceError ? { persistenceError: team.persistenceError } : {}) },
+    };
+}
+export const teamReportTool = {
+    name: "team_report",
+    description: "Raccogli stato, task e risultati della squadra, con revisione e artefatti recuperabili via output_page. "
+        + "Il checkpoint sopravvive al riavvio. wait=true attende fino a timeout_s; altrimenti torna subito.",
+    schema: {
+        type: "object",
+        properties: {
+            team_id: { type: "string", description: "squadra di questa sessione da recuperare; default: la piu' recente" },
+            wait: { type: "boolean", description: "true: aspetta che finiscano (fino a timeout_s)" },
+            timeout_s: { type: "number", description: `secondi massimi di attesa (default ${WAIT_DEFAULT_S}, max ${WAIT_MAX_S})` },
+        },
+    },
+    handler: async (input, ctx) => {
+        const requested = typeof input["team_id"] === "string" ? input["team_id"].trim() : "";
+        const team = requested ? teamById(ctx.sessionId ?? "", requested) : currentTeam(ctx);
+        if (!team) {
+            const saved = ctx.sessionDir && ctx.sessionId ? readTeamHandoff(ctx.sessionDir, ctx.sessionId, requested || undefined) : null;
+            return saved ? reportResult(`Checkpoint squadra ${saved.id}, revisione ${saved.revision}. `
+                + (saved.done ? "Lavoro terminato.\n" : "Runtime non attivo: gli incarichi incompleti vanno ripresi.\n")
+                + (saved.failed ? "Sono presenti incarichi falliti.\n" : "")
+                + (saved.report || saved.members.map((member) => `[${member.slug}] ${member.status}: ${member.summary ?? member.error ?? ""}`).join("\n")), saved, false) : noTeam();
+        }
+        const finished = (current) => reportResult(`${current.failed ? "squadra terminata con errori:\n" : ""}${current.report || "la squadra ha finito"}`, current);
+        if (team.done)
+            return finished(team);
+        const progress = team.members.map((member) => `[${member.slug}] ${member.status ?? "queued"}`
+            + (member.error ? `: ${member.error}` : member.summary ? `: ${member.summary.slice(0, 600)}` : "")).join("\n");
+        if (input["wait"] !== true)
+            return reportResult(`stanno ancora lavorando: ${pendingMembers(team).join(", ")}.`
+                + `\n${progress}\nContinua con quello che puoi, oppure chiama team_report con wait=true.`, team);
+        const richiesti = Number(input["timeout_s"]);
+        const secondi = Number.isFinite(richiesti) ? Math.min(WAIT_MAX_S, Math.max(1, richiesti)) : WAIT_DEFAULT_S;
+        const deadline = Date.now() + secondi * 1000;
+        while (Date.now() < deadline) {
+            if (ctx.signal.aborted)
+                return reportResult("attesa interrotta; il lavoro del team non viene cancellato", currentTeam(ctx) ?? team);
+            const current = requested ? teamById(ctx.sessionId ?? "", requested) : currentTeam(ctx);
+            if (current?.done)
+                return finished(current);
+            try {
+                await sleep(Math.min(250, Math.max(1, deadline - Date.now())), ctx.signal);
+            }
+            catch {
+                return reportResult("attesa interrotta; il lavoro del team non viene cancellato", currentTeam(ctx) ?? team);
+            }
+        }
+        return reportResult(`non hanno ancora finito dopo ${secondi}s: ${pendingMembers(currentTeam(ctx) ?? team).join(", ")}. Richiama team_report piu' tardi.`, currentTeam(ctx) ?? team);
+    },
+};
+export const teamTools = [
+    teamEngageTool,
+    teamSayTool,
+    teamInboxTool,
+    teamWaitTool,
+    teamReportTool,
+];

package/dist/tools/workspace-sessions.d.ts

@@ -0,0 +1,2 @@
+import type { Tool } from "../core/types.js";
+export declare const workspaceSessionsTool: Tool;

package/dist/tools/workspace-sessions.js

@@ -0,0 +1,35 @@
+export const workspaceSessionsTool = {
+    name: "workspace_sessions",
+    description: "Rileva altre sessioni Talos attive nella stessa cartella e invia messaggi di coordinamento. "
+        + "I messaggi ricevuti entrano automaticamente al prossimo confine sicuro del turno; le sessioni inattive li leggono al prossimo turno.",
+    schema: {
+        type: "object",
+        properties: {
+            action: { type: "string", enum: ["list", "send"], description: "default list" },
+            to: { type: "string", description: "id esatto del destinatario restituito da list" },
+            message: { type: "string", description: "messaggio conciso; massimo 6000 byte" },
+        },
+    },
+    handler: async (input, ctx) => {
+        if (ctx.signal.aborted)
+            return { output: "chiamata annullata", isError: true };
+        const channel = ctx.workspaceSession;
+        if (!channel)
+            return { output: "coordinamento tra sessioni non attivo in questo host", isError: true };
+        const action = input["action"] ?? "list";
+        if (action === "list")
+            return JSON.stringify({ self: channel.id, peers: channel.peers() });
+        if (action !== "send")
+            return { output: "action deve essere list oppure send", isError: true };
+        if (typeof input["to"] !== "string" || typeof input["message"] !== "string") {
+            return { output: "send richiede to e message come stringhe", isError: true };
+        }
+        try {
+            const message = channel.send(input["to"], input["message"]);
+            return JSON.stringify({ id: message.id, to: message.to, status: "queued" });
+        }
+        catch (error) {
+            return { output: error.message, isError: true };
+        }
+    },
+};

package/dist/tui/account-entry.d.ts

@@ -0,0 +1 @@
+export declare function enterAccount(env: NodeJS.ProcessEnv): Promise<string>;

package/dist/tui/account-entry.js

@@ -0,0 +1,93 @@
+import * as readline from "node:readline";
+import { stdin, stdout } from "node:process";
+import { openUrl } from "../providers/open-browser.js";
+import { tr } from "./i18n.js";
+import { initializeLanguage, onboardingLanguage } from "./language-preference.js";
+import { leggiOnboarding, salvaOnboarding, serveTermini, TESTI, consensoAffermativo, TERMINI_VERSIONE, LINK_TERMINI, LINK_PRIVACY } from "./onboarding.js";
+import { decisioneCancello, tokenVascend, statoSessione, valutaLicenzaLocale, rimuoviTokenVascend, salvaTokenVascend, rinnovaProvaOffline } from "./vascend-login.js";
+import { startWebLogin, waitForWebLogin, WebLoginError } from "./web-login.js";
+export async function enterAccount(env) {
+    const language = initializeLanguage(env);
+    const state = onboardingLanguage(leggiOnboarding(env), env);
+    // Host/test flags only control this local UI. Server authorization always
+    // requires a verified session and current account permissions.
+    if (env["TALOS_NO_LOGIN"] === "1")
+        return "";
+    const saved = tokenVascend(env);
+    const session = saved ? await statoSessione(env, saved) : null;
+    if (!stdin.isTTY || !stdout.isTTY || env["TALOS_HOST_PROFILE"]?.toLowerCase() === "horizon")
+        return "";
+    const offline = session?.stato === "irraggiungibile" ? valutaLicenzaLocale(env) : null;
+    const decision = decisioneCancello(saved, session, offline);
+    let tier = decision.tier;
+    let token = saved;
+    const note = () => tr("Account connesso", "Account connected") +
+        (tier ? ` · ${tr("Piano", "Plan")} ${tier}` : "");
+    if (decision.azione === "prosegui" && !serveTermini(state)) {
+        if (session?.stato === "valida" && token)
+            void rinnovaProvaOffline(env, token).catch(() => { });
+        return offline?.ok ? tr("Account offline · prova firmata valida", "Offline account · signed proof valid") : note();
+    }
+    const abort = new AbortController();
+    const rl = readline.createInterface({ input: stdin, output: stdout });
+    const cancel = () => abort.abort();
+    rl.on("SIGINT", cancel);
+    const write = (text) => { stdout.write(`  ${text}\n`); };
+    try {
+        if (decision.azione === "login") {
+            if (saved)
+                rimuoviTokenVascend(env);
+            write(tr("Accesso a Vascend Talos", "Sign in to Vascend Talos"));
+            write(tr("Accedi sul sito e conferma il collegamento a Talos.", "Sign in on the website and approve the connection to Talos."));
+            const grant = await startWebLogin(env, language, {}, abort.signal);
+            write(grant.url);
+            write(`${tr("Codice", "Code")}: ${grant.userCode.slice(0, 5)}-${grant.userCode.slice(5)}`);
+            write(tr("Confronta il codice sul sito. In attesa della conferma · Ctrl+C annulla", "Compare the code on the website. Waiting for approval · Ctrl+C cancel"));
+            await openUrl(grant.url, { print: () => { } });
+            const account = await waitForWebLogin(env, grant, {}, abort.signal);
+            if (!salvaTokenVascend(env, account.token))
+                throw new Error(TESTI[language].tokenNonSalvabile);
+            token = account.token;
+            tier = account.tier;
+            write(TESTI[language].benvenuto(account.email));
+            await rinnovaProvaOffline(env, token).catch(() => { });
+        }
+        if (serveTermini(state)) {
+            const t = TESTI[language];
+            write(t.terminiTitolo);
+            write(t.terminiCorpo);
+            write(`${t.terminiEtichetta}: ${LINK_TERMINI}`);
+            write(`${t.privacyEtichetta}: ${LINK_PRIVACY}`);
+            const answer = await new Promise((resolve, reject) => {
+                const onAbort = () => reject(new WebLoginError("cancelled"));
+                if (abort.signal.aborted) {
+                    onAbort();
+                    return;
+                }
+                abort.signal.addEventListener("abort", onAbort, { once: true });
+                rl.question(`  ${t.terminiDomanda} `, answer => {
+                    abort.signal.removeEventListener("abort", onAbort);
+                    resolve(answer);
+                });
+            });
+            if (!consensoAffermativo(answer, language))
+                throw new Error(t.terminiRifiutati);
+            salvaOnboarding(env, { ...state, lingua: language, terminiVersione: TERMINI_VERSIONE, terminiQuando: new Date().toISOString() });
+        }
+        return note();
+    }
+    catch (e) {
+        if (e instanceof WebLoginError) {
+            const messages = {
+                cancelled: tr("Accesso annullato.", "Sign-in cancelled."),
+                expired_token: tr("Link scaduto. Riavvia Talos per riprovare.", "Link expired. Restart Talos to try again."),
+                access_denied: tr("Collegamento annullato dal sito.", "Connection cancelled on the website."),
+            };
+            throw new Error(messages[e.code] ?? tr("Accesso dal sito non disponibile. Riprova fra poco.", "Website sign-in is unavailable. Please try again shortly."));
+        }
+        throw e;
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/tui/attachment-highlight.d.ts

@@ -0,0 +1 @@
+export declare function createAttachmentHighlighter(source: string, paint: ((text: string) => string) | undefined): (row: string, offset?: number) => string;

package/dist/tui/attachment-highlight.js

@@ -0,0 +1,24 @@
+import { IMAGE_REF, TEXT_REF } from "./attachment-refs.js";
+// Il colore viene applicato solo alla vista: testo, offset del cursore e
+// riferimenti usati per recuperare gli allegati restano identici.
+export function createAttachmentHighlighter(source, paint) {
+    if (!paint)
+        return row => row;
+    const refs = new RegExp(`${IMAGE_REF}|${TEXT_REF}`, "gi");
+    const spans = [...source.matchAll(refs)].map(match => ({ start: match.index, end: match.index + match[0].length }));
+    return (row, offset = 0) => {
+        let cursor = 0;
+        let output = "";
+        for (const span of spans) {
+            const start = Math.max(0, span.start - offset);
+            const end = Math.min(row.length, span.end - offset);
+            if (start >= row.length)
+                break;
+            if (end <= start)
+                continue;
+            output += row.slice(cursor, start) + paint(row.slice(start, end));
+            cursor = end;
+        }
+        return output + row.slice(cursor);
+    };
+}

package/dist/tui/attachment-refs.d.ts

@@ -0,0 +1,2 @@
+export declare const IMAGE_REF: string;
+export declare const TEXT_REF: string;

package/dist/tui/attachment-refs.js

@@ -0,0 +1,3 @@
+// Keep legacy references readable in saved prompts and queued messages.
+export const IMAGE_REF = String.raw `(?:\[(?:image|img)|\bimg)[ \t]*#[ \t]*(\d+)\b\]?`;
+export const TEXT_REF = String.raw `(?:\[(?:text|txt)|\btxt)[ \t]*#[ \t]*(\d+)\b(?:[ \t]*\u00b7[ \t]*\d+[ \t]*(?:caratteri|characters|caracteres|Zeichen))?\]?`;