@vascend/talos 0.1.0

package/dist/core/background.d.ts

@@ -0,0 +1,45 @@
+import { type ChildProcess } from "node:child_process";
+export declare function terminateChildProcess(child: ChildProcess): void;
+export type BgStatus = "running" | "done" | "failed" | "killed";
+export interface BgTask {
+    readonly id: string;
+    readonly command: string;
+    readonly startedAt: number;
+    endedAt?: number;
+    status: BgStatus;
+    exitCode?: number;
+    output: string;
+    detached?: boolean;
+}
+interface Foreground {
+    readonly taskId: string;
+    background(): void;
+}
+export declare class BackgroundManager {
+    private readonly tasks;
+    private readonly children;
+    private readonly order;
+    private seq;
+    private fg;
+    private readonly changeCbs;
+    private readonly finishCbs;
+    createTask(command: string): BgTask;
+    setChild(id: string, child: ChildProcess): void;
+    appendOutput(id: string, chunk: string): void;
+    finishTask(id: string, status: BgStatus, exitCode?: number): void;
+    setForeground(fg: Foreground): void;
+    clearForeground(id?: string): void;
+    hasForeground(): boolean;
+    markDetached(id: string): void;
+    requestBackground(): BgTask | null;
+    kill(id: string): boolean;
+    get(id: string): BgTask | undefined;
+    list(): readonly BgTask[];
+    running(): readonly BgTask[];
+    onChange(cb: () => void): () => void;
+    onFinish(cb: (task: BgTask) => void): () => void;
+    private emitChange;
+    private pruneHistory;
+}
+export declare const backgroundManager: BackgroundManager;
+export {};

package/dist/core/background.js

@@ -0,0 +1,140 @@
+import { spawn } from "node:child_process";
+// `child.kill()` su Windows termina spesso soltanto cmd/bash lasciando vivi i
+// processi generati (node, npm, test runner). Il controllo agentico deve invece
+// riferirsi all'intero comando, quindi usa la terminazione ricorsiva del tree.
+export function terminateChildProcess(child) {
+    if (process.platform === "win32" && child.pid) {
+        try {
+            const killer = spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], { windowsHide: true });
+            killer.once("error", () => { try {
+                child.kill();
+            }
+            catch { /* gia' terminato */ } });
+            return;
+        }
+        catch { /* fallback portabile sotto */ }
+    }
+    try {
+        child.kill("SIGTERM");
+    }
+    catch { /* gia' terminato */ }
+}
+const MAX_BG_OUTPUT = 50_000;
+const MAX_COMPLETED_BACKGROUND = 20;
+export class BackgroundManager {
+    tasks = new Map();
+    children = new Map();
+    order = [];
+    seq = 0;
+    fg = null;
+    changeCbs = new Set();
+    finishCbs = new Set();
+    createTask(command) {
+        this.seq += 1;
+        const id = `bg${this.seq}`;
+        const task = { id, command, startedAt: Date.now(), status: "running", output: "" };
+        this.tasks.set(id, task);
+        this.order.push(id);
+        this.emitChange();
+        return task;
+    }
+    setChild(id, child) {
+        this.children.set(id, child);
+    }
+    appendOutput(id, chunk) {
+        const t = this.tasks.get(id);
+        if (!t)
+            return;
+        t.output = (t.output + chunk).slice(-MAX_BG_OUTPUT);
+        this.emitChange();
+    }
+    finishTask(id, status, exitCode) {
+        const t = this.tasks.get(id);
+        if (!t || t.status !== "running")
+            return;
+        t.status = status;
+        t.endedAt = Date.now();
+        if (exitCode !== undefined)
+            t.exitCode = exitCode;
+        this.children.delete(id);
+        this.emitChange();
+        for (const cb of this.finishCbs)
+            cb(t);
+        this.pruneHistory(id);
+    }
+    // Registra il comando in primo piano (chiamato dal tool bash all'avvio).
+    setForeground(fg) { this.fg = fg; }
+    clearForeground(id) { if (!id || this.fg?.taskId === id)
+        this.fg = null; }
+    hasForeground() { return this.fg !== null; }
+    markDetached(id) {
+        const task = this.tasks.get(id);
+        if (task && !task.detached) {
+            task.detached = true;
+            this.emitChange();
+        }
+    }
+    // Ctrl+B: stacca il comando in primo piano. Ritorna il task o null se non c'e'
+    // niente in primo piano.
+    requestBackground() {
+        const fg = this.fg;
+        if (!fg)
+            return null;
+        this.fg = null;
+        const t = this.tasks.get(fg.taskId);
+        if (t)
+            t.detached = true;
+        this.emitChange();
+        fg.background();
+        return t ?? null;
+    }
+    kill(id) {
+        const child = this.children.get(id);
+        if (!child)
+            return false;
+        terminateChildProcess(child);
+        this.finishTask(id, "killed");
+        return true;
+    }
+    get(id) { return this.tasks.get(id); }
+    list() {
+        // Ogni comando shell nasce come candidato al Ctrl+B, ma diventa davvero
+        // un'attivita' in background soltanto quando l'utente lo stacca. Esporre
+        // anche i normali comandi conclusi faceva crescere /bg senza limite.
+        return this.order
+            .map((id) => this.tasks.get(id))
+            .filter((t) => Boolean(t?.detached));
+    }
+    running() { return this.list().filter((t) => t.status === "running"); }
+    onChange(cb) { this.changeCbs.add(cb); return () => this.changeCbs.delete(cb); }
+    onFinish(cb) { this.finishCbs.add(cb); return () => this.finishCbs.delete(cb); }
+    emitChange() { for (const cb of this.changeCbs)
+        cb(); }
+    pruneHistory(latestId) {
+        const completedDetached = this.order.filter((id) => {
+            const task = this.tasks.get(id);
+            return Boolean(task?.detached && task.status !== "running");
+        });
+        const retainedDetached = new Set(completedDetached.slice(-MAX_COMPLETED_BACKGROUND));
+        const keep = new Set(this.order.filter((id) => {
+            const task = this.tasks.get(id);
+            if (!task)
+                return false;
+            if (task.status === "running")
+                return true;
+            if (task.detached)
+                return retainedDetached.has(id);
+            // Mantieni soltanto l'ultimo foreground: il chiamante legge il suo
+            // output immediatamente dopo finishTask, gli altri non sono consultabili.
+            return id === latestId;
+        }));
+        for (const id of this.order) {
+            if (!keep.has(id))
+                this.tasks.delete(id);
+        }
+        const retainedOrder = this.order.filter((id) => keep.has(id));
+        this.order.splice(0, this.order.length, ...retainedOrder);
+    }
+}
+// Istanza condivisa di processo.
+export const backgroundManager = new BackgroundManager();

