@vascend/talos 0.1.0

package/dist/tui/review-store.d.ts

@@ -0,0 +1,60 @@
+import type { AgentEvent, Message, ToolCallPart } from "../core/types.js";
+export type ReviewState = "running" | "ok" | "error" | "stopped" | "info";
+export type ReviewKind = "tool" | "file" | "team" | "notice";
+export interface ReviewChange {
+    readonly before?: string;
+    readonly after: string;
+    readonly scope: "file" | "fragment" | "append" | "reported";
+}
+export interface ReviewEntry {
+    readonly id: string;
+    readonly kind: ReviewKind;
+    readonly title: string;
+    readonly tool?: string;
+    readonly target: string;
+    readonly actor: string;
+    readonly state: ReviewState;
+    readonly startedAt?: number;
+    readonly endedAt?: number;
+    readonly input?: Readonly<Record<string, unknown>>;
+    readonly output?: string;
+    readonly change?: ReviewChange;
+    readonly parentId?: string;
+    readonly role?: string;
+    readonly parent?: string;
+}
+export declare function reviewTitle(name: string): string;
+export declare function callTarget(call: ToolCallPart): string;
+export declare class ReviewStore {
+    private readonly capacity;
+    private items;
+    private callIndex;
+    private actorText;
+    private sequence;
+    private run;
+    private _revision;
+    private _evicted;
+    private _running;
+    private _label;
+    private _goal;
+    constructor(capacity?: number);
+    get revision(): number;
+    get evicted(): number;
+    get running(): boolean;
+    get label(): string;
+    get goal(): string;
+    entries(): readonly ReviewEntry[];
+    get(id: string): ReviewEntry | undefined;
+    begin(goal: string): void;
+    finish(interrupted?: boolean): void;
+    reset(history?: readonly Message[]): void;
+    change(callId: string, change: ReviewChange): void;
+    record(event: AgentEvent, at?: number | undefined, actor?: string): void;
+    recordActor(actor: string, event: AgentEvent): void;
+    private recordKingdom;
+    private actorId;
+    private finishActor;
+    private callId;
+    private notice;
+    private put;
+}

package/dist/tui/review-store.js

