@alisio/alisio-code 0.1.0-alpha.10

package/dist/tui/skills-manager.js

@@ -0,0 +1,200 @@
+import { Key, matchesKey, truncateToWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { style } from "./theme.js";
+export const initialSkillManagerState = (entries) => ({
+    query: "",
+    searching: false,
+    sort: "name",
+    selectedId: entries[0]?.id,
+    offset: 0,
+});
+export function visibleSkills(entries, state) {
+    const query = state.query.trim().toLowerCase();
+    const filtered = query
+        ? entries.filter((entry) => `${entry.displayId} ${entry.description} ${entry.scope} ${entry.source} ${entry.owner?.name ?? ""}`
+            .toLowerCase()
+            .includes(query))
+        : [...entries];
+    const byName = (a, b) => a.displayId.localeCompare(b.displayId);
+    filtered.sort((a, b) => {
+        if (state.sort === "source")
+            return a.source.localeCompare(b.source) || a.scope.localeCompare(b.scope) || byName(a, b);
+        if (state.sort === "tokens")
+            return b.approximateTokens - a.approximateTokens || byName(a, b);
+        return byName(a, b);
+    });
+    return filtered;
+}
+export function retainSkillSelection(entries, state) {
+    const visible = visibleSkills(entries, state);
+    if (visible.some((entry) => entry.id === state.selectedId))
+        return state;
+    return { ...state, selectedId: visible[0]?.id, offset: 0 };
+}
+export function skillViewport(entries, state, capacity) {
+    const visible = visibleSkills(entries, state);
+    const selected = Math.max(0, visible.findIndex((entry) => entry.id === state.selectedId));
+    const size = Math.max(1, capacity);
+    let offset = Math.max(0, Math.min(state.offset, Math.max(0, visible.length - size)));
+    if (selected < offset)
+        offset = selected;
+    else if (selected >= offset + size)
+        offset = selected - size + 1;
+    const items = visible.slice(offset, offset + size);
+    return {
+        items,
+        selected,
+        offset,
+        above: offset,
+        below: Math.max(0, visible.length - offset - items.length),
+    };
+}
+const SORTS = ["name", "source", "tokens"];
+export const cycleSkillSort = (sort) => SORTS[(SORTS.indexOf(sort) + 1) % SORTS.length] ?? "name";
+export function moveSkillSelection(entries, state, move, capacity) {
+    const visible = visibleSkills(entries, state);
+    if (!visible.length)
+        return { ...state, selectedId: undefined, offset: 0 };
+    const current = Math.max(0, visible.findIndex((entry) => entry.id === state.selectedId));
+    const delta = Math.max(1, capacity - 1);
+    const next = move === "home"
+        ? 0
+        : move === "end"
+            ? visible.length - 1
+            : Math.max(0, Math.min(visible.length - 1, current +
+                (move === "up" ? -1 : move === "down" ? 1 : move === "pageUp" ? -delta : delta)));
+    return { ...state, selectedId: visible[next]?.id };
+}
+const sourceLabel = (entry) => entry.locked ? "locked by plugin · plugin" : entry.scope === "config" ? "config" : entry.scope;
+const marker = (entry) => (!entry.effective ? "↳" : entry.enabled ? "✔" : "○");
+export class SkillsManager {
+    entries;
+    state;
+    width = 80;
+    height;
+    pending = false;
+    constructor(options) {
+        this.entries = options.entries;
+        this.state = initialSkillManagerState(this.entries);
+        this.height = options.height;
+        this.onClose = options.onClose;
+        this.onToggle = options.onToggle;
+        this.onError = options.onError;
+        this.onChanged = options.onChanged;
+        this.requestRender = options.requestRender;
+    }
+    onClose;
+    onToggle;
+    onError;
+    onChanged;
+    requestRender;
+    invalidate() { }
+    capacity() {
+        return Math.max(1, this.height() - 12);
+    }
+    selected() {
+        return visibleSkills(this.entries, this.state).find((entry) => entry.id === this.state.selectedId);
+    }
+    handleInput(data) {
+        if (matchesKey(data, Key.escape))
+            return this.onClose();
+        if (this.state.searching) {
+            if (matchesKey(data, Key.backspace))
+                this.state.query = this.state.query.slice(0, -1);
+            else if (matchesKey(data, Key.enter))
+                this.state.searching = false;
+            else if (data.length === 1 && data >= " " && data <= "~")
+                this.state.query += data;
+            this.state = retainSkillSelection(this.entries, this.state);
+            this.requestRender();
+            return;
+        }
+        const capacity = this.capacity();
+        let move;
+        if (matchesKey(data, Key.up) || /^\x1b\[<64;/.test(data))
+            move = "up";
+        else if (matchesKey(data, Key.down) || /^\x1b\[<65;/.test(data))
+            move = "down";
+        else if (data === "\x1b[5~")
+            move = "pageUp";
+        else if (data === "\x1b[6~")
+            move = "pageDown";
+        else if (["\x1b[H", "\x1b[1~"].includes(data))
+            move = "home";
+        else if (["\x1b[F", "\x1b[4~"].includes(data))
+            move = "end";
+        if (move)
+            this.state = moveSkillSelection(this.entries, this.state, move, capacity);
+        else if (data === "/")
+            this.state = { ...this.state, searching: true };
+        else if (data === "t") {
+            this.state = retainSkillSelection(this.entries, {
+                ...this.state,
+                sort: cycleSkillSort(this.state.sort),
+                offset: 0,
+            });
+        }
+        else if ((matchesKey(data, Key.enter) || data === " ") && !this.pending) {
+            const selected = this.selected();
+            if (selected?.manageable && !selected.locked && selected.effective) {
+                this.pending = true;
+                void this.onToggle(selected.id, !selected.enabled)
+                    .then((updated) => {
+                    this.entries = this.entries.map((entry) => (entry.id === updated.id ? updated : entry));
+                    this.onChanged(`${updated.displayId}: ${updated.enabled ? "enabled" : "disabled"}.`);
+                })
+                    .catch(this.onError)
+                    .finally(() => {
+                    this.pending = false;
+                    this.requestRender();
+                });
+            }
+        }
+        this.requestRender();
+    }
+    render(width) {
+        this.width = width;
+        const state = retainSkillSelection(this.entries, this.state);
+        this.state = state;
+        const viewport = skillViewport(this.entries, state, this.capacity());
+        this.state.offset = viewport.offset;
+        const all = visibleSkills(this.entries, state);
+        const selected = this.selected();
+        const fit = (line) => truncateToWidth(line, Math.max(1, width));
+        const lines = [
+            fit(style.bold(style.yellow("Skills"))),
+            fit(style.dim(`${all.length}/${this.entries.length} · sort: ${state.sort} · enter/space to cycle, / to search, t to sort, Esc to close`)),
+            fit(state.searching || state.query
+                ? `Search: ${state.query}${state.searching ? "▏" : ""}`
+                : "Search: —"),
+        ];
+        if (viewport.above)
+            lines.push(fit(style.dim(`↑ ${viewport.above} more above`)));
+        for (const entry of viewport.items) {
+            const active = entry.id === state.selectedId;
+            const text = `${marker(entry)} ${entry.displayId}   ${sourceLabel(entry)} · ~${entry.approximateTokens} tok`;
+            lines.push(fit(active ? `\x1b[7m${text}\x1b[27m` : text));
+        }
+        if (viewport.below)
+            lines.push(fit(style.dim(`↓ ${viewport.below} more below`)));
+        if (!viewport.items.length)
+            lines.push(fit(style.dim("No skills match this search.")));
+        if (selected) {
+            const status = !selected.effective
+                ? `shadowed by ${selected.shadowedBy ?? "a higher-precedence skill"}`
+                : selected.enabled
+                    ? "effective · enabled"
+                    : "effective · disabled";
+            const action = selected.locked
+                ? `Locked by plugin ${selected.owner?.name ?? selected.owner?.id ?? "owner"}; use /plugins to manage it.`
+                : selected.effective
+                    ? `${this.pending ? "Saving…" : "Enter/Space"} ${selected.enabled ? "disables" : "enables"} this skill for this project.`
+                    : "This lower-precedence copy cannot be toggled independently.";
+            lines.push(fit(style.bold(selected.displayId)));
+            lines.push(...wrapTextWithAnsi(selected.description, Math.max(1, width)).slice(0, 2).map(fit));
+            lines.push(fit(style.dim(`Source: ${sourceLabel(selected)} · Scope: ${selected.scope} · ~${selected.approximateTokens} tokens`)));
+            lines.push(fit(style.dim(`Status: ${status}`)));
+            lines.push(fit(style.dim(action)));
+        }
+        return lines.slice(0, Math.max(4, this.height()));
+    }
+}

package/dist/tui/state.d.ts

@@ -0,0 +1,199 @@
+/**
+ * Pure presentation logic for the TUI: formatting, command parsing and the reduction of
+ * versioned runner events into a view model. No terminal or pi-tui imports here.
+ */
+import type { Message, ModelInfo, RunEvent } from "@alisio/sdk";
+export type Level = "ok" | "warn" | "danger";
+export declare function formatTokens(n: number): string;
+/** Prefixes every model with its owning provider so identical model ids are never ambiguous. */
+export declare function providerModelItems(provider: string, models: ModelInfo[], current?: string): {
+    value: string;
+    label: string;
+    description?: string | undefined;
+}[];
+export interface ProviderCatalogView {
+    profile: string;
+    provider: string;
+    title: string;
+    configuredModel: string;
+    models: ModelInfo[];
+    unavailable: boolean;
+}
+export interface ConfiguredProviderModelItem {
+    value: string;
+    label: string;
+    description: string;
+    unavailable: boolean;
+}
+export interface PluginCatalogView {
+    id: string;
+    name: string;
+    description: string;
+    categories: string[];
+    builtin: boolean;
+    source: string;
+    status: "active" | "inactive" | "failed" | "restart-required";
+    enabled: boolean;
+    manageable: boolean;
+    diagnostic?: string;
+}
+/** Text markers remain meaningful without color: [x] active, [ ] inactive, [!] failed, [*] pending. */
+/** Group headings are derived from the primary category (or "General") of each plugin. */
+export declare function pluginCatalogItems(entries: PluginCatalogView[]): {
+    value: string;
+    label: string;
+    description: string;
+}[];
+export declare const pluginToggleNeedsConfirmation: (entry: PluginCatalogView) => boolean;
+export interface McpServerView {
+    name: string;
+    displayName: string;
+    source: {
+        kind: "global" | "project" | "explicit" | "builtin" | "plugin";
+    };
+    status: "disabled" | "disconnected" | "connecting" | "connected" | "failed" | "needs-authentication" | "restart-required";
+    enabled: boolean;
+    runtimePermission: "granted" | "not-granted" | "read-only";
+    counts: {
+        tools: number;
+    };
+}
+/** Group headings are generated only for sources that actually registered servers. */
+export declare function mcpServerItems(entries: McpServerView[]): {
+    value: string;
+    label: string;
+    description: string;
+}[];
+export interface McpToolView {
+    name: string;
+    effectiveName?: string;
+    title?: string;
+    description?: string;
+    annotations?: {
+        readOnly?: boolean;
+        destructive?: boolean;
+        openWorld?: boolean;
+    };
+}
+export declare function mcpToolItems(tools: McpToolView[]): {
+    value: string;
+    label: string;
+    description: string;
+}[];
+/** Builds one filterable list while retaining provider/profile ownership in each opaque value. */
+export declare function configuredProviderModelItems(catalogs: ProviderCatalogView[], current?: {
+    provider: string;
+    model: string;
+}): ConfiguredProviderModelItem[];
+export declare function contextLevel(pct: number, compactionAt?: number): Level;
+export declare function contextPercent(used: number, total: number | undefined): number | undefined;
+/** The effective total the context bar measures against, and what it is derived from. */
+export interface ContextBudget {
+    /** Effective total in tokens: the model's context window, or absent when it is unknown. */
+    total?: number;
+    /** Basis of the total: the model's context window, or unknown (no fabricated total). */
+    basis: "window" | "unknown";
+    /** Percentage of `total` at which the engine auto-compacts; the bar turns red there. */
+    compactionAt: number;
+}
+export declare function formatContext(used: number, total: number | undefined, estimated: boolean, basis?: "window" | "unknown"): string;
+export declare function formatDuration(ms: number): string;
+export declare const textWidth: (text: string) => number;
+export declare function truncatePlain(text: string, width: number): string;
+export declare function shortenPath(path: string, home: string, max?: number): string;
+/** Host (and port) only: never path, query, user info or credentials. */
+export declare function hostOf(baseURL: string): string;
+export declare const shortId: (id: string) => string;
+export interface Segment {
+    text: string;
+    priority: number;
+}
+/** Keeps segments in order, dropping the lowest priority ones until the line fits. */
+export declare function fitSegments<T extends Segment>(segments: T[], width: number, separator: string): T[];
+export interface CommandSpec {
+    name: string;
+    description: string;
+    argumentHint?: string;
+    aliases?: string[];
+}
+export declare const COMMANDS: CommandSpec[];
+/** Every TUI slash name (commands, aliases and routing prefixes); templates cannot take them. */
+export declare function reservedCommandNames(): string[];
+export declare function resolveCommand(name: string): string | undefined;
+export declare function parseCommand(input: string): {
+    name: string;
+    args: string;
+} | undefined;
+export declare function summarizeToolArgs(name: string, args: string): string;
+export interface DiffLine {
+    sign: "+" | "-";
+    text: string;
+}
+export interface EditSummary {
+    path: string;
+    added: number;
+    removed: number;
+    lines: DiffLine[];
+}
+export declare function editSummary(name: string, args: string): EditSummary | undefined;
+export type ToolStatus = "running" | "approval" | "ok" | "error";
+export type TranscriptItem = {
+    kind: "user";
+    text: string;
+} | {
+    kind: "assistant";
+    text: string;
+    reasoning: string;
+    done: boolean;
+} | {
+    kind: "tool";
+    id: string;
+    name: string;
+    args: string;
+    summary: string;
+    status: ToolStatus;
+    durationMs?: number;
+    preview?: string;
+} | {
+    kind: "notice";
+    text: string;
+} | {
+    kind: "info";
+    text: string;
+} | {
+    kind: "error";
+    text: string;
+};
+export interface Stats {
+    input: number;
+    output: number;
+    cached: number;
+    turns: number;
+    runs: number;
+    tools: Record<string, {
+        calls: number;
+        errors: number;
+    }>;
+    models: string[];
+    lastRunMs?: number;
+    startedAt: number;
+}
+export interface ViewState {
+    items: TranscriptItem[];
+    streaming: boolean;
+    compacting: boolean;
+    model: string;
+    /** Context size in tokens: provider-reported, or estimated (`~`). */
+    context?: {
+        used: number;
+        estimated: boolean;
+    };
+    runStartedAt?: number;
+    stats: Stats;
+}
+export declare function initialViewState(model: string, now?: number): ViewState;
+export declare function addItem(state: ViewState, item: TranscriptItem): ViewState;
+export declare function reduceEvent(state: ViewState, event: RunEvent): ViewState;
+export declare function lastAssistantText(items: TranscriptItem[]): string | undefined;
+/** Rebuilds transcript items from persisted history (used by /resume). */
+export declare function itemsFromHistory(messages: Message[]): TranscriptItem[];