@alisio/core 0.1.0-alpha.9 → 0.1.0

package/dist/changelog/parse.js

@@ -0,0 +1,160 @@
+const ENTRY_HEADING = /^##\s+\[?([^\]\s]+)\]?(?:\s*[-–—·]\s*(\d{4}-\d{2}-\d{2}))?\s*$/;
+const SECTION_HEADING = /^###\s+(.+?)\s*$/;
+const BULLET = /^\s{0,3}[-*]\s+(.*\S)\s*$/;
+const DEFAULT_SECTION = "Changes";
+export const UNRELEASED = "Unreleased";
+export function parseChangelog(markdown) {
+    const entries = [];
+    let entry;
+    let section;
+    let item = -1;
+    const openSection = (title) => {
+        section = { title, items: [] };
+        entry?.sections.push(section);
+        item = -1;
+    };
+    for (const raw of markdown.replace(/\r\n?/g, "\n").split("\n")) {
+        const heading = ENTRY_HEADING.exec(raw);
+        if (heading?.[1]) {
+            const version = heading[1].replace(/^v(?=\d)/, "");
+            const unreleased = version.toLowerCase() === UNRELEASED.toLowerCase();
+            entry = {
+                version: unreleased ? UNRELEASED : version,
+                ...(heading[2] ? { date: heading[2] } : {}),
+                ...(unreleased ? { unreleased: true } : {}),
+                sections: [],
+            };
+            entries.push(entry);
+            section = undefined;
+            item = -1;
+            continue;
+        }
+        if (!entry)
+            continue;
+        const sectionHeading = SECTION_HEADING.exec(raw);
+        if (sectionHeading?.[1]) {
+            openSection(sectionHeading[1]);
+            continue;
+        }
+        const bullet = BULLET.exec(raw);
+        if (bullet?.[1]) {
+            if (!section)
+                openSection(DEFAULT_SECTION);
+            section?.items.push(bullet[1]);
+            item = (section?.items.length ?? 0) - 1;
+            continue;
+        }
+        // A non-blank, indented continuation extends the previous bullet.
+        if (section && item >= 0 && /^\s{2,}\S/.test(raw))
+            section.items[item] = `${section.items[item]} ${raw.trim()}`;
+    }
+    return entries.map((e) => ({ ...e, sections: e.sections.filter((s) => s.items.length) }));
+}
+const VERSION = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+function parseVersion(text) {
+    const match = VERSION.exec(text.trim());
+    if (!match)
+        return undefined;
+    return {
+        core: [Number(match[1]), Number(match[2]), Number(match[3])],
+        pre: match[4] ? match[4].split(".") : [],
+    };
+}
+/** Whether `text` is a semantic version (`1.2.3-alpha.4`, with an optional leading `v`). */
+export const isVersion = (text) => parseVersion(text) !== undefined;
+/**
+ * Semver order with numeric prerelease identifiers (`alpha.9` < `alpha.10`; a release is above its
+ * prereleases). `Unreleased` is above every version; an unparseable text sorts below all of them.
+ */
+export function compareVersions(a, b) {
+    const unreleasedA = a === UNRELEASED, unreleasedB = b === UNRELEASED;
+    if (unreleasedA || unreleasedB)
+        return Number(unreleasedA) - Number(unreleasedB);
+    const left = parseVersion(a), right = parseVersion(b);
+    if (!left || !right)
+        return Math.sign(Number(!!left) - Number(!!right));
+    for (let i = 0; i < 3; i++) {
+        const diff = (left.core[i] ?? 0) - (right.core[i] ?? 0);
+        if (diff)
+            return Math.sign(diff);
+    }
+    if (!left.pre.length || !right.pre.length)
+        return Math.sign(right.pre.length - left.pre.length);
+    for (let i = 0; i < Math.max(left.pre.length, right.pre.length); i++) {
+        const x = left.pre[i], y = right.pre[i];
+        if (x === undefined)
+            return -1;
+        if (y === undefined)
+            return 1;
+        const numeric = /^\d+$/.test(x) && /^\d+$/.test(y);
+        if (numeric) {
+            const diff = Number(x) - Number(y);
+            if (diff)
+                return Math.sign(diff);
+        }
+        else if (/^\d+$/.test(x) !== /^\d+$/.test(y))
+            return /^\d+$/.test(x) ? -1 : 1;
+        else if (x !== y)
+            return x < y ? -1 : 1;
+    }
+    return 0;
+}
+/**
+ * The entries to show: the `limit` newest (default 5), or the one named by `version` (`alpha.4`,
+ * `1.2.3-alpha.4` and `v1.2.3-alpha.4` all match). Entries come back newest first.
+ */
+export function selectEntries(entries, options = {}) {
+    const sorted = [...entries].sort((a, b) => compareVersions(b.version, a.version));
+    const asked = options.version?.trim();
+    if (!asked)
+        return { entries: sorted.slice(0, Math.max(1, options.limit ?? 5)), found: true };
+    const wanted = asked.replace(/^v(?=\d)/, "").toLowerCase();
+    const hit = sorted.find((entry) => entry.version.toLowerCase() === wanted ||
+        entry.version.toLowerCase().endsWith(`-${wanted}`) ||
+        entry.version.toLowerCase().endsWith(`.${wanted}`));
+    return hit ? { entries: [hit], found: true } : { entries: [], found: false };
+}
+/**
+ * Decides the discreet "Alisio updated" line. A first run (no `lastSeen`) stays silent and records;
+ * the same version does nothing; a downgrade or an upgrade without entries records silently;
+ * an upgrade with entries in `(lastSeen, current]` shows. `Unreleased` never counts as news and an
+ * unparseable `current` (a development build) does nothing.
+ */
+export function changelogNews(input) {
+    const { entries, current, lastSeen } = input;
+    const none = { show: false, versions: [], record: false };
+    if (!isVersion(current))
+        return none;
+    if (!lastSeen || !isVersion(lastSeen))
+        return { ...none, record: true };
+    const order = compareVersions(current, lastSeen);
+    if (order === 0)
+        return none;
+    if (order < 0)
+        return { ...none, record: true };
+    const versions = entries
+        .filter((entry) => !entry.unreleased &&
+        compareVersions(entry.version, lastSeen) > 0 &&
+        compareVersions(entry.version, current) <= 0)
+        .map((entry) => entry.version)
+        .sort((a, b) => compareVersions(b, a));
+    return versions.length
+        ? { show: true, versions, latest: versions[0], record: true }
+        : { ...none, record: true };
+}
+/** Markdown for the entries (one `##` heading per version, bold section titles, bullets). */
+export function formatChangelogMarkdown(entries) {
+    if (!entries.length)
+        return "No changelog entries.";
+    return entries
+        .map((entry) => [
+        `## ${entry.version}${entry.date ? ` · ${entry.date}` : ""}${entry.unreleased ? " (not released yet)" : ""}`,
+        ...entry.sections.flatMap((section) => [
+            "",
+            `**${section.title}**`,
+            "",
+            ...section.items.map((item) => `- ${item}`),
+        ]),
+    ].join("\n"))
+        .join("\n\n");
+}