package/dist/core/bootstrap.d.ts

@@ -0,0 +1,45 @@
+import type { PiConfig } from "./config.js";
+import { Session } from "./session.js";
+import { ToolRegistry } from "../tools/registry.js";
+import type { ProviderRegistry } from "../providers/registry.js";
+import { ExtensionHost } from "../extensions/loader.js";
+import { type Skill } from "../skills/skills.js";
+import { type PackageResources } from "../packages/packages.js";
+import type { AgentDeps } from "./agent.js";
+import { type ExecutionTarget } from "./execution-target.js";
+import { WorkspaceSession } from "./workspace-sessions.js";
+export interface Harness {
+    config: PiConfig;
+    readonly env: NodeJS.ProcessEnv;
+    readonly tools: ToolRegistry;
+    readonly providers: ProviderRegistry;
+    readonly host: ExtensionHost;
+    readonly session: Session;
+    readonly skills: readonly Skill[];
+    readonly skillCommandsEnabled: boolean;
+    readonly projectTrusted: boolean;
+    readonly packages: PackageResources;
+    /** Root aggiuntive che appartengono allo stesso progetto della cwd primaria. */
+    readonly fsRoots: readonly string[];
+    readonly executionTarget: ExecutionTarget;
+    readonly workspaceSession?: WorkspaceSession;
+    /** Chiude presenza e risorse del canale fra sessioni. */
+    dispose?(): void;
+    deps(confirm: AgentDeps["confirm"]): AgentDeps;
+    setModel(model: string): void;
+    reloadProviders(): void;
+    loadSession(id: string): Session;
+    newSession(): Session;
+}
+export declare function createToolRegistry(env: NodeJS.ProcessEnv): ToolRegistry;
+export declare function bootstrap(opts: {
+    cwd?: string;
+    fsRoots?: readonly string[];
+    executionTarget?: ExecutionTarget;
+    model?: string;
+    sessionId?: string;
+    continueLast?: boolean;
+    sessionName?: string;
+    env?: NodeJS.ProcessEnv;
+    trustPrompt?: (resources: readonly string[]) => Promise<boolean>;
+}): Promise<Harness>;

