@alisio/alisio-code 0.1.0-alpha.9 → 0.1.1

package/dist/serve.js

@@ -0,0 +1,99 @@
+/**
+ * `alisio serve`: loaded only by the serve action, and it loads `@alisio/server` only then, so
+ * `alisio`, `alisio run` and the TUI never load the HTTP server (spec §3.4, T-12).
+ */
+import { spawn } from "node:child_process";
+/** The operating system's URL opener for `platform`, as `[command, ...args]`. */
+export function browserCommand(platform, url) {
+    if (platform === "darwin")
+        return ["open", url];
+    if (platform === "win32")
+        return ["cmd", "/c", "start", '""', url];
+    return ["xdg-open", url];
+}
+/** Opens `url` in the default browser; failures are reported, never fatal. */
+export function openBrowser(url) {
+    const [command = "", ...args] = browserCommand(process.platform, url);
+    try {
+        const child = spawn(command, args, { detached: true, stdio: "ignore" });
+        child.on("error", () => process.stderr.write("Could not open a browser; open the URL above manually.\n"));
+        child.unref();
+    }
+    catch {
+        process.stderr.write("Could not open a browser; open the URL above manually.\n");
+    }
+}
+/** Parsed option keys that are not `AppOptions` (serve flags and UI-only globals). */
+const SERVE_ONLY_KEYS = new Set([
+    "port",
+    "host",
+    "allowRemote",
+    "open",
+    "maxWorkspaces",
+    "maxRuns",
+    "json",
+    "quiet",
+    "banner",
+    "tui",
+    "baseUrl",
+    "herdr",
+    "disablePlugin",
+    "addDir",
+    "agents",
+]);
+function positiveInt(value, flag, min = 1) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < min)
+        throw new Error(`${flag} expects an integer >= ${min}, got "${value}"`);
+    return parsed;
+}
+/** Starts the server, prints the launch URL and stops cleanly on SIGINT/SIGTERM. */
+export async function serve(flags, app, version) {
+    const port = positiveInt(flags.port, "--port", 0);
+    if (port > 65_535)
+        throw new Error(`--port expects a value up to 65535, got "${flags.port}"`);
+    const { startServer, isLoopbackHost } = await import("@alisio/server");
+    if (!isLoopbackHost(flags.host) && !flags.allowRemote)
+        throw new Error(`--host ${flags.host} is not a loopback address: add --allow-remote to expose the server on the network (no TLS; prefer an SSH tunnel).`);
+    // Global CLI options minus the serve flags and the UI-only ones: the rest are app options.
+    const { cwd, onEvent: _onEvent, approve: _approve, approveExternalDirectory: _approveDirectory, ...rest } = app;
+    const base = Object.fromEntries(Object.entries(rest).filter(([key]) => !SERVE_ONLY_KEYS.has(key)));
+    let server;
+    try {
+        server = await startServer({
+            host: flags.host,
+            port,
+            allowRemote: !!flags.allowRemote,
+            version,
+            maxOpenWorkspaces: positiveInt(flags.maxWorkspaces, "--max-workspaces"),
+            maxConcurrentRuns: positiveInt(flags.maxRuns, "--max-runs"),
+            defaultWorkspace: cwd ?? process.cwd(),
+            app: base,
+        });
+    }
+    catch (error) {
+        if (error.code === "EADDRINUSE")
+            throw new Error(`Port ${port} is already in use: choose another with --port <n> (0 picks a free one).`);
+        throw error;
+    }
+    process.stdout.write(`Alisio web UI: ${server.launchUrl}\n`);
+    if (!isLoopbackHost(flags.host))
+        process.stderr.write(`Warning: listening on ${flags.host} (--allow-remote). Anyone who can reach this address and obtains the token can drive the agent; traffic is not encrypted.\n`);
+    if (!server.webInstalled)
+        process.stderr.write("The web UI assets are not installed in this build; only the HTTP API is served.\n");
+    process.stderr.write("Press Ctrl+C to stop.\n");
+    if (flags.open)
+        openBrowser(server.launchUrl);
+    let stopping = false;
+    const stop = () => {
+        if (stopping)
+            process.exit(130);
+        stopping = true;
+        process.stderr.write("Stopping Alisio server…\n");
+        // Safety net: shutdown is bounded internally; never hang the terminal.
+        setTimeout(() => process.exit(1), 8_000).unref();
+        void server.close().finally(() => process.exit(0));
+    };
+    process.on("SIGINT", stop);
+    process.on("SIGTERM", stop);
+}

