@vascend/talos 0.1.4 → 0.1.6

package/dist/tui/terminal-text.js

@@ -80,15 +80,39 @@ export function padLine(value, width) {
     const fitted = fitLine(value, width);
     return fitted + " ".repeat(Math.max(0, width - terminalWidth(fitted)));
 }
-export function wrapText(value, width, wordWrap = false) {
+// Count hard-wrapped rows without allocating or painting the hidden text.
+export function wrappedLineCount(value, width) {
+    const max = Math.max(2, width);
+    let count = 0;
+    for (const line of plainText(value).split("\n")) {
+        if (printableAscii.test(line)) {
+            count += Math.max(1, Math.ceil(line.length / Math.floor(max)));
+            continue;
+        }
+        count++;
+        let used = 0;
+        for (const { segment } of graphemes.segment(line)) {
+            const size = cellWidth(segment);
+            if (used + size > max) {
+                count++;
+                used = 0;
+            }
+            used += size;
+        }
+    }
+    return count;
+}
+export function wrapText(value, width, wordWrap = false, maxLines = Infinity) {
     const max = Math.max(2, width);
     const lines = [];
     for (const line of plainText(value).split("\n")) {
+        if (lines.length >= maxLines)
+            break;
         if (!wordWrap && printableAscii.test(line)) {
             const chunk = Math.max(1, Math.floor(max));
             if (!line.length)
                 lines.push("");
-            for (let i = 0; i < line.length; i += chunk)
+            for (let i = 0; i < line.length && lines.length < maxLines; i += chunk)
                 lines.push(line.slice(i, i + chunk));
             continue;
         }
@@ -108,6 +132,8 @@ export function wrapText(value, width, wordWrap = false) {
                     row = "";
                     used = 0;
                 }
+                if (lines.length >= maxLines)
+                    return lines;
                 if (wordWrap && !row && segment === " ")
                     continue;
             }

package/dist/tui/theme.js

@@ -86,8 +86,8 @@ const VASCEND_DARK_COLORS = {
     dim: "dimSilver",
     text: CHAT_TEXT,
     thinkingText: "darkSilver",
-    selectedBg: "#30445e",
-    userMessageBg: "#252c19",
+    selectedBg: "#292929",
+    userMessageBg: "#2b2b2b",
     userMessageText: CHAT_TEXT,
     attachmentRef: "#28aacc",
     customMessageBg: "#12151b",

package/dist/tui/tool-presentation.d.ts

@@ -0,0 +1,3 @@
+import type { ToolCallPart } from "../core/types.js";
+export declare function toolLabel(name: string): string;
+export declare function toolArg(call: ToolCallPart): string;

package/dist/tui/tool-presentation.js

@@ -0,0 +1,98 @@
+import { tr } from "./i18n.js";
+import { oneLine } from "./terminal-text.js";
+function truncate(value, max) {
+    if (value.length <= max)
+        return value;
+    if (max <= 1)
+        return value.slice(0, max);
+    return `${value.slice(0, max - 1)}…`;
+}
+function compactArgs(input) {
+    const value = JSON.stringify(input);
+    return value.length > 80 ? value.slice(0, 77) + "..." : value;
+}
+function vascendArg(call) {
+    const input = call.input;
+    const castle = typeof input["castle"] === "string" && input["castle"] && input["castle"] !== "master"
+        ? ` @${input["castle"]}` : "";
+    switch (call.name) {
+        case "vascend_mark": {
+            const task = String(input["task"] ?? "");
+            const status = String(input["status"] ?? "completed");
+            return truncate(`${task} → ${status}${castle}`, 56);
+        }
+        case "vascend_plan": {
+            const tasks = Array.isArray(input["tasks"]) ? input["tasks"].length : 0;
+            const title = typeof input["title"] === "string" ? input["title"] : "";
+            const count = tr("{count} attività", "{count} tasks", { count: tasks });
+            return truncate(title ? `${title} · ${count}${castle}` : `${count}${castle}`, 60);
+        }
+        case "vascend_addtasks": {
+            const tasks = Array.isArray(input["tasks"]) ? input["tasks"].length : 0;
+            return truncate("+" + tr("{count} attività", "{count} tasks", { count: tasks }) + castle, 56);
+        }
+        case "vascend_note": {
+            const task = typeof input["task"] === "string" && input["task"] ? `${input["task"]}: ` : "";
+            return truncate(`${task}${String(input["text"] ?? input["note"] ?? "")}`, 56);
+        }
+        case "vascend_skill": {
+            const task = typeof input["task"] === "string" && input["task"] ? `${input["task"]}: ` : "";
+            const skills = Array.isArray(input["skills"])
+                ? input["skills"].join(", ") : String(input["skills"] ?? input["skill"] ?? "");
+            return truncate(`${task}${skills}`, 56);
+        }
+        default:
+            return null;
+    }
+}
+export function toolLabel(name) {
+    if (/(?:^|_)(?:widget_)?read_me$/.test(name))
+        return tr('Istruzioni visuali', 'Visual instructions');
+    if (/(?:^|_)(?:visualize|show_widget)$/.test(name))
+        return tr('Artifact', 'Artifact');
+    const labels = {
+        read_file: "Read", write_file: "Write", edit_file: "Update", list_dir: "List",
+        bash: "Bash", bash_output: tr("Processo in background", "Background process"), web_fetch: "Fetch", ask_user: "Ask",
+        wait: "Wait", tool_search: "ToolSearch", tool_invoke: "Invoke", skill_search: "SkillSearch",
+        skill_load: "SkillLoad", output_page: "Page", kingdoms_warm: tr("Collaboratori", "Collaborators"),
+        kingdom_send: "Send", kingdom_inbox: "Inbox", kingdom_wait: "WaitMsg", glob: "Glob",
+        grep: "Grep", recall: "Recall", image_generate: "Image",
+        vascend_plan: tr("Lista attività", "Task list"), vascend_mark: tr("Stato attività", "Task status"),
+        vascend_note: "Note", vascend_skill: "Skill",
+        vascend_addtasks: tr("Aggiungi attività", "Add tasks"),
+        vascend_addrooms: tr("Aggiungi attività", "Add tasks"),
+        vascend_status: tr("Lista attività", "Task list"),
+    };
+    return labels[name] ?? name;
+}
+export function toolArg(call) {
+    const path = call.input["path"];
+    if (call.name === "run_program") {
+        const code = String(call.input["code"] ?? "");
+        return tr("JavaScript · {count} righe · Ctrl+R dettagli", "JavaScript · {count} lines · Ctrl+R details", { count: code.split("\n").length });
+    }
+    if (call.name === "tool_invoke") {
+        const inner = String(call.input["name"] ?? "");
+        const args = call.input["args"] && typeof call.input["args"] === "object"
+            ? compactArgs(call.input["args"]) : "";
+        return truncate(`${inner}${args && args !== "{}" ? ` ${args}` : ""}`, 56);
+    }
+    if (call.name === "tool_search" || call.name === "skill_search")
+        return truncate(String(call.input["query"] ?? ""), 50);
+    if (call.name === "skill_load")
+        return String(call.input["name"] ?? "");
+    if (call.name === "grep" || call.name === "glob")
+        return truncate(String(call.input["pattern"] ?? ""), 50);
+    if (call.name === "wait") {
+        const until = call.input["until"];
+        return typeof until === "string" && until ? `until ${truncate(until, 44)}` : `${call.input["seconds"] ?? 5}s`;
+    }
+    const danilov = vascendArg(call);
+    if (danilov !== null)
+        return danilov;
+    if (typeof path === "string" && path)
+        return path;
+    if (call.name === "bash")
+        return truncate(oneLine(String(call.input["command"] ?? "")), 60);
+    return compactArgs(call.input);
+}

package/dist/tui/tool-style.js

@@ -39,6 +39,10 @@ const CATEGORY = {
     image_generate: "image",
 };
 export function toolCategory(name) {
+    if (/(?:^|_)(?:widget_)?read_me$/.test(name))
+        return 'search';
+    if (/(?:^|_)(?:visualize|show_widget)$/.test(name))
+        return 'image';
     return CATEGORY[name] ?? "misc";
 }
 // Colore PIENO di ogni categoria (tinta a cui punta il pulse), come tripla RGB.

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

@@ -0,0 +1,25 @@
+export declare class TranscriptStore<T> {
+    private readonly maxChars;
+    private readonly maxItems;
+    private tail;
+    private tailChars;
+    private stored;
+    private chunks;
+    private cache;
+    private directory?;
+    private fd?;
+    private bytes;
+    constructor(maxChars?: number, maxItems?: number);
+    get length(): number;
+    get retainedChars(): number;
+    push(value: T): void;
+    get(index: number): T | undefined;
+    set(index: number, value: T): void;
+    slice(start?: number, end?: number): T[];
+    from(start?: number, end?: number): IterableIterator<T>;
+    clear(): void;
+    private chunkAt;
+    private spill;
+    private write;
+    private load;
+}

package/dist/tui/transcript-store.js

@@ -0,0 +1,151 @@
+import { closeSync, mkdtempSync, openSync, readSync, rmSync, writeSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+// Disposable UI history, not model memory. Keep a small mutable tail and spill
+// complete chunks to disk. Indexed slices read only the visible chunks; resize
+// can replay original events without retaining their entire payload in the heap.
+export class TranscriptStore {
+    maxChars;
+    maxItems;
+    tail = [];
+    tailChars = 0;
+    stored = 0;
+    chunks = [];
+    cache = new Map();
+    directory;
+    fd;
+    bytes = 0;
+    constructor(maxChars = 256_000, maxItems = 512) {
+        this.maxChars = maxChars;
+        this.maxItems = maxItems;
+    }
+    get length() { return this.stored + this.tail.length; }
+    get retainedChars() { return this.tailChars; }
+    push(value) {
+        const size = JSON.stringify(value).length;
+        if (this.tail.length && (this.tail.length >= this.maxItems || this.tailChars + size > this.maxChars))
+            this.spill();
+        this.tail.push(value);
+        this.tailChars += size;
+        if (this.tailChars >= this.maxChars)
+            this.spill();
+    }
+    get(index) {
+        if (index < 0 || index >= this.length)
+            return undefined;
+        if (index >= this.stored)
+            return this.tail[index - this.stored];
+        const chunk = this.chunkAt(index);
+        return this.load(chunk)[index - this.chunks[chunk].start];
+    }
+    set(index, value) {
+        if (index < 0 || index >= this.length)
+            return;
+        if (index >= this.stored) {
+            const at = index - this.stored;
+            this.tailChars += JSON.stringify(value).length - JSON.stringify(this.tail[at]).length;
+            this.tail[at] = value;
+            if (this.tailChars >= this.maxChars)
+                this.spill();
+            return;
+        }
+        const chunk = this.chunkAt(index), previous = this.chunks[chunk];
+        const values = [...this.load(chunk)];
+        values[index - previous.start] = value;
+        this.chunks[chunk] = this.write(values, previous.start);
+        this.cache.delete(chunk);
+    }
+    slice(start = 0, end = this.length) {
+        const rows = [];
+        for (const value of this.from(start, end))
+            rows.push(value);
+        return rows;
+    }
+    *from(start = 0, end = this.length) {
+        let index = Math.max(0, start);
+        const limit = Math.min(end, this.length);
+        while (index < Math.min(limit, this.stored)) {
+            const chunk = this.chunkAt(index), info = this.chunks[chunk];
+            const values = this.load(chunk), stop = Math.min(limit, info.start + info.count);
+            while (index < stop)
+                yield values[index++ - info.start];
+        }
+        while (index < limit)
+            yield this.tail[index++ - this.stored];
+    }
+    clear() {
+        this.tail = [];
+        this.tailChars = 0;
+        this.stored = 0;
+        this.chunks = [];
+        this.cache.clear();
+        this.bytes = 0;
+        if (this.fd !== undefined) {
+            closeSync(this.fd);
+            this.fd = undefined;
+        }
+        if (this.directory) {
+            const directory = this.directory;
+            this.directory = undefined;
+            try {
+                rmSync(directory, { recursive: true, force: true });
+            }
+            catch { /* Disposable cache may be held by a scanner. */ }
+        }
+    }
+    chunkAt(index) {
+        let low = 0, high = this.chunks.length - 1;
+        while (low < high) {
+            const mid = Math.ceil((low + high) / 2);
+            if (this.chunks[mid].start <= index)
+                low = mid;
+            else
+                high = mid - 1;
+        }
+        return low;
+    }
+    spill() {
+        this.chunks.push(this.write(this.tail, this.stored));
+        this.stored += this.tail.length;
+        this.tail = [];
+        this.tailChars = 0;
+    }
+    write(values, start) {
+        if (this.fd === undefined) {
+            this.directory = mkdtempSync(join(tmpdir(), "talos-transcript-"));
+            this.fd = openSync(join(this.directory, "chunks.json"), "w+", 0o600);
+        }
+        const buffer = Buffer.from(JSON.stringify(values));
+        const offset = this.bytes;
+        let written = 0;
+        while (written < buffer.length) {
+            const size = writeSync(this.fd, buffer, written, buffer.length - written, offset + written);
+            if (!size)
+                throw new Error("Unable to write transcript cache");
+            written += size;
+        }
+        this.bytes += written;
+        return { start, count: values.length, offset, bytes: written };
+    }
+    load(index) {
+        const cached = this.cache.get(index);
+        if (cached)
+            return cached;
+        const chunk = this.chunks[index], buffer = Buffer.allocUnsafe(chunk.bytes);
+        let read = 0;
+        while (read < buffer.length) {
+            const size = readSync(this.fd, buffer, read, buffer.length - read, chunk.offset + read);
+            if (!size)
+                throw new Error("Unable to read transcript cache");
+            read += size;
+        }
+        const values = JSON.parse(buffer.toString("utf8"));
+        // Oversized single events are read on demand, never retained in the cache.
+        if (chunk.bytes <= this.maxChars * 2) {
+            this.cache.set(index, values);
+            if (this.cache.size > 2)
+                this.cache.delete(this.cache.keys().next().value);
+        }
+        return values;
+    }
+}

package/dist/tui/usage-footer.d.ts

@@ -2,7 +2,7 @@ import type { PlanLimits } from "../core/types.js";
 import type { TuiTheme } from "./branding.js";
 import { type SessionUsageState } from "./session-usage.js";
 import { type StatusData, type StatusOptions } from "./status-line.js";
-export declare const SESSION_USAGE_EXPLANATION = "I token cumulati sono la somma delle chiamate della sessione, inclusi input ripetuti e cache: non sono il contesto di una singola richiesta. Talos seleziona informazioni rilevanti e gestisce la cronologia con recupero e compattazione secondo la configurazione. Questo non annulla i consumi registrati dal provider. \u2265 indica un totale parziale: il consumo noto \u00E8 almeno quello mostrato. Il contesto indicato \u00E8 una stima locale, non una misura esatta del payload inviato.";
+export declare function sessionUsageExplanation(): string;
 type UsageState = Pick<SessionUsageState, "limits" | "incomplete" | "missing" | "unsaved">;
 export declare function subscriptionDetails(providerId: string, limits: PlanLimits | undefined, t: TuiTheme, now?: number): string[];
 export declare function buildUsageFooter(d: StatusData, t: TuiTheme, state: UsageState, providerId: string, opts?: StatusOptions, now?: number): readonly string[];

package/dist/tui/usage-footer.js

@@ -4,7 +4,9 @@ import { buildStatusLine, DEFAULT_ORDER } from "./status-line.js";
 import { fitLine, oneLine, terminalWidth } from "./terminal-text.js";
 import { buildContextBar } from "./context-bar.js";
 import { getLanguage, tr } from "./i18n.js";
-export const SESSION_USAGE_EXPLANATION = "I token cumulati sono la somma delle chiamate della sessione, inclusi input ripetuti e cache: non sono il contesto di una singola richiesta. Talos seleziona informazioni rilevanti e gestisce la cronologia con recupero e compattazione secondo la configurazione. Questo non annulla i consumi registrati dal provider. ≥ indica un totale parziale: il consumo noto è almeno quello mostrato. Il contesto indicato è una stima locale, non una misura esatta del payload inviato.";
+export function sessionUsageExplanation() {
+    return tr("I token cumulati sono la somma delle chiamate della sessione, inclusi input ripetuti e cache: non sono il contesto di una singola richiesta. Talos seleziona informazioni rilevanti e gestisce la cronologia con recupero e compattazione secondo la configurazione. Questo non annulla i consumi registrati dal provider. ≥ indica un totale parziale: il consumo noto è almeno quello mostrato. Il contesto indicato è una stima locale, non una misura esatta del payload inviato.", "Cumulative tokens sum the session's calls, including repeated input and cache: they are not the context of a single request. Talos selects relevant information and manages history through retrieval and compaction according to configuration. This does not erase usage recorded by the provider. ≥ indicates a partial total: known usage is at least the amount shown. The displayed context is a local estimate, not an exact measurement of the payload sent.");
+}
 const shortLabel = (label) => label.replace("Limite 5 ore", "5h").replace("Settimanale", tr("7g", "7d")).replace("Finestra ", "");
 const remainingPercent = (window) => window.status === "rejected" ? "0%"
     : window.utilization !== undefined ? `${Math.round(Math.max(0, Math.min(1, 1 - window.utilization)) * 100)}%` : undefined;

package/dist/tui/vascend-id.d.ts

@@ -0,0 +1,49 @@
+export declare const VASCEND_ID_ISSUER = "https://id.vascend.it";
+export declare const VASCEND_ID_CLIENT = "talos";
+export declare const AGENT_RESOURCE = "https://api.vascend.it/agent";
+export declare const RELAY_RESOURCE = "https://relay.vascend.it";
+export declare const LOGIN_RESOURCES: readonly ["https://api.vascend.it/agent", "https://relay.vascend.it"];
+export declare const VASCEND_ID_SCOPE = "openid email offline_access agent sessions";
+type FetchLike = (url: string, init?: RequestInit) => Promise<Response>;
+export interface IdDeps {
+    readonly fetchImpl?: FetchLike;
+    readonly now?: () => number;
+}
+export interface TokenRisorsa {
+    readonly token: string;
+    readonly scade: number;
+}
+export interface SessioneId {
+    readonly accessToken: string;
+    readonly refreshToken: string;
+    readonly scade: number;
+    readonly email: string;
+    readonly risorse?: Readonly<Record<string, TokenRisorsa>>;
+}
+export declare class VascendIdError extends Error {
+    readonly code: string;
+    constructor(code: string);
+}
+export declare function issuerOf(env: NodeJS.ProcessEnv): string;
+export declare function tokenPlausibile(token: unknown, max?: number): token is string;
+export declare function claimNonVerificati(token: string): Record<string, unknown>;
+export declare function chiamaId(env: NodeJS.ProcessEnv, path: string, campi: Record<string, string | readonly string[]>, deps?: IdDeps, signal?: AbortSignal): Promise<Record<string, unknown>>;
+export declare function sessioneDaRisposta(data: Record<string, unknown>, now: number): SessioneId;
+export declare function sessionePath(env: NodeJS.ProcessEnv): string | null;
+export declare function leggiSessione(env: NodeJS.ProcessEnv): SessioneId | null;
+export declare function salvaSessione(env: NodeJS.ProcessEnv, sessione: SessioneId): boolean;
+export declare function rimuoviSessione(env: NodeJS.ProcessEnv): void;
+export interface EsitoToken {
+    readonly token: string;
+    readonly email?: string;
+    readonly errore?: "assente" | "respinta" | "rete";
+}
+export declare function tokenAgente(env: NodeJS.ProcessEnv, deps?: IdDeps): Promise<EsitoToken>;
+export interface EsitoTokenRisorsa {
+    readonly token: string;
+    readonly email?: string;
+    readonly errore?: "assente" | "respinta" | "rete" | "risorsa";
+}
+export declare function tokenRisorsa(env: NodeJS.ProcessEnv, risorsa: string, deps?: IdDeps): Promise<EsitoTokenRisorsa>;
+export declare function revocaSessioneId(env: NodeJS.ProcessEnv, deps?: IdDeps): Promise<void>;
+export {};