package/dist/core/bootstrap.js

@@ -0,0 +1,294 @@
+import { buildConfig } from "./config.js";
+import { Session, listSessions } from "./session.js";
+import { prepareSessionStorage } from "./session-storage.js";
+import { maintainSessionStorage, protectSessionStorage } from "./storage-retention.js";
+import { applyStoredCredentials } from "./credentials.js";
+import { ToolRegistry } from "../tools/registry.js";
+import { builtinTools } from "../tools/builtin.js";
+import { registerComputerUse } from "../tools/computer-use.js";
+import { resolveTool } from "../tools/resolve.js";
+import { executeTool } from "../tools/execute.js";
+import { CLI_DIRECT_TOOL_NAMES, FILE_DISCOVERY_TOOL_NAMES, HORIZON_DIRECT_TOOL_NAMES, toolDescribeTool, toolListTool } from "../tools/discovery.js";
+import { defaultRegistry, resolveStartupModel } from "../providers/registry.js";
+import { ExtensionHost } from "../extensions/loader.js";
+import { registerExtensionTools } from "../extensions/ext-tools.js";
+import { OpenAICompatProvider } from "../providers/openai-compat.js";
+import { discoverSkills, skillsSystemBlock } from "../skills/skills.js";
+import { parseDefaultTrust, resolveProjectTrust, writeTrustDecision } from "./trust.js";
+import { resolvePackages } from "../packages/packages.js";
+import { contextWindowFor, estimateMessagesTokens, estimateTokens, estimateToolDefinitionTokens } from "./compaction.js";
+import { resolveWorkspaceRoots, workspaceSystemBlock } from "./workspace-roots.js";
+import { normalizeExecutionTarget } from "./execution-target.js";
+import { WorkspaceSession } from "./workspace-sessions.js";
+export function createToolRegistry(env) {
+    const horizonDiscovery = env["TALOS_HOST_PROFILE"]?.trim().toLowerCase() === "horizon";
+    const deferTools = env["TALOS_DEFER_TOOLS"] !== "0";
+    const excluded = (env["TALOS_EXCLUDE_TOOLS"] ?? "").split(",").map(name => name.trim()).filter(Boolean);
+    const profile = env["TALOS_TOOL_PROFILE"]?.trim().toLowerCase();
+    if (profile && profile !== "compact" && profile !== "standard")
+        throw new Error("TALOS_TOOL_PROFILE must be compact or standard");
+    const compact = profile === "compact" || (!profile && !horizonDiscovery && deferTools
+        && !excluded.includes("resolve") && !excluded.includes("execute"));
+    if (compact && (excluded.includes("resolve") || excluded.includes("execute"))) {
+        throw new Error("The compact profile requires resolve and execute. Use TALOS_TOOL_PROFILE=standard for this exclusion.");
+    }
+    const directTools = new Set(horizonDiscovery ? HORIZON_DIRECT_TOOL_NAMES : CLI_DIRECT_TOOL_NAMES);
+    if (excluded.includes("bash"))
+        for (const name of FILE_DISCOVERY_TOOL_NAMES)
+            directTools.add(name);
+    const tools = new ToolRegistry(compact ? { compact: true } : horizonDiscovery || deferTools ? { directTools } : undefined);
+    for (const tool of builtinTools) {
+        tools.register(tool);
+    }
+    tools.register(toolListTool, deferTools);
+    tools.register(toolDescribeTool, deferTools);
+    if (compact) {
+        tools.register(resolveTool);
+        tools.register(executeTool);
+    }
+    for (const name of excluded) {
+        tools.remove(name);
+    }
+    return tools;
+}
+// Assembla l'intero harness: config, provider, tool builtin, estensioni,
+// sessione. Punto unico di costruzione condiviso da TUI/print/RPC/SDK.
+export async function bootstrap(opts) {
+    // Le credenziali persistite (~/.talos/config.json, blocco "providers")
+    // diventano TALOS_<ID>_API_KEY / _BASE_URL prima di costruire config e
+    // registro. Le env var gia' presenti hanno precedenza.
+    const env = applyStoredCredentials(opts.env ?? process.env);
+    const executionTarget = normalizeExecutionTarget(opts.executionTarget);
+    let config = buildConfig({ cwd: opts.cwd, model: opts.model, env });
+    const fsRoots = resolveWorkspaceRoots({ cwd: config.cwd, explicit: opts.fsRoots, env });
+    const tools = createToolRegistry(env);
+    registerComputerUse(tools, env);
+    let providers = defaultRegistry(env);
+    // Modello PREFERITO dall'utente: l'intento salvato/configurato. Lo teniamo
+    // separato dal modello effettivo cosi', se al riavvio il suo provider non e'
+    // (ancora) configurato, ripieghiamo su uno disponibile SENZA dimenticare la
+    // scelta. Appena il provider torna (reloadProviders), il preferito riprende.
+    let preferredModel = config.model;
+    {
+        const startup = resolveStartupModel(providers, preferredModel);
+        if (startup.model !== config.model)
+            config = { ...config, model: startup.model };
+    }
+    // Project trust: decide se caricare risorse locali al progetto.
+    const trust = await resolveProjectTrust({
+        cwd: config.cwd,
+        env,
+        defaultTrust: parseDefaultTrust(env["TALOS_DEFAULT_TRUST"]),
+        prompt: opts.trustPrompt,
+    });
+    const projectTrusted = trust.trusted;
+    if (trust.persist)
+        writeTrustDecision(env, config.cwd, projectTrusted ? "trust" : "deny");
+    // Packages: bundle configurati esplicitamente dall'utente (env/global).
+    const packages = resolvePackages(env, [], { cwd: config.cwd, projectTrusted });
+    // Estensioni: caricate dal progetto solo se fidato (eseguono codice). Le
+    // estensioni dei package sono configurate dall'utente -> caricate sempre.
+    const host = new ExtensionHost(tools, config.cwd);
+    if (projectTrusted)
+        await host.loadDir();
+    for (const ext of packages.extensions) {
+        try {
+            await host.loadModule(ext);
+        }
+        catch (err) {
+            process.stderr.write(`[pkg] errore estensione ${ext}: ${err.message}\n`);
+        }
+    }
+    // Tool CORE per ispezionare e gestire le estensioni a runtime: l'agente puo'
+    // vedere la lista (con cosa registrano e lo stato) e cambiarne le impostazioni
+    // (enable/disable, opzioni). Persistiti su .talos/extensions-settings.json.
+    registerExtensionTools(tools, host);
+    // Evento project_trust: le estensioni possono osservare la decisione di
+    // fiducia sulle risorse locali (parita' Pi).
+    await host.emit("project_trust", {
+        trusted: projectTrusted,
+        cwd: config.cwd,
+        resources: trust.resources,
+        source: trust.source,
+    });
+    // Skills: discovery + progressive disclosure (solo nome+descrizione nel
+    // system prompt). --no-skills/--skill arrivano via env. Le skill di progetto
+    // richiedono trust.
+    const skillsDisabled = env["TALOS_NO_SKILLS"] === "1";
+    const extraSkillPaths = [
+        ...(env["TALOS_SKILLS"] ?? "").split(",").map((p) => p.trim()).filter(Boolean),
+        ...packages.skills,
+    ];
+    const skills = discoverSkills(config.cwd, {
+        extraPaths: extraSkillPaths,
+        disabled: skillsDisabled,
+        projectTrusted,
+    });
+    const skillCommandsEnabled = env["TALOS_SKILL_COMMANDS"] !== "0";
+    const skillBlock = skillsSystemBlock(skills);
+    const workspaceBlock = workspaceSystemBlock(config.cwd, fsRoots);
+    const systemParts = [config.system, workspaceBlock, skillBlock].filter(Boolean);
+    const systemWithSkills = systemParts.join("\n\n");
+    config = { ...config, system: host.applySystem(systemWithSkills) };
+    // Sessione MUTABILE: /resume puo' sostituirla a runtime. Le closure sotto
+    // (host.bind, deps()) riferiscono la variabile `session`, quindi vedono il
+    // nuovo valore dopo loadSession senza ri-bind.
+    prepareSessionStorage(config, env);
+    const resumeId = opts.sessionId ?? (opts.continueLast ? listSessions(config.sessionDir)[0]?.id : undefined);
+    const protectStorage = (id) => protectSessionStorage(config.sessionDir, [id, config.roomStoreId, config.planStoreId].filter((value) => Boolean(value)), env, config.cwd);
+    let releaseStorage = resumeId ? protectStorage(resumeId) : () => { };
+    let session;
+    try {
+        session = resumeId ? Session.load(config.sessionDir, resumeId) : Session.create(config.sessionDir);
+        if (!resumeId)
+            releaseStorage = protectStorage(session.id);
+    }
+    catch (error) {
+        releaseStorage();
+        throw error;
+    }
+    maintainSessionStorage(env, config.cwd);
+    const maintenanceTimer = setInterval(() => maintainSessionStorage(env, config.cwd), 3_600_000);
+    maintenanceTimer.unref();
+    if (opts.sessionName && opts.sessionName !== session.name)
+        session.setName(opts.sessionName);
+    const openWorkspaceSession = () => {
+        if (env["TALOS_WORKSPACE_SESSIONS"] === "0")
+            return undefined;
+        try {
+            return new WorkspaceSession({ cwd: config.cwd, sessionId: session.id, label: session.name ?? session.id,
+                model: config.model, env, executionTarget });
+        }
+        catch (error) {
+            process.stderr.write(`[talos] coordinamento fra sessioni non disponibile: ${error.message}\n`);
+            return undefined;
+        }
+    };
+    let workspaceSession = openWorkspaceSession();
+    const renewWorkspaceSession = () => {
+        workspaceSession?.close();
+        workspaceSession = openWorkspaceSession();
+    };
+    // Inietta nell'host le capacita' runtime (provider/sessione/contesto) per
+    // l'ExtensionApi e il bus eventi.
+    host.bind({
+        isProjectTrusted: () => projectTrusted,
+        contextUsage: () => ({
+            tokens: estimateTokens(config.system) + estimateMessagesTokens(session.history()) + estimateToolDefinitionTokens(tools.defs()),
+            window: contextWindowFor(config.model, config.contextWindow),
+        }),
+        systemPrompt: () => config.system,
+        registerProvider: (name, cfg) => providers.register(new OpenAICompatProvider(name, cfg.label ?? name, cfg.baseUrl ?? "", cfg.apiKey ?? "", cfg.models ?? [])),
+        unregisterProvider: (name) => {
+            providers.remove(name);
+        },
+        setSessionName: (name) => session.setName(name),
+        setLabel: () => { },
+        appendEntry: (type, data) => session.append({ role: "user", content: [{ type: "text", text: `[${type}] ${JSON.stringify(data ?? {})}` }] }),
+        sessionEntries: () => session.tree(),
+        sessionLeafId: () => session.head,
+    });
+    // config e' mutabile via closure: /model lo aggiorna e i giri successivi
+    // dell'agente lo rileggono al momento di costruire i deps.
+    const harness = {
+        get config() {
+            return config;
+        },
+        set config(next) {
+            const changedWorkspace = config.cwd !== next.cwd;
+            const changedStorage = config.sessionDir !== next.sessionDir || config.roomStoreId !== next.roomStoreId || config.planStoreId !== next.planStoreId;
+            config = next;
+            if (changedStorage) {
+                const releasePrevious = releaseStorage;
+                releaseStorage = protectStorage(session.id);
+                releasePrevious();
+            }
+            if (changedWorkspace)
+                renewWorkspaceSession();
+        },
+        tools,
+        env,
+        get providers() {
+            return providers;
+        },
+        host,
+        get session() {
+            return session;
+        },
+        skills,
+        skillCommandsEnabled,
+        projectTrusted,
+        packages,
+        fsRoots,
+        executionTarget,
+        get workspaceSession() { return workspaceSession; },
+        dispose() { workspaceSession?.close(); workspaceSession = undefined; releaseStorage(); clearInterval(maintenanceTimer); },
+        setModel(model) {
+            config = { ...config, model };
+            // La scelta esplicita dell'utente diventa la nuova PREFERENZA: cosi' un
+            // reloadProviders successivo non la sovrascrive con un ripiego.
+            preferredModel = model;
+        },
+        reloadProviders() {
+            // Rilegge le credenziali persistite dal disco e ricostruisce il
+            // registro. Le env var gia' presenti nel processo mantengono la
+            // precedenza (come all'avvio).
+            const fresh = applyStoredCredentials(env);
+            providers = defaultRegistry(fresh);
+            // Il provider del modello PREFERITO potrebbe essere appena diventato
+            // disponibile (l'utente ha inserito la chiave): se ora risolve, ripristina
+            // il preferito; altrimenti tieni un ripiego erogabile.
+            const startup = resolveStartupModel(providers, preferredModel);
+            if (startup.model !== config.model)
+                config = { ...config, model: startup.model };
+        },
+        loadSession(id) {
+            const releaseNext = protectStorage(id);
+            try {
+                session = Session.load(config.sessionDir, id);
+            }
+            catch (error) {
+                releaseNext();
+                throw error;
+            }
+            releaseStorage();
+            releaseStorage = releaseNext;
+            renewWorkspaceSession();
+            return session;
+        },
+        newSession() {
+            session = Session.create(config.sessionDir);
+            const releaseNext = protectStorage(session.id);
+            releaseStorage();
+            releaseStorage = releaseNext;
+            renewWorkspaceSession();
+            return session;
+        },
+        deps(confirm) {
+            workspaceSession?.update({ label: session.name ?? session.id, model: config.model });
+            const resolved = providers.resolve(config.model);
+            if (!resolved) {
+                const configured = providers.list().map((p) => p.id).join(", ") || "nessuno";
+                throw new Error(`impossibile risolvere il modello "${config.model}". ` +
+                    `Provider configurati: ${configured}. ` +
+                    `Usa la sintassi provider/modello (es. anthropic/claude-sonnet-4-6) ` +
+                    `e imposta la chiave d'ambiente del provider.`);
+            }
+            // Il provider riceve l'id del modello SENZA prefisso provider.
+            const runConfig = { ...config, model: resolved.modelId };
+            return {
+                provider: resolved.provider,
+                tools,
+                session,
+                config: runConfig,
+                confirm,
+                host,
+                env,
+                executionTarget,
+                ...(workspaceSession ? { workspaceSession } : {}),
+                ...(fsRoots.length || env["TALOS_CONFINE_FS"] === "1" ? { fsRoots } : {}),
+            };
+        },
+    };
+    return harness;
+}