package/dist/tui/agent-manager.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Pure logic of the TUI agent manager (`/agents`): argument parsing, the agent picker rows and
+ * their filter, and the editor form with capability-driven options. Rendering and I/O live in
+ * `app.ts`; agent files go through the core `AgentDefinitionService` shared with the web server.
+ */
+import type { AgentDefinitionInfo, AgentDefinitionInput, AgentDraft, AgentModelCapabilities, AgentReasoningSummary, AgentScope, AgentTemplateInfo } from "@alisio/core";
+import { type ActiveAgent } from "@alisio/core";
+/** Verbs the TUI owns; any other `/agents <verb>` goes to the subagents plugin's command. */
+export type AgentsCommand = {
+    kind: "picker";
+} | {
+    kind: "new";
+    description?: string;
+} | {
+    kind: "templates";
+} | {
+    kind: "manage";
+} | {
+    kind: "edit";
+    id: string;
+    scope?: AgentScope;
+} | {
+    kind: "delete";
+    id: string;
+    scope?: AgentScope;
+} | {
+    kind: "plugin";
+    args: string;
+};
+/**
+ * `/agents` → picker; `/agents new [description]` (assisted when a description is given),
+ * `/agents templates`, `/agents manage`, `/agents edit|delete <id> [project|global]`. Anything
+ * else (`list`, `defs`, `reload`, `open`, `cancel`…) belongs to the subagents plugin.
+ */
+export declare function parseAgentsArgs(args: string): AgentsCommand;
+/** "Project" / "Global" for agent files, "Built-in" / "Plugin" / "User" otherwise. */
+export declare function agentBadge(agent: Pick<ActiveAgent, "source"> & {
+    path?: string;
+}, workspace: string, home: string): string;
+export interface PickerRow {
+    value: string;
+    label: string;
+    description?: string;
+}
+/** Action rows shown above the agents in the `/agents` picker. */
+export declare const AGENT_PICKER_ACTIONS: PickerRow[];
+/** Picker rows: name, badge and markers in the label; description below. */
+export declare function agentPickerRows(agents: Array<ActiveAgent & {
+    path?: string;
+}>, activeId: string, roots: {
+    workspace: string;
+    home: string;
+}): PickerRow[];
+/** Case-insensitive substring match of every query word on the label and description. */
+export declare function filterAgentRows<T extends {
+    label: string;
+    description?: string;
+    value: string;
+}>(rows: ReadonlyArray<T>, query: string): T[];
+/** The editable state of one agent in the TUI editor. */
+export interface AgentForm {
+    scope: AgentScope;
+    /** Set when editing a saved agent. */
+    id?: string;
+    name: string;
+    description: string;
+    instructions: string;
+    model: string;
+    reasoning: {
+        effort?: string;
+        summary?: AgentReasoningSummary;
+    };
+    text: {
+        format?: "text" | "json_object" | "json_schema";
+        verbosity?: "low" | "medium" | "high";
+    };
+}
+export declare function emptyAgentForm(scope: AgentScope, model: string): AgentForm;
+export declare function formFromTemplate(template: AgentTemplateInfo, scope: AgentScope, model: string): AgentForm;
+export declare function formFromDefinition(definition: AgentDefinitionInfo): AgentForm;
+/** Applies a model draft to the form (keeps scope, id and model). */
+export declare function applyDraft(form: AgentForm, draft: AgentDraft): AgentForm;
+/** The API/service body of a form, fitted to the model's capabilities. */
+export declare function formToInput(form: AgentForm, capabilities?: AgentModelCapabilities): AgentDefinitionInput;
+/** Validation errors of a form (empty when it can be saved). */
+export declare function formErrors(form: AgentForm): string[];
+/** One-line editing of multi-line text: newlines shown and typed as `\n`. */
+export declare const encodeMultiline: (text: string) => string;
+export declare const decodeMultiline: (text: string) => string;
+export type AgentField = "scope" | "name" | "description" | "instructions" | "model" | "effort" | "summary" | "verbosity" | "format" | "refine" | "save" | "cancel";
+/**
+ * Editor rows. Settings the model does not support are shown as "not supported by this model"
+ * (their value is ignored on save); `dirty` enables the Save row.
+ */
+export declare function agentEditorRows(form: AgentForm, capabilities: AgentModelCapabilities, options: {
+    creating: boolean;
+    scopes: AgentScope[];
+    dirty: boolean;
+}): Array<PickerRow & {
+    value: AgentField;
+}>;
+/** Choice rows of a select field, honoring the model capabilities. */
+export declare function agentFieldChoices(field: "effort" | "summary" | "verbosity" | "format", capabilities: AgentModelCapabilities): PickerRow[];
+/** Whether a field can be edited for the model (unsupported settings are read-only). */
+export declare function agentFieldSupported(field: "effort" | "summary" | "verbosity", capabilities: AgentModelCapabilities): boolean;