@@ -0,0 +1,270 @@
+import { oneLine } from "./terminal-text.js";
+const LABELS = {
+    read_file: "Lettura", list_dir: "Cartella", grep: "Ricerca", glob: "Ricerca file",
+    write_file: "Scrittura", edit_file: "Modifica", bash: "Comando", bash_bg: "Comando in background",
+    run_program: "Programma", tool_search: "Ricerca strumenti", tool_invoke: "Strumento",
+    ask_user: "Domanda", vascend_plan: "Lista attività", vascend_mark: "Stato attività",
+    vascend_note: "Nota", vascend_addtasks: "Nuove attività", kingdoms_warm: "Collaboratori",
+    vascend_addrooms: "Nuove attività", vascend_status: "Lista attività",
+    kingdom_send: "Messaggio al team", kingdom_inbox: "Messaggi del team", kingdom_wait: "Attesa collaboratori",
+};
+export function reviewTitle(name) { return LABELS[name] ?? name; }
+export function callTarget(call) {
+    const i = call.input;
+    return oneLine(String(i["path"] ?? i["command"] ?? i["pattern"] ?? i["query"] ??
+        i["task"] ?? i["question"] ?? i["goal"] ?? call.name));
+}
+// Registro della sessione: conserva gli output ricevuti anche quando il log
+// della chat viene compattato. Nessuna lettura del filesystem dal renderer.
+export class ReviewStore {
+    capacity;
+    items = new Map();
+    callIndex = new Map();
+    actorText = new Map();
+    sequence = 0;
+    run = 0;
+    _revision = 0;
+    _evicted = 0;
+    _running = false;
+    _label = "Pronto";
+    _goal = "";
+    constructor(capacity = 2000) {
+        this.capacity = capacity;
+    }
+    get revision() { return this._revision; }
+    get evicted() { return this._evicted; }
+    get running() { return this._running || [...this.items.values()].some(e => e.state === "running"); }
+    get label() { return !this._running && this.running ? "Collaboratori in esecuzione" : this._label; }
+    get goal() { return this._goal; }
+    entries() { return [...this.items.values()]; }
+    get(id) { return this.items.get(id); }
+    begin(goal) {
+        this.run += 1;
+        this._running = true;
+        this._label = "Avvio";
+        this._goal = goal;
+        this._revision += 1;
+    }
+    finish(interrupted = false) {
+        for (const entry of this.items.values()) {
+            if (entry.state === "running" && entry.actor === "Talos")
+                this.put({ ...entry, state: "stopped", endedAt: Date.now() });
+        }
+        this._running = false;
+        this._label = interrupted ? "Interrotto" : "In attesa del prossimo messaggio";
+        this._revision += 1;
+    }
+    reset(history = []) {
+        this.items.clear();
+        this.callIndex.clear();
+        this.actorText.clear();
+        this.sequence = 0;
+        this.run = 0;
+        this._evicted = 0;
+        this._running = false;
+        this._label = "Pronto";
+        this._goal = "";
+        for (const message of history) {
+            if (message.role === "user")
+                this._goal = message.content.filter(p => p.type === "text").map(p => p.text).join("\n");
+            for (const part of message.content) {
+                if (part.type === "tool_call")
+                    this.record({ type: "tool_call", call: part }, undefined);
+                else if (part.type === "tool_result")
+                    this.record({ type: "tool_result", result: part }, undefined);
+            }
+        }
+        // Una sessione ripresa non ha durate affidabili ne' comandi ancora in volo.
+        for (const e of this.items.values()) {
+            this.put({ ...e, startedAt: undefined, endedAt: undefined, state: e.state === "running" ? "stopped" : e.state });
+        }
+        this._revision += 1;
+    }
+    change(callId, change) {
+        const id = this.callIndex.get(`Talos:${callId}`) ?? this.callId(callId);
+        const entry = this.items.get(id);
+        if (entry)
+            this.put({ ...entry, change });
+    }
+    record(event, at = Date.now(), actor = "Talos") {
+        switch (event.type) {
+            case "status":
+                this._label = oneLine(event.label);
+                this._revision += 1;
+                break;
+            case "turn_start":
+                this._label = "Elaborazione";
+                this._revision += 1;
+                break;
+            case "text":
+                if (this._label !== "Risposta in corso") {
+                    this._label = "Risposta in corso";
+                    this._revision += 1;
+                }
+                break;
+            case "tool_call": {
+                const call = event.call;
+                if (actor === "Talos")
+                    this._label = `${reviewTitle(call.name)} · ${callTarget(call)}`;
+                const id = this.callId(call.id, actor);
+                this.callIndex.set(`${actor}:${call.id}`, id);
+                this.put({ id, kind: "tool", title: reviewTitle(call.name), tool: call.name,
+                    target: callTarget(call), actor, state: "running", startedAt: at,
+                    input: call.input, parentId: event.parentId });
+                break;
+            }
+            case "tool_result": {
+                if (actor === "Talos")
+                    this._label = "Elaborazione";
+                const id = this.callIndex.get(`${actor}:${event.result.callId}`) ?? this.callId(event.result.callId, actor);
+                const entry = this.items.get(id);
+                const input = entry?.input;
+                const editing = entry?.tool === "edit_file";
+                const writing = entry?.tool === "write_file";
+                const change = !event.result.isError && input && (editing || writing)
+                    ? { before: editing ? String(input["old_string"] ?? "") : undefined,
+                        after: String(input[editing ? "new_string" : "content"] ?? ""),
+                        scope: editing ? "fragment" : input["append"] === true ? "append" : "reported" }
+                    : undefined;
+                this.put({ ...(entry ?? { id, kind: "tool", title: "Risultato", target: event.result.callId, actor }),
+                    state: event.result.isError ? "error" : "ok", output: event.result.output, endedAt: at,
+                    ...(change ? { change } : {}) });
+                break;
+            }
+            case "error":
+                this.notice("Errore", event.message, "error", at, actor);
+                break;
+            case "compacted":
+                this.notice("Contesto riassunto", `Stima locale: ${event.tokensBefore} → ${event.tokensAfter} token.\n${event.anchors?.join("\n") ?? ""}`, "info", at);
+                break;
+            case "user_message":
+                this.notice("Messaggio preso in carico", event.text, "info", event.at);
+                break;
+            case "workspace_message":
+                this.notice(`Sessione ${event.message.fromLabel}`, event.message.text, "info", at);
+                break;
+            case "kingdom":
+                this.recordKingdom(event, at);
+                break;
+        }
+    }
+    recordActor(actor, event) {
+        if (event.type === "status") {
+            this.put({ id: `status:${this.run}:${actor}`, kind: "notice", actor, title: "Stato",
+                target: oneLine(event.label), output: event.label, state: "info", startedAt: Date.now() });
+            return;
+        }
+        if (event.type === "text") {
+            const text = (this.actorText.get(actor) ?? "") + event.delta;
+            this.actorText.set(actor, text);
+            this.put({ id: `stream:${this.run}:${actor}`, kind: "notice", actor, title: "Risposta in corso",
+                target: "Scrive un aggiornamento", output: text, state: "info", startedAt: Date.now() });
+            return;
+        }
+        if (event.type === "tool_call" || event.type === "done" || event.type === "error") {
+            const text = this.actorText.get(actor);
+            if (text?.trim())
+                this.notice("Aggiornamento", text, "info", Date.now(), actor);
+            this.actorText.delete(actor);
+            this.items.delete(`stream:${this.run}:${actor}`);
+        }
+        if (event.type === "turn_start" || event.type === "done" || event.type === "error") {
+            this.record({ type: "kingdom", phase: "vassal", slug: actor,
+                state: event.type === "turn_start" ? "active" : event.type === "done" ? "done" : "error",
+                ...(event.type === "error" ? { label: event.message } : {}) });
+        }
+        if (event.type === "done" || event.type === "error")
+            this.finishActor(actor);
+        if (event.type !== "turn_start")
+            this.record(event, Date.now(), actor);
+    }
+    recordKingdom(e, at) {
+        if (e.phase === "start") {
+            for (const member of e.castles) {
+                this.put({ id: `team:${this.run}:${member.slug}`, kind: "team", title: member.slug,
+                    actor: member.slug, target: member.goal, role: member.role, parent: member.parent,
+                    state: "info", output: member.after.length ? `In coda · dopo ${member.after.join(", ")}` : "In coda", startedAt: at });
+            }
+        }
+        else if (e.phase === "tool") {
+            const key = `${e.slug}:${e.callId}`;
+            const id = e.state === "start" ? this.callId(e.callId, e.slug) : this.callIndex.get(key) ?? this.callId(e.callId, e.slug);
+            this.callIndex.set(key, id);
+            const prev = this.items.get(id);
+            this.put({ ...prev, id, kind: "tool", title: reviewTitle(e.tool), tool: e.tool, actor: e.slug,
+                target: e.command ?? e.args ?? prev?.target ?? e.tool,
+                state: e.state === "start" ? "running" : e.state === "error" ? "error" : "ok",
+                startedAt: prev?.startedAt ?? e.at, endedAt: e.state === "start" ? undefined : e.at,
+                input: e.command ? { command: e.command } : prev?.input ?? { argomenti: e.args ?? "" },
+                output: e.output ?? prev?.output });
+        }
+        else if (e.phase === "file") {
+            this.put({ id: `file:${++this.sequence}`, kind: "file", title: "Modifica segnalata", target: e.path,
+                actor: e.slug, state: "info", startedAt: at, output: "Modifica segnalata dal collaboratore; i frammenti ricevuti possono essere parziali.",
+                change: e.edit ? { before: e.edit.oldString, after: e.edit.newString ?? e.edit.content ?? "", scope: "reported" } : undefined });
+        }
+        else if (e.phase === "vassal") {
+            const id = this.actorId(e.slug);
+            const prev = this.items.get(id);
+            this.put({ ...prev, id, kind: "team", title: e.slug, actor: e.slug,
+                target: e.goal ?? prev?.target ?? e.label ?? "Collaboratore",
+                role: e.role ?? prev?.role, parent: e.parent ?? prev?.parent,
+                output: e.label ?? prev?.output, startedAt: prev?.startedAt ?? at,
+                state: e.state === "error" ? "error" : e.state === "done" ? "ok" : "running",
+                endedAt: e.state === "done" || e.state === "error" ? at : undefined });
+            if (e.state === "done" || e.state === "error")
+                this.finishActor(e.slug);
+        }
+        else if (e.phase === "end") {
+            for (const report of e.reports) {
+                const id = this.actorId(report.slug);
+                const prev = this.items.get(id);
+                this.put({ ...prev, id, kind: "team", title: report.slug, actor: report.slug,
+                    target: prev?.target ?? report.role ?? "Collaboratore", endedAt: at,
+                    state: report.ok ? "ok" : "error", output: [report.summary, report.error].filter(Boolean).join("\n") });
+                this.finishActor(report.slug);
+            }
+        }
+        else if (e.phase === "say" || e.phase === "note" || e.phase === "notice" || e.phase === "message" || e.phase === "inbox") {
+            const actor = "slug" in e ? e.slug : "from" in e ? e.from : "Talos";
+            this.notice(e.phase === "message" ? `${actor} → ${e.to}` : e.phase === "inbox" ? `Messaggio ${e.state === "read" ? "letto" : "in coda"}` : "Aggiornamento", e.text, "info", at, actor);
+        }
+        else if (e.phase === "task") {
+            const id = `task:${this.run}:${e.slug}:${e.workstreamId}:${e.taskRef}`;
+            this.put({ id, kind: "team", title: e.taskRef, target: e.workstreamId, actor: e.slug,
+                state: e.status === "completed" ? "ok" : e.status === "failed" ? "error" : e.status === "running" ? "running" : "info", startedAt: e.at });
+        }
+        else if (e.phase === "usage") {
+            this.put({ id: `usage:${this.run}:${e.slug}`, kind: "team", title: "Consumi", target: e.slug, actor: e.slug,
+                state: "info", startedAt: e.at, output: `Input: ${e.inputTokens}\nOutput: ${e.outputTokens}\nTotale: ${e.totalTokens}\nTurni: ${e.turns}` +
+                    (e.costUsd === undefined ? "" : `\nCosto USD: ${e.costUsd}`) });
+        }
+    }
+    actorId(actor) {
+        return [...this.items.values()].find(e => e.id.startsWith("team:") && e.actor === actor && e.state === "running")?.id ?? `team:${this.run}:${actor}`;
+    }
+    finishActor(actor) {
+        for (const entry of this.items.values()) {
+            if (entry.actor === actor && entry.state === "running")
+                this.put({ ...entry, state: "stopped", endedAt: Date.now() });
+        }
+    }
+    callId(id, actor = "Talos") { return `call:${this.run}:${actor}:${id}`; }
+    notice(title, output, state, at, actor = "Talos") {
+        this.put({ id: `notice:${++this.sequence}`, kind: "notice", title, target: oneLine(output).slice(0, 200), actor, state, output, startedAt: at });
+    }
+    put(entry) {
+        this.items.set(entry.id, entry);
+        if (this.items.size > this.capacity) {
+            const oldest = [...this.items.values()].find(e => e.state !== "running");
+            if (oldest) {
+                this.items.delete(oldest.id);
+                for (const [key, id] of this.callIndex)
+                    if (id === oldest.id)
+                        this.callIndex.delete(key);
+                this._evicted += 1;
+            }
+        }
+        this._revision += 1;
+    }
+}