package/dist/core/cli-args.d.ts

@@ -0,0 +1,41 @@
+import { type VibeModeSelection } from "./vibe-modes.js";
+export type CliMode = "tui" | "print" | "rpc" | "doctor" | "work";
+export interface ExtensionFlagArg {
+    readonly name: string;
+    readonly value?: string;
+}
+export interface CliArgs {
+    readonly mode: CliMode;
+    readonly model?: string;
+    readonly cwd?: string;
+    readonly addDirs: readonly string[];
+    readonly config?: string;
+    readonly json: boolean;
+    readonly yolo: boolean;
+    readonly prompt?: string;
+    readonly promptTemplates: readonly string[];
+    readonly skills: readonly string[];
+    readonly noSkills: boolean;
+    readonly approve?: boolean;
+    readonly noApprove?: boolean;
+    readonly sessionId?: string;
+    readonly continueLast?: boolean;
+    readonly resumePicker?: boolean;
+    readonly name?: string;
+    readonly excludeTools: readonly string[];
+    readonly vibeMode?: VibeModeSelection;
+    readonly help: boolean;
+    readonly version: boolean;
+    readonly extensionFlags: readonly ExtensionFlagArg[];
+    readonly workList?: boolean;
+    readonly workScope?: string;
+    readonly workVerify?: string;
+    readonly workMax?: number;
+    readonly workMinutes?: number;
+}
+export declare class CliArgumentError extends Error {
+    readonly exitCode = 2;
+    constructor(message: string);
+}
+export declare function parseCliArgs(argv: readonly string[]): CliArgs;
+export declare function cliHelp(): string;