package/dist/tui/agent-manager.js

@@ -0,0 +1,269 @@
+import { AGENT_REASONING_SUMMARIES, AGENT_TEXT_FORMATS, AGENT_VERBOSITIES, DEFAULT_AGENT_ID, fitAgentSettings, validateAgentDefinitionInput, } from "@alisio/core";
+/**
+ * `/agents` → picker; `/agents new [description]` (assisted when a description is given),
+ * `/agents templates`, `/agents manage`, `/agents edit|delete <id> [project|global]`. Anything
+ * else (`list`, `defs`, `reload`, `open`, `cancel`…) belongs to the subagents plugin.
+ */
+export function parseAgentsArgs(args) {
+    const text = args.trim();
+    if (!text)
+        return { kind: "picker" };
+    const [verb = "", ...rest] = text.split(/\s+/);
+    const tail = text.slice(verb.length).trim();
+    const scope = (value) => value === "project" || value === "global" ? value : undefined;
+    switch (verb.toLowerCase()) {
+        case "new":
+        case "create":
+            return tail ? { kind: "new", description: tail } : { kind: "new" };
+        case "templates":
+        case "template":
+            return { kind: "templates" };
+        case "manage":
+            return { kind: "manage" };
+        case "edit":
+        case "delete":
+        case "rm": {
+            const [id, where] = rest;
+            if (!id)
+                return { kind: "manage" };
+            const found = scope(where);
+            return {
+                kind: verb.toLowerCase() === "edit" ? "edit" : "delete",
+                id,
+                ...(found ? { scope: found } : {}),
+            };
+        }
+        default:
+            return { kind: "plugin", args: text };
+    }
+}
+/** "Project" / "Global" for agent files, "Built-in" / "Plugin" / "User" otherwise. */
+export function agentBadge(agent, workspace, home) {
+    if (agent.source === "builtin")
+        return "Built-in";
+    if (agent.source === "plugin")
+        return "Plugin";
+    const path = agent.path ?? "";
+    if (path.startsWith(`${workspace}/`) || path.startsWith(`${workspace}\\`))
+        return "Project";
+    if (path.startsWith(`${home}/`) || path.startsWith(`${home}\\`))
+        return "Global";
+    return "User";
+}
+/** Action rows shown above the agents in the `/agents` picker. */
+export const AGENT_PICKER_ACTIONS = [
+    {
+        value: "__agents:new",
+        label: "+ Create agent…",
+        description: "Blank, from a template or written by Alisio",
+    },
+    {
+        value: "__agents:manage",
+        label: "✎ Manage saved agents…",
+        description: "Edit or delete project and global agents",
+    },
+];
+/** Picker rows: name, badge and markers in the label; description below. */
+export function agentPickerRows(agents, activeId, roots) {
+    return agents.map((agent) => ({
+        value: agent.id,
+        label: [
+            agent.name,
+            `[${agentBadge(agent, roots.workspace, roots.home)}]`,
+            agent.id === activeId ? "(current)" : undefined,
+            agent.id === DEFAULT_AGENT_ID ? "(default)" : undefined,
+            agent.readOnly ? "read-only" : undefined,
+        ]
+            .filter(Boolean)
+            .join(" "),
+        description: [agent.description, agent.model ? `model: ${agent.model}` : undefined]
+            .filter(Boolean)
+            .join(" · "),
+    }));
+}
+/** Case-insensitive substring match of every query word on the label and description. */
+export function filterAgentRows(rows, query) {
+    const words = query.toLowerCase().split(/\s+/).filter(Boolean);
+    if (!words.length)
+        return [...rows];
+    return rows.filter((row) => {
+        const haystack = `${row.value} ${row.label} ${row.description ?? ""}`.toLowerCase();
+        return words.every((word) => haystack.includes(word));
+    });
+}
+export function emptyAgentForm(scope, model) {
+    return {
+        scope,
+        name: "New agent",
+        description: "",
+        instructions: "",
+        model,
+        reasoning: {},
+        text: {},
+    };
+}
+const settingsOf = (source) => ({
+    reasoning: {
+        ...(source.reasoning?.effort ? { effort: source.reasoning.effort } : {}),
+        ...(source.reasoning?.summary ? { summary: source.reasoning.summary } : {}),
+    },
+    text: {
+        ...(source.text?.format?.type ? { format: source.text.format.type } : {}),
+        ...(source.text?.verbosity ? { verbosity: source.text.verbosity } : {}),
+    },
+});
+export function formFromTemplate(template, scope, model) {
+    return {
+        scope,
+        name: template.name,
+        description: template.description,
+        instructions: template.instructions,
+        model,
+        ...settingsOf(template),
+    };
+}
+export function formFromDefinition(definition) {
+    return {
+        scope: definition.scope,
+        id: definition.id,
+        name: definition.name,
+        description: definition.description,
+        instructions: definition.instructions,
+        model: definition.model,
+        ...settingsOf(definition),
+    };
+}
+/** Applies a model draft to the form (keeps scope, id and model). */
+export function applyDraft(form, draft) {
+    return {
+        ...form,
+        name: draft.name,
+        description: draft.description,
+        instructions: draft.instructions,
+        ...settingsOf(draft),
+    };
+}
+/** The API/service body of a form, fitted to the model's capabilities. */
+export function formToInput(form, capabilities) {
+    const input = {
+        name: form.name.trim(),
+        ...(form.description.trim() ? { description: form.description.trim() } : {}),
+        ...(form.instructions.trim() ? { instructions: form.instructions.trim() } : {}),
+        model: form.model.trim(),
+        ...(form.reasoning.effort || form.reasoning.summary
+            ? {
+                reasoning: {
+                    ...(form.reasoning.effort ? { effort: form.reasoning.effort } : {}),
+                    ...(form.reasoning.summary ? { summary: form.reasoning.summary } : {}),
+                },
+            }
+            : {}),
+        ...(form.text.format || form.text.verbosity
+            ? {
+                text: {
+                    ...(form.text.format ? { format: { type: form.text.format } } : {}),
+                    ...(form.text.verbosity ? { verbosity: form.text.verbosity } : {}),
+                },
+            }
+            : {}),
+    };
+    return capabilities ? fitAgentSettings(input, capabilities) : input;
+}
+/** Validation errors of a form (empty when it can be saved). */
+export function formErrors(form) {
+    const result = validateAgentDefinitionInput(formToInput(form));
+    return result.ok ? [] : result.errors.map((e) => e.message);
+}
+/** One-line editing of multi-line text: newlines shown and typed as `\n`. */
+export const encodeMultiline = (text) => text.replace(/\\/g, "\\\\").replace(/\n/g, "\\n");
+export const decodeMultiline = (text) => text.replace(/\\(\\|n)/g, (_, c) => (c === "n" ? "\n" : "\\"));
+const clip = (text, max = 60) => {
+    const line = text.replace(/\s+/g, " ").trim();
+    return line.length > max ? `${line.slice(0, max - 1)}…` : line;
+};
+/**
+ * Editor rows. Settings the model does not support are shown as "not supported by this model"
+ * (their value is ignored on save); `dirty` enables the Save row.
+ */
+export function agentEditorRows(form, capabilities, options) {
+    const unsupported = "not supported by this model";
+    const rows = [];
+    if (options.creating && options.scopes.length > 1)
+        rows.push({
+            value: "scope",
+            label: `Scope: ${form.scope === "project" ? "Project" : "Global"}`,
+            description: "Project: .agents/agents in this workspace · Global: ~/.agents/agents",
+        });
+    rows.push({ value: "name", label: `Name: ${form.name || "(empty)"}` }, {
+        value: "description",
+        label: `Description: ${clip(form.description) || "(derived from instructions)"}`,
+    }, {
+        value: "instructions",
+        label: `Instructions: ${clip(form.instructions) || "(empty)"}`,
+        description: `${form.instructions.length} characters`,
+    }, { value: "model", label: `Model: ${form.model || "(choose one)"}` }, {
+        value: "effort",
+        label: `Reasoning effort: ${capabilities.reasoning ? (form.reasoning.effort ?? "model default") : "—"}`,
+        ...(capabilities.reasoning ? {} : { description: unsupported }),
+    }, {
+        value: "summary",
+        label: `Reasoning summary: ${capabilities.summary ? (form.reasoning.summary ?? "auto") : "—"}`,
+        ...(capabilities.summary ? {} : { description: unsupported }),
+    }, {
+        value: "verbosity",
+        label: `Verbosity: ${capabilities.verbosity ? (form.text.verbosity ?? "default") : "—"}`,
+        ...(capabilities.verbosity ? {} : { description: unsupported }),
+    }, { value: "format", label: `Text format: ${form.text.format ?? "text"}` }, {
+        value: "refine",
+        label: "✦ Refine with Alisio…",
+        description: "The active model rewrites the instructions to the authoring standards",
+    });
+    const errors = formErrors(form);
+    rows.push({
+        value: "save",
+        label: options.dirty && !errors.length
+            ? "✓ Save agent definition"
+            : "✓ Save agent definition (nothing to save)",
+        ...(errors.length
+            ? { description: errors.join("; ") }
+            : options.dirty
+                ? {}
+                : { description: "No unsaved changes" }),
+    });
+    rows.push({ value: "cancel", label: "✗ Close editor" });
+    return rows;
+}
+/** Choice rows of a select field, honoring the model capabilities. */
+export function agentFieldChoices(field, capabilities) {
+    const levels = field === "effort"
+        ? capabilities.effortLevels
+        : field === "summary"
+            ? AGENT_REASONING_SUMMARIES
+            : field === "verbosity"
+                ? AGENT_VERBOSITIES
+                : AGENT_TEXT_FORMATS.filter((format) => capabilities.textFormats.includes(format));
+    return [
+        ...levels.map((value) => ({
+            value,
+            label: field === "format"
+                ? value === "json_object"
+                    ? "JSON"
+                    : value === "json_schema"
+                        ? "JSON Schema"
+                        : "Text"
+                : value,
+            ...(field === "effort" && value === capabilities.defaultEffort
+                ? { description: "model default" }
+                : {}),
+        })),
+        ...(field === "format" ? [] : [{ value: "!clear", label: "(use the default)" }]),
+    ];
+}
+/** Whether a field can be edited for the model (unsupported settings are read-only). */
+export function agentFieldSupported(field, capabilities) {
+    return field === "effort"
+        ? capabilities.reasoning
+        : field === "summary"
+            ? capabilities.summary
+            : capabilities.verbosity;
+}

