@alisio/alisio-code 0.1.0-alpha.3

package/dist/tui/panel.js

@@ -0,0 +1,140 @@
+export const CHORD_MS = 800;
+export const initialPanelState = () => ({ focus: "editor", collapsed: new Set() });
+const childrenOf = (nodes, id) => nodes.filter((n) => (n.parentId ?? undefined) === id);
+/** Tree order (parents before children) skipping the descendants of collapsed nodes. */
+export function visibleRows(nodes, collapsed) {
+    const rows = [];
+    const known = new Set(nodes.map((n) => n.id));
+    const visit = (parent, depth) => {
+        for (const node of nodes.filter((n) => parent === undefined ? !n.parentId || !known.has(n.parentId) : n.parentId === parent)) {
+            const kids = childrenOf(nodes, node.id);
+            rows.push({ node, depth, hasChildren: kids.length > 0 });
+            if (!collapsed.has(node.id))
+                visit(node.id, depth + 1);
+        }
+    };
+    visit(undefined, 0);
+    return rows;
+}
+export function descendants(nodes, id) {
+    return childrenOf(nodes, id).flatMap((c) => [c.id, ...descendants(nodes, c.id)]);
+}
+const byId = (nodes, id) => nodes.find((n) => n.id === id);
+export function reducePanel(state, action, nodes) {
+    const done = (next, effect) => ({
+        state: next,
+        ...(effect ? { effect } : {}),
+        handled: true,
+    });
+    const skip = { state, handled: false };
+    const first = visibleRows(nodes, state.collapsed)[0]?.node;
+    const cancelOrConfirm = (id) => {
+        if (!id)
+            return done(state);
+        const count = descendants(nodes, id).length;
+        return count
+            ? done({ ...state, confirm: { id, count } })
+            : done({ ...state, confirm: undefined }, { type: "cancel", id });
+    };
+    const open = (node, base) => node?.sessionId
+        ? done({ ...base, focus: "view", viewing: node.id, selected: node.id, chordUntil: undefined }, {
+            type: "open",
+            sessionId: node.sessionId,
+        })
+        : done(base);
+    if (state.confirm && action.type === "key") {
+        if (action.key === "yes")
+            return done({ ...state, confirm: undefined }, { type: "cancel", id: state.confirm.id });
+        return done({ ...state, confirm: undefined });
+    }
+    if (action.type === "ctrlX") {
+        if (!nodes.length)
+            return skip;
+        const running = nodes.find((n) => n.status === "running") ?? first;
+        return done({
+            ...state,
+            focus: "panel",
+            selected: state.selected && byId(nodes, state.selected) ? state.selected : (running?.id ?? first?.id),
+            chordUntil: action.now + CHORD_MS,
+        });
+    }
+    const key = action.key;
+    if (state.focus === "editor") {
+        if (key === "down" && action.editorEmpty && nodes.length)
+            return done({ ...state, focus: "panel", selected: state.selected ?? first?.id });
+        return skip;
+    }
+    if (state.focus === "panel") {
+        const rows = visibleRows(nodes, state.collapsed);
+        const index = Math.max(0, rows.findIndex((r) => r.node.id === state.selected));
+        const current = rows[index];
+        switch (key) {
+            case "down":
+                if (state.chordUntil && action.now <= state.chordUntil)
+                    return open(first, state);
+                return done({
+                    ...state,
+                    selected: rows[Math.min(rows.length - 1, index + 1)]?.node.id,
+                    chordUntil: undefined,
+                });
+            case "up":
+                return done({
+                    ...state,
+                    selected: rows[Math.max(0, index - 1)]?.node.id,
+                    chordUntil: undefined,
+                });
+            case "right": {
+                if (!current?.hasChildren)
+                    return done(state);
+                if (state.collapsed.has(current.node.id)) {
+                    const collapsed = new Set(state.collapsed);
+                    collapsed.delete(current.node.id);
+                    return done({ ...state, collapsed });
+                }
+                return done({ ...state, selected: childrenOf(nodes, current.node.id)[0]?.id });
+            }
+            case "left": {
+                if (current?.hasChildren && !state.collapsed.has(current.node.id))
+                    return done({ ...state, collapsed: new Set([...state.collapsed, current.node.id]) });
+                const parent = current?.node.parentId;
+                return done(parent && byId(nodes, parent) ? { ...state, selected: parent } : state);
+            }
+            case "enter":
+                return open(current?.node, state);
+            case "escape":
+            case "tab":
+                return done({ ...state, focus: "editor", chordUntil: undefined });
+            case "cancel":
+                return cancelOrConfirm(current?.node.id);
+            default:
+                // Any other key returns focus to the editor and is typed there.
+                return { state: { ...state, focus: "editor", chordUntil: undefined }, handled: false };
+        }
+    }
+    // Read-only child view.
+    const viewing = byId(nodes, state.viewing);
+    const back = () => done({ ...state, focus: "editor", viewing: undefined }, { type: "close-view" });
+    switch (key) {
+        case "escape":
+            return back();
+        case "up": {
+            const parent = byId(nodes, viewing?.parentId);
+            return parent ? open(parent, state) : back();
+        }
+        case "down":
+            return open(childrenOf(nodes, viewing?.id)[0], state);
+        case "left":
+        case "right": {
+            const siblings = childrenOf(nodes, viewing?.parentId);
+            const i = siblings.findIndex((s) => s.id === viewing?.id);
+            if (siblings.length < 2 || i < 0)
+                return done(state);
+            const next = siblings[(i + (key === "right" ? 1 : siblings.length - 1)) % siblings.length];
+            return open(next, state);
+        }
+        case "cancel":
+            return cancelOrConfirm(viewing?.id);
+        default:
+            return done(state);
+    }
+}