package/dist/commands/builtins.d.ts

@@ -0,0 +1,10 @@
+import type { CommandDescriptor } from "@alisio/sdk";
+/** A built-in slash command: a descriptor without `source`/`owner` (always `builtin`). */
+export type BuiltinCommand = Omit<CommandDescriptor, "source" | "owner">;
+/**
+ * Built-in slash commands, in the order the TUI lists them. Names, aliases, descriptions and
+ * argument hints are the TUI's `COMMANDS` moved here as data (the TUI re-exports them).
+ * `execution: "core"` commands have a handler in `CommandCatalog.execute`; `surface` commands
+ * (clipboard, exit, settings/connect wizards, help, `/ask`) are handled by each UI.
+ */
+export declare const BUILTIN_COMMANDS: readonly BuiltinCommand[];

package/dist/commands/builtins.js

@@ -0,0 +1,161 @@
+const ALL = ["tui", "web", "api"];
+const TUI = ["tui"];
+const INTERACTIVE = ["tui", "web"];
+/**
+ * Built-in slash commands, in the order the TUI lists them. Names, aliases, descriptions and
+ * argument hints are the TUI's `COMMANDS` moved here as data (the TUI re-exports them).
+ * `execution: "core"` commands have a handler in `CommandCatalog.execute`; `surface` commands
+ * (clipboard, exit, settings/connect wizards, help, `/ask`) are handled by each UI.
+ */
+export const BUILTIN_COMMANDS = [
+    {
+        name: "help",
+        description: "Show commands and keys",
+        surfaces: INTERACTIVE,
+        execution: "surface",
+    },
+    {
+        name: "connect",
+        description: "Configure a provider and choose its active model",
+        surfaces: TUI,
+        execution: "surface",
+    },
+    {
+        name: "model",
+        description: "Switch provider and model",
+        aliases: ["models"],
+        surfaces: ALL,
+        execution: "core",
+    },
+    {
+        name: "compact",
+        description: "Summarize older history",
+        argumentHint: "[focus]",
+        surfaces: ALL,
+        execution: "core",
+    },
+    { name: "stats", description: "Session statistics", surfaces: ALL, execution: "core" },
+    {
+        name: "clear",
+        description: "Start a new session",
+        aliases: ["new"],
+        surfaces: ALL,
+        execution: "core",
+    },
+    { name: "sessions", description: "List recent sessions", surfaces: ALL, execution: "core" },
+    {
+        name: "resume",
+        description: "Resume a session by ID or prefix",
+        argumentHint: "<id>",
+        surfaces: ALL,
+        execution: "core",
+    },
+    {
+        name: "tools",
+        description: "List tools and permission state",
+        surfaces: ALL,
+        execution: "core",
+    },
+    {
+        name: "plugins",
+        description: "Browse and manage project plugins",
+        surfaces: ALL,
+        execution: "core",
+    },
+    {
+        name: "skills",
+        description: "Browse and manage effective skills",
+        surfaces: ALL,
+        execution: "core",
+    },
+    { name: "mcps", description: "Browse and manage MCP servers", surfaces: ALL, execution: "core" },
+    {
+        name: "settings",
+        description: "Open the settings menu",
+        aliases: ["prefs"],
+        surfaces: TUI,
+        execution: "surface",
+    },
+    {
+        name: "copy",
+        description: "Copy the last assistant response to the clipboard",
+        surfaces: TUI,
+        execution: "surface",
+    },
+    {
+        name: "agents",
+        description: "List and switch the active agent (applies from the next prompt)",
+        argumentHint: "[<verb>]",
+        surfaces: ALL,
+        execution: "core",
+    },
+    {
+        name: "effort",
+        description: "Set the reasoning effort level for the active model",
+        argumentHint: "[level]",
+        surfaces: ALL,
+        execution: "core",
+    },
+    {
+        name: "ask",
+        description: "Ask the agent to turn your question into a multiple-choice ask_user_question",
+        argumentHint: "<question>",
+        surfaces: INTERACTIVE,
+        execution: "surface",
+    },
+    {
+        name: "btw",
+        description: "Ask a side question about the session without adding to the conversation",
+        argumentHint: "[question]",
+        surfaces: ALL,
+        execution: "core",
+    },
+    {
+        name: "artifacts",
+        description: "Browse this session's artifacts",
+        argumentHint: "[filter]",
+        surfaces: INTERACTIVE,
+        execution: "surface",
+    },
+    {
+        name: "permission",
+        description: "Switch the permission mode (ask, auto, full access), see its status or manage saved permissions",
+        aliases: ["permissions"],
+        argumentHint: "[ask|auto|full|status]",
+        surfaces: INTERACTIVE,
+        execution: "surface",
+    },
+    {
+        name: "reload",
+        description: "Reload the configuration, agents, skills, prompt templates and MCP servers (between turns)",
+        surfaces: INTERACTIVE,
+        execution: "surface",
+    },
+    {
+        name: "changelog",
+        description: "Show what changed in recent Alisio releases",
+        argumentHint: "[version]",
+        surfaces: INTERACTIVE,
+        execution: "surface",
+    },
+    {
+        name: "tasks",
+        description: "Show this session's background tasks (bg_run) with their output, and stop them",
+        surfaces: INTERACTIVE,
+        execution: "surface",
+    },
+    {
+        name: "goal",
+        description: "Start or manage the current Session Goal",
+        argumentHint: "[objective | pause | resume | edit | clear | help | budget=<n>]",
+        surfaces: INTERACTIVE,
+        execution: "surface",
+    },
+    {
+        name: "exit",
+        description: "Exit Alisio",
+        aliases: ["quit"],
+        surfaces: TUI,
+        execution: "surface",
+    },
+];