package/dist/tui/review-team.d.ts

@@ -0,0 +1,2 @@
+import type { ReviewEntry, ReviewStore } from "./review-store.js";
+export declare function teamEntries(store: ReviewStore): readonly ReviewEntry[];

package/dist/tui/review-team.js

@@ -0,0 +1,27 @@
+// Proiezione del registro: una riga stabile per agente, non una per evento.
+export function teamEntries(store) {
+    const groups = new Map();
+    for (const entry of store.entries()) {
+        if (entry.actor === "Talos")
+            continue;
+        groups.set(entry.actor, [...(groups.get(entry.actor) ?? []), entry]);
+    }
+    return [...groups].map(([actor, entries]) => {
+        const lifecycle = entries.filter(e => e.id.startsWith("team:")).at(-1);
+        const active = entries.filter(e => e.kind === "tool" && e.state === "running");
+        const problems = entries.filter(e => e.state === "error" || e.state === "stopped");
+        const files = new Set(entries.filter(e => e.change || e.kind === "file").map(e => e.target));
+        const latest = [...entries].sort((a, b) => (a.endedAt ?? a.startedAt ?? 0) - (b.endedAt ?? b.startedAt ?? 0)).at(-1);
+        const current = active.map(e => `${e.title}: ${e.target}`).join(" · ");
+        const state = lifecycle?.state ?? (active.length ? "running" : "info");
+        const goal = lifecycle?.target ?? "Incarico non disponibile";
+        const status = entries.find(e => e.id.startsWith("status:"));
+        const waiting = state === "running" && status && /attes|conferm|permess|domand/i.test(status.target)
+            && (status.startedAt ?? 0) >= (latest.endedAt ?? latest.startedAt ?? 0);
+        const activity = (waiting ? status.target : "") || current || (state !== "running" ? lifecycle?.output : "") || `${latest.title}: ${latest.target}`;
+        return { id: `agent:${actor}`, actor, kind: "team", title: actor,
+            state, target: `${actor} · ${state === "running" ? "in corso" : state === "ok" ? "concluso" : state === "error" ? "errore" : state === "stopped" ? "interrotto" : lifecycle?.output?.startsWith("In coda") ? "in coda" : "stato non disponibile"} · ${activity}`,
+            output: `Incarico: ${goal}\nRuolo: ${lifecycle?.role ?? "non disponibile"}\nRisponde a: ${lifecycle?.parent ?? "orchestratore"}\nAttività: ${activity}\n${active.length} tool attivi · ${files.size} file · ${problems.length} problemi\nEventi disponibili: ${entries.length}`,
+            startedAt: lifecycle?.startedAt, endedAt: lifecycle?.endedAt };
+    });
+}