package/dist/tui/agents.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The ACTIVE (main-session) agent logic lives in `@alisio/core` (`agents/active.ts`) so every
+ * surface (TUI, headless, server) resolves agents the same way. Re-exported for compatibility.
+ */
+export { type ActiveAgent, type AgentPickerItem, activeAgentCatalog, agentCatalogFromState, agentPickerItems, agentRunOptions, BUILTIN_AGENTS, DEFAULT_AGENT_ID, type MainCapableAgentRecord, mainAgentFromRecord, resolveActiveAgent, } from "@alisio/core";

package/dist/tui/agents.js

@@ -0,0 +1,5 @@
+/**
+ * The ACTIVE (main-session) agent logic lives in `@alisio/core` (`agents/active.ts`) so every
+ * surface (TUI, headless, server) resolves agents the same way. Re-exported for compatibility.
+ */
+export { activeAgentCatalog, agentCatalogFromState, agentPickerItems, agentRunOptions, BUILTIN_AGENTS, DEFAULT_AGENT_ID, mainAgentFromRecord, resolveActiveAgent, } from "@alisio/core";

package/dist/tui/app.d.ts

@@ -1,4 +1,45 @@
-import type { AppOptions } from "@alisio/core";
+import { type AppOptions } from "@alisio/core";
+import { type Component, type SelectItem } from "@earendil-works/pi-tui";
+/**
+ * Inline selection list with type-to-filter, rendered above the editor.
+ *
+ * Grouped item builders (pluginCatalogItems) interleave their output with non-selectable
+ * `__group:` header items. Headers stay in the SelectList so they render, scroll and truncate
+ * like rows, but selection is owned here: navigation jumps over headers via skipGroupHeaders
+ * (wrapping both directions), Enter never fires onSelect for a header, and the whole display
+ * sequence is re-derived on every filter keystroke so headers of fully-filtered groups vanish.
+ */
+export declare class Picker implements Component {
+    private title;
+    private readonly onSelectItem;
+    private readonly onCancelPick;
+    private filterable;
+    private detail?;
+    /** Custom filter (default: value prefix, keeping group headers). */
+    private readonly match?;
+    private list;
+    private filter;
+    /** Full item sequence (group headers + rows) before any filtering. */
+    private readonly allItems;
+    /** Display sequence: filtered rows plus the headers of groups that still match. */
+    private items;
+    /** Selection index within `items`; always a real row, never a group header. */
+    private index;
+    /** Picker height target: counted on real rows only, so headers never stretch the list. */
+    private readonly maxVisible;
+    constructor(title: string, items: SelectItem[], onSelectItem: (item: SelectItem) => void, onCancelPick: () => void, filterable?: boolean, detail?: string | undefined, 
+    /** Custom filter (default: value prefix, keeping group headers). */
+    match?: ((items: SelectItem[], filter: string) => SelectItem[]) | undefined);
+    /** Copies items, dimming group-header labels (style helpers stay plain under NO_COLOR). */
+    private static displayItems;
+    /** (Re)builds the SelectList over the filtered display sequence; selection starts on a row. */
+    private resetList;
+    invalidate(): void;
+    /** The currently selected item — always a real row, never a group header. */
+    getSelectedItem(): SelectItem | null;
+    handleInput(data: string): void;
+    render(width: number): string[];
+}
 export interface TuiOptions extends AppOptions {
     session?: string;
     quiet?: boolean;