package/dist/commands/catalog.d.ts

@@ -0,0 +1,86 @@
+/**
+ * One catalog of slash commands for every surface (TUI, web, API): built-ins, plugin commands,
+ * prompt templates and skills, with the pure core handlers of `execution: "core"` commands.
+ * The catalog reads its sources live from the host on each call, so plugin/template/skill
+ * changes show up without rebuilding it.
+ */
+import type { CommandDescriptor, ToolDefinition } from "@alisio/sdk";
+import type { PluginCatalogEntry } from "../application.ts";
+import type { SessionStore } from "../core/contracts.ts";
+import type { AgentRunner } from "../core/runner.ts";
+import type { McpServerInfo } from "../mcp/connector.ts";
+import type { PromptTemplate } from "../resources/prompts.ts";
+import type { SkillCatalogEntry } from "../resources/skills.ts";
+import { type SideQuestions } from "../sessions/side-questions.ts";
+import { BUILTIN_COMMANDS, type BuiltinCommand } from "./builtins.ts";
+export { BUILTIN_COMMANDS, type BuiltinCommand };
+export type CommandSurface = CommandDescriptor["surfaces"][number];
+type PluginCommandHandler = (args: string, context?: {
+    sessionId?: string;
+}) => Promise<string>;
+/**
+ * What the catalog needs from an application. `createApplication()`'s result satisfies it; the
+ * optional members only enable the matching sources and handlers.
+ */
+export interface CommandHost {
+    workspace: string;
+    store: SessionStore;
+    runner: Pick<AgentRunner, "policy" | "approvals" | "compact" | "setModel">;
+    registry: {
+        list(): ToolDefinition[];
+    };
+    provider: {
+        id: string;
+    };
+    plugins?: {
+        commands: ReadonlyMap<string, PluginCommandHandler>;
+        commandInfo: ReadonlyMap<string, {
+            plugin: string;
+            description?: string;
+            argumentHint?: string;
+        }>;
+        pluginState?(plugin: string, key: string): unknown;
+    };
+    prompts?: {
+        templates: ReadonlyMap<string, PromptTemplate>;
+    };
+    skillCatalog?(): SkillCatalogEntry[];
+    pluginCatalog?(): PluginCatalogEntry[];
+    mcp?: {
+        list(): McpServerInfo[];
+    };
+    config?: {
+        agents: {
+            active?: string;
+            effort?: string;
+        };
+    };
+    updateSetting?(key: "agents.effort", value: unknown): Promise<string>;
+    /** `/btw` side questions (tool-less, outside the conversation). */
+    sideQuestions?: Pick<SideQuestions, "ask" | "history">;
+}
+export interface CommandExecutionContext {
+    sessionId: string;
+    signal?: AbortSignal;
+}
+export interface CommandResult {
+    /** Markdown for the user. */
+    text?: string;
+    /** `notice` is a short status line; `info` (default) a report. */
+    tone?: "info" | "notice";
+    /** The session the surface should switch to (`clear`/`new`, `resume`). */
+    sessionId?: string;
+    /** Structured result for programmatic callers (e.g. a `CompactionResult`). */
+    data?: unknown;
+}
+export declare class CommandCatalog {
+    private readonly host?;
+    constructor(host?: CommandHost | undefined);
+    private builtins;
+    /** Every descriptor (optionally for one surface). Precedence: builtin > plugin > prompt > skill. */
+    list(surface?: CommandSurface): CommandDescriptor[];
+    /** A command by name or alias (built-in names and aliases are case-insensitive). */
+    resolve(name: string): CommandDescriptor | undefined;
+    /** Runs an `execution: "core"` command. Surface commands and unknown names throw. */
+    execute(name: string, args: string, ctx: CommandExecutionContext): Promise<CommandResult>;
+}