package/dist/tui/selector-mouse.d.ts

@@ -0,0 +1,26 @@
+interface MouseEvent {
+    button: number;
+    x: number;
+    y: number;
+    press: boolean;
+}
+export declare class SelectorMouseInput {
+    private readonly text;
+    private readonly mouse;
+    private pending;
+    private timer?;
+    constructor(text: (text: string) => void, mouse: (event: MouseEvent) => void);
+    push(chunk: string): void;
+    dispose(): void;
+}
+export declare function selectorMouseIndex(o: {
+    x: number;
+    y: number;
+    rows: number;
+    columns: number;
+    renderedRows: number;
+    count: number;
+    index: number;
+    pageSize: number;
+}): number | null;
+export {};

package/dist/tui/selector-mouse.js

@@ -0,0 +1,65 @@
+// SGR reports can arrive in multiple chunks. Never forward partial mouse
+// sequences to readline: their numbers would become the palette's query.
+export class SelectorMouseInput {
+    text;
+    mouse;
+    pending = "";
+    timer;
+    constructor(text, mouse) {
+        this.text = text;
+        this.mouse = mouse;
+    }
+    push(chunk) {
+        if (this.timer)
+            clearTimeout(this.timer);
+        let rest = this.pending + chunk;
+        this.pending = "";
+        while (rest) {
+            const start = rest.indexOf("\x1b[<");
+            if (start < 0) {
+                // Keep even ESC or ESC+[ until we can distinguish a key from a
+                // fragmented mouse report. A lone Escape is released after 35 ms.
+                const suffix = rest.endsWith("\x1b[") ? 2 : rest.endsWith("\x1b") ? 1 : 0;
+                if (suffix) {
+                    if (rest.length > suffix)
+                        this.text(rest.slice(0, -suffix));
+                    this.pending = rest.slice(-suffix);
+                    this.timer = setTimeout(() => {
+                        const key = this.pending;
+                        this.pending = "";
+                        this.text(key);
+                    }, 35);
+                }
+                else
+                    this.text(rest);
+                return;
+            }
+            if (start)
+                this.text(rest.slice(0, start));
+            rest = rest.slice(start);
+            const match = /^\x1b\[<(\d+);(\d+);(\d+)([Mm])/.exec(rest);
+            if (match) {
+                this.mouse({ button: Number(match[1]), x: Number(match[2]), y: Number(match[3]), press: match[4] === "M" });
+                rest = rest.slice(match[0].length);
+            }
+            else if (/^\x1b\[<[\d;]*$/.test(rest) && rest.length < 48) {
+                this.pending = rest;
+                this.timer = setTimeout(() => { this.pending = ""; }, 250);
+                return;
+            }
+            else {
+                rest = rest.slice(3); // discard a malformed control prefix
+            }
+        }
+    }
+    dispose() { if (this.timer)
+        clearTimeout(this.timer); this.pending = ""; }
+}
+export function selectorMouseIndex(o) {
+    const top = o.rows - Math.min(o.renderedRows, o.rows - 1) + 1;
+    const row = o.y - top - 1; // title occupies the first overlay row
+    if (o.x < 1 || o.x > o.columns + 1 || row < 0 || row >= Math.min(o.count, o.pageSize))
+        return null;
+    const start = Math.max(0, Math.min(o.index - Math.floor(o.pageSize / 2), o.count - o.pageSize));
+    return start + row;
+}

package/dist/tui/selector.d.ts

@@ -0,0 +1,51 @@
+import type { TuiTheme } from "./branding.js";
+export interface SelectOption<T> {
+    readonly key?: string;
+    readonly label: string;
+    readonly detail: string;
+    readonly group?: string;
+    readonly hint?: string;
+    readonly value: T;
+}
+interface SelectorControl {
+    pause(): void;
+    resume(): void;
+    write(text: string): void;
+    setOverlay(lines: string[] | null): void;
+}
+interface SelectorOptions<T> {
+    readonly title: string;
+    readonly hint?: string;
+    readonly options: readonly SelectOption<T>[];
+    readonly current?: T;
+    readonly currentKey?: string;
+    readonly theme: TuiTheme;
+    readonly wide?: boolean;
+    readonly question?: boolean;
+    readonly selectedDetailsOnly?: boolean;
+    readonly mouse?: boolean;
+}
+export interface SelectorRenderOptions<T> extends SelectorOptions<T> {
+    readonly index: number;
+    readonly pageSize: number;
+    readonly columns: number;
+    readonly query?: string;
+    readonly totalCount?: number;
+    readonly details?: boolean;
+    readonly detailOffset?: number;
+}
+export declare function pickerPageSize(rows: number, fullHeight?: boolean): number;
+export declare function filterOptions<T extends {
+    label: string;
+    detail: string;
+    group?: string;
+    hint?: string;
+}>(options: readonly T[], query: string): readonly T[];
+export declare function renderSelector<T>(opts: SelectorRenderOptions<T>): string[];
+export declare function selectOption<T>(opts: SelectorOptions<T> & {
+    readonly ctl: SelectorControl;
+    readonly terminalColumns: () => number;
+    readonly filterable?: boolean;
+    readonly fullHeight?: boolean;
+}): Promise<SelectOption<T> | null>;
+export {};