package/dist/tui/questions.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Pure, pi-tui-free reducer for the interactive question panel (`ask_user_question` / `/ask`).
+ * Mirrors the `panel.ts` convention: state+action -> {state, effect}, fully unit-testable without
+ * a TTY. Navigation wraps around (matching pi-tui's `SelectList`), never clamps. The question
+ * specs are carried inside the state itself (set once by `initialQuestionState`) so the reducer
+ * and the rendering component both stay self-contained from `state` alone.
+ */
+export interface QuestionOptionSpec {
+    label: string;
+    description?: string;
+    recommended?: boolean;
+}
+export interface QuestionSpec {
+    header: string;
+    question: string;
+    multiSelect?: boolean;
+    options: QuestionOptionSpec[];
+}
+/** One question's recorded answer: which option indices, and whether it was skipped (Esc). */
+export interface QuestionAnswer {
+    skipped: boolean;
+    indices: number[];
+}
+export interface QuestionPanelState {
+    questions: QuestionSpec[];
+    index: number;
+    cursor: number;
+    done: boolean;
+    answers: Array<QuestionAnswer | undefined>;
+    toggled: Set<number>;
+}
+export type QuestionAction = {
+    type: "up";
+} | {
+    type: "down";
+} | {
+    type: "toggle";
+} | {
+    type: "confirm";
+} | {
+    type: "back";
+} | {
+    type: "skip";
+};
+export interface QuestionSubmitEffect {
+    type: "submit";
+    answers: Array<QuestionAnswer | undefined>;
+}
+export interface ReduceResult {
+    state: QuestionPanelState;
+    effect?: QuestionSubmitEffect;
+}
+export declare function initialQuestionState(questions: QuestionSpec[]): QuestionPanelState;
+export declare function reduceQuestions(state: QuestionPanelState, action: QuestionAction): ReduceResult;
+export declare function truncateLabel(text: string, max?: number): string;
+export declare function summarizeAnswers(questions: QuestionSpec[], answers: Array<QuestionAnswer | undefined>): string;

package/dist/tui/questions.js

@@ -0,0 +1,113 @@
+/**
+ * Pure, pi-tui-free reducer for the interactive question panel (`ask_user_question` / `/ask`).
+ * Mirrors the `panel.ts` convention: state+action -> {state, effect}, fully unit-testable without
+ * a TTY. Navigation wraps around (matching pi-tui's `SelectList`), never clamps. The question
+ * specs are carried inside the state itself (set once by `initialQuestionState`) so the reducer
+ * and the rendering component both stay self-contained from `state` alone.
+ */
+const recommendedIndex = (spec) => {
+    const i = spec.options.findIndex((o) => o.recommended);
+    return i >= 0 ? i : 0;
+};
+/**
+ * Cursor/toggled to show when navigating (back/forward) into a question, restoring any prior
+ * answer. A question with no prior answer starts with its recommended (or first) option already
+ * highlighted; for a multi-select question that also means pre-toggled, so confirming without
+ * touching anything records a deliberate choice rather than an accidental empty one. A skipped
+ * prior answer restores to that same untouched default rather than remembering the empty choice.
+ * `initialQuestionState` (the very first question of a fresh batch) intentionally does not
+ * pre-toggle, so an explicit empty multi-select confirm stays distinguishable from skip there too.
+ */
+const restore = (spec, prior) => {
+    if (!prior || prior.skipped)
+        return {
+            cursor: recommendedIndex(spec),
+            toggled: new Set(prior ? [] : [recommendedIndex(spec)]),
+        };
+    return { cursor: prior.indices[0] ?? recommendedIndex(spec), toggled: new Set(prior.indices) };
+};
+export function initialQuestionState(questions) {
+    const first = questions[0];
+    return {
+        questions,
+        index: 0,
+        cursor: first ? recommendedIndex(first) : 0,
+        done: false,
+        answers: questions.map(() => undefined),
+        toggled: new Set(),
+    };
+}
+function advance(state, answer) {
+    const answers = state.answers.slice();
+    answers[state.index] = answer;
+    const nextIndex = state.index + 1;
+    if (nextIndex >= state.questions.length) {
+        const done = { ...state, answers, done: true };
+        return { state: done, effect: { type: "submit", answers } };
+    }
+    const nextSpec = state.questions[nextIndex];
+    const { cursor, toggled } = restore(nextSpec, answers[nextIndex]);
+    return { state: { ...state, index: nextIndex, cursor, toggled, answers, done: false } };
+}
+export function reduceQuestions(state, action) {
+    if (state.done)
+        return { state };
+    const spec = state.questions[state.index];
+    switch (action.type) {
+        case "up": {
+            const cursor = (state.cursor - 1 + spec.options.length) % spec.options.length;
+            return { state: { ...state, cursor } };
+        }
+        case "down": {
+            const cursor = (state.cursor + 1) % spec.options.length;
+            return { state: { ...state, cursor } };
+        }
+        case "toggle": {
+            if (!spec.multiSelect)
+                return { state };
+            const toggled = new Set(state.toggled);
+            if (toggled.has(state.cursor))
+                toggled.delete(state.cursor);
+            else
+                toggled.add(state.cursor);
+            return { state: { ...state, toggled } };
+        }
+        case "confirm": {
+            const indices = spec.multiSelect ? [...state.toggled].sort((a, b) => a - b) : [state.cursor];
+            return advance(state, { skipped: false, indices });
+        }
+        case "skip":
+            return advance(state, { skipped: true, indices: [] });
+        case "back": {
+            if (state.index === 0)
+                return { state };
+            const prevIndex = state.index - 1;
+            const prevSpec = state.questions[prevIndex];
+            const { cursor, toggled } = restore(prevSpec, state.answers[prevIndex]);
+            return { state: { ...state, index: prevIndex, cursor, toggled, done: false } };
+        }
+        default:
+            return { state };
+    }
+}
+export function truncateLabel(text, max = 50) {
+    if (text.length <= max)
+        return text;
+    return `${text.slice(0, Math.max(0, max - 1))}…`;
+}
+export function summarizeAnswers(questions, answers) {
+    const lines = questions.map((spec, index) => {
+        const answer = answers[index];
+        if (!answer || answer.skipped)
+            return `**${spec.header}:** _Skipped_`;
+        if (answer.indices.length === 0)
+            return `**${spec.header}:** _None selected_`;
+        const chosen = answer.indices
+            .map((i) => spec.options[i]?.label ?? "")
+            .filter(Boolean)
+            .map((label) => truncateLabel(label))
+            .join(", ");
+        return `**${spec.header}:** ${chosen}`;
+    });
+    return lines.join("\n");
+}

package/dist/tui/queue.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Single serialized queue for every cross-session interactive prompt the TUI can show: write/
+ * process approvals, `/model`'s plugin-facing `select`, and `ask_user_question`/`/ask`'s question
+ * panel. At most one of these is ever on screen, regardless of how many sessions (root or nested
+ * subagents) are asking. Ordering is plain FIFO by arrival: simple, fair, and starvation-free —
+ * there is no root-over-subagent (or vice versa) priority. Generic and session-agnostic: it only
+ * ever sees an opaque `sessionId`/`label` pair, never anything subagent-specific.
+ *
+ * A job whose `signal` aborts before its turn is withdrawn without ever running: `onWithdrawn` is
+ * called once, in its place, and it never blocks the jobs behind it. A job that is already running
+ * when its own signal aborts is `run`'s own responsibility to unwind (mirroring the existing
+ * `approve`/`request.signal` abort-while-displayed pattern in app.ts) — the queue does not
+ * interrupt a job mid-flight, it only prevents queued jobs from ever starting once withdrawn.
+ */
+export interface QueueAsker {
+    sessionId?: string;
+    label?: string;
+}
+export interface QueueJob<T> extends QueueAsker {
+    signal?: AbortSignal;
+    run: () => Promise<T>;
+    /** Called exactly once, instead of `run`, when withdrawn (aborted) before its turn arrives. */
+    onWithdrawn: () => T;
+}
+export declare class InteractiveQueue {
+    private queue;
+    private active;
+    submit<T>(job: QueueJob<T>): Promise<T>;
+    private advance;
+    /** The currently running job's asker, if any. */
+    current(): QueueAsker | undefined;
+    isQueued(sessionId: string): boolean;
+    /** Currently displayed OR waiting behind another prompt — both count as "waiting on the user". */
+    isWaiting(sessionId: string): boolean;
+}

package/dist/tui/queue.js

@@ -0,0 +1,79 @@
+/**
+ * Single serialized queue for every cross-session interactive prompt the TUI can show: write/
+ * process approvals, `/model`'s plugin-facing `select`, and `ask_user_question`/`/ask`'s question
+ * panel. At most one of these is ever on screen, regardless of how many sessions (root or nested
+ * subagents) are asking. Ordering is plain FIFO by arrival: simple, fair, and starvation-free —
+ * there is no root-over-subagent (or vice versa) priority. Generic and session-agnostic: it only
+ * ever sees an opaque `sessionId`/`label` pair, never anything subagent-specific.
+ *
+ * A job whose `signal` aborts before its turn is withdrawn without ever running: `onWithdrawn` is
+ * called once, in its place, and it never blocks the jobs behind it. A job that is already running
+ * when its own signal aborts is `run`'s own responsibility to unwind (mirroring the existing
+ * `approve`/`request.signal` abort-while-displayed pattern in app.ts) — the queue does not
+ * interrupt a job mid-flight, it only prevents queued jobs from ever starting once withdrawn.
+ */
+export class InteractiveQueue {
+    queue = [];
+    active;
+    submit(job) {
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const asker = { sessionId: job.sessionId, label: job.label };
+            const entry = {
+                asker,
+                start: () => {
+                    settled = true;
+                    this.active = asker;
+                    // Clear `active` and advance BEFORE settling the caller's promise, so a caller awaiting
+                    // this job never observes a stale `current()`/`isWaiting()` in the same microtask.
+                    job.run().then((value) => {
+                        this.active = undefined;
+                        this.advance();
+                        resolve(value);
+                    }, (error) => {
+                        this.active = undefined;
+                        this.advance();
+                        reject(error);
+                    });
+                },
+            };
+            const withdraw = () => {
+                if (settled)
+                    return;
+                settled = true;
+                const i = this.queue.indexOf(entry);
+                if (i >= 0)
+                    this.queue.splice(i, 1);
+                resolve(job.onWithdrawn());
+            };
+            if (job.signal) {
+                if (job.signal.aborted) {
+                    withdraw();
+                    return;
+                }
+                job.signal.addEventListener("abort", withdraw, { once: true });
+            }
+            this.queue.push(entry);
+            this.advance();
+        });
+    }
+    advance() {
+        if (this.active)
+            return;
+        const next = this.queue.shift();
+        if (!next)
+            return;
+        next.start();
+    }
+    /** The currently running job's asker, if any. */
+    current() {
+        return this.active ? { ...this.active } : undefined;
+    }
+    isQueued(sessionId) {
+        return this.queue.some((e) => e.asker.sessionId === sessionId);
+    }
+    /** Currently displayed OR waiting behind another prompt — both count as "waiting on the user". */
+    isWaiting(sessionId) {
+        return this.active?.sessionId === sessionId || this.isQueued(sessionId);
+    }
+}

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

@@ -0,0 +1,67 @@
+import type { Component } from "@earendil-works/pi-tui";
+export type SkillSort = "name" | "source" | "tokens";
+export interface SkillCatalogView {
+    id: string;
+    effectiveId: string;
+    displayId: string;
+    name: string;
+    description: string;
+    scope: "project" | "config" | "user" | "plugin";
+    source: string;
+    owner?: {
+        id: string;
+        name: string;
+    };
+    manageable: boolean;
+    locked: boolean;
+    enabled: boolean;
+    effective: boolean;
+    shadowedBy?: string;
+    approximateTokens: number;
+}
+export interface SkillManagerState {
+    query: string;
+    searching: boolean;
+    sort: SkillSort;
+    selectedId?: string;
+    offset: number;
+}
+export interface SkillViewport {
+    items: SkillCatalogView[];
+    selected: number;
+    offset: number;
+    above: number;
+    below: number;
+}
+export declare const initialSkillManagerState: (entries: SkillCatalogView[]) => SkillManagerState;
+export declare function visibleSkills(entries: SkillCatalogView[], state: SkillManagerState): SkillCatalogView[];
+export declare function retainSkillSelection(entries: SkillCatalogView[], state: SkillManagerState): SkillManagerState;
+export declare function skillViewport(entries: SkillCatalogView[], state: SkillManagerState, capacity: number): SkillViewport;
+export declare const cycleSkillSort: (sort: SkillSort) => SkillSort;
+export declare function moveSkillSelection(entries: SkillCatalogView[], state: SkillManagerState, move: "up" | "down" | "pageUp" | "pageDown" | "home" | "end", capacity: number): SkillManagerState;
+export declare class SkillsManager implements Component {
+    private entries;
+    private state;
+    private width;
+    private height;
+    private pending;
+    constructor(options: {
+        entries: SkillCatalogView[];
+        height: () => number;
+        onClose: () => void;
+        onToggle: (id: string, enabled: boolean) => Promise<SkillCatalogView>;
+        onError: (error: unknown) => void;
+        onChanged: (message: string) => void;
+        requestRender: () => void;
+    });
+    private onClose;
+    private onToggle;
+    private onError;
+    private onChanged;
+    private requestRender;
+    invalidate(): void;
+    private capacity;
+    private selected;
+    handleInput(data: string): void;
+    render(width: number): string[];
+}