@alisio/alisio-code 0.1.0-alpha.21 → 0.1.0-alpha.22

package/dist/main.js

@@ -200,7 +200,7 @@ async function run(cmd, prompt, sessionId) {
                 process.stderr.write(`[startup] ${JSON.stringify(d)}\n`);
         }
         if (!opts.quiet)
-            console.log("Alisio · /exit /new /skill:name /command plugin.id:name args");
+            console.log("Alisio · /exit /new /btw question /skill:name /command plugin.id:name args");
         process.stdout.write("\nalisio › ");
         try {
             for await (const rawLine of rl) {
@@ -217,6 +217,22 @@ async function run(cmd, prompt, sessionId) {
                     process.stdout.write("\nalisio › ");
                     continue;
                 }
+                if (line === "/btw" || line.startsWith("/btw ")) {
+                    // Side question: printed here only, never added to the conversation.
+                    try {
+                        const { CommandCatalog } = await import("@alisio/core");
+                        const result = await new CommandCatalog(app).execute("btw", line.slice(4), {
+                            sessionId: session,
+                            signal: controller.signal,
+                        });
+                        console.log(result.text ?? "");
+                    }
+                    catch (e) {
+                        console.error(e instanceof Error ? e.message : String(e));
+                    }
+                    process.stdout.write("\nalisio › ");
+                    continue;
+                }
                 if (line.startsWith("/command ")) {
                     const [name, ...args] = line.slice(9).split(" ");
                     const handler = app.plugins.commands.get(name ?? "");

package/dist/tui/app.js

@@ -3,8 +3,9 @@ import { CombinedAutocompleteProvider, Container, Editor, getImageDimensions, ge
 import { loadVersion } from "../version.js";
 import { activeAgentCatalog, agentPickerItems, agentRunOptions, mainAgentFromRecord, resolveActiveAgent, } from "./agents.js";
 import { MAX_ATTACHMENTS_PER_MESSAGE, MAX_IMAGE_BYTES, pasteImageFromClipboard, removeLastAttachment, toApiAttachment, } from "./attachments.js";
+import { BTW_DESCRIPTION, BTW_USAGE, btwBrowser, btwPending } from "./btw.js";
 import { copyText, nodeSpawn } from "./clipboard.js";
-import { AttachmentsBar, BannerBlock, ContentInset, clock, contentInnerWidth, Footer, Header, QuestionPanel, Switch, TranscriptSync, TreePanel, } from "./components.js";
+import { AttachmentsBar, BannerBlock, BtwPanel, ContentInset, clock, contentInnerWidth, Footer, Header, QuestionPanel, Switch, TranscriptSync, TreePanel, } from "./components.js";
 import { ConnectInputPrompt } from "./connect-input.js";
 import { bounded, EXIT_PENDING_CAP_MS, EXIT_SESSION_END_CAP_MS } from "./exit.js";
 import { BRANCH_REFRESH_MS, createBranchCache } from "./git-branch.js";
@@ -1440,6 +1441,57 @@ export async function runTui(options) {
         "**Keys**: Enter send · Shift+Enter / Alt+Enter / Ctrl+J newline · Tab complete · ↑↓ history · Esc interrupt · Ctrl+C clear input (twice to exit) · Ctrl+D exit on empty input · c / y copy last response (empty input) · x expand/collapse latest thought/tool batch/output (empty input) · click a collapsible header row to toggle it · PgUp/PgDn or mouse wheel scroll · Ctrl+X agent panel · Ctrl+B background running agents",
         `**Paste**: multi-line text pastes as one block automatically · Ctrl+V attach a clipboard image (PNG/JPEG/GIF/WebP, up to ${(MAX_IMAGE_BYTES / (1024 * 1024)).toFixed(0)} MB, up to ${MAX_ATTACHMENTS_PER_MESSAGE} per message) · Ctrl+R remove the last attached image`,
     ].join("\n");
+    // `/btw` side questions: answered in the picker slot, never appended to the transcript. One
+    // question is in flight at a time; Esc cancels it (independent of the run's controller, so a
+    // side question also works, and is cancelled on its own, while a turn is running).
+    let btwController;
+    let btwPanel;
+    const btwHeight = () => Math.max(4, Math.floor((process.stdout.rows ?? 30) / 2) - 6);
+    const closeBtw = () => {
+        btwController?.abort(new Error("Cancelled"));
+        btwController = undefined;
+        if (btwPanel && picker === btwPanel)
+            closePicker();
+        btwPanel = undefined;
+    };
+    const sideQuestion = async (question) => {
+        const asked = session;
+        const entries = app.sideQuestions.history(asked);
+        if (!question) {
+            const state = btwBrowser(entries);
+            if (!state)
+                return notice(`${BTW_USAGE}\n${BTW_DESCRIPTION}`);
+            btwPanel = new BtwPanel(state, closeBtw, btwHeight);
+            return showPicker(btwPanel);
+        }
+        btwController?.abort(new Error("Cancelled"));
+        const controller = new AbortController();
+        btwController = controller;
+        const panel = new BtwPanel(btwPending(entries, question), closeBtw, btwHeight);
+        btwPanel = panel;
+        showPicker(panel);
+        try {
+            await app.sideQuestions.ask(asked, question, { signal: controller.signal });
+            if (controller.signal.aborted)
+                return;
+            panel.dispatch({ type: "answered", entries: app.sideQuestions.history(asked) });
+            // An approval may have taken the slot meanwhile: the answer is in the history anyway.
+            if (picker !== panel)
+                flashHint("Side answer ready: /btw to view it", 4000);
+        }
+        catch (e) {
+            if (controller.signal.aborted)
+                return;
+            panel.dispatch({ type: "failed", message: e instanceof Error ? e.message : String(e) });
+            if (picker !== panel)
+                error(e);
+        }
+        finally {
+            if (btwController === controller)
+                btwController = undefined;
+            tui.requestRender();
+        }
+    };
     const commandCatalog = new CommandCatalog(app);
     const mutating = new Set([
         "connect",
@@ -1521,6 +1573,8 @@ export async function runTui(options) {
                     tui.flash(message);
                     return result.ok ? undefined : notice(message);
                 }
+                case "btw":
+                    return await sideQuestion(parsed.args);
                 case "ask": {
                     if (!parsed.args)
                         return notice("Usage: /ask <question>");
@@ -1834,6 +1888,7 @@ export async function runTui(options) {
     const ticker = setInterval(() => {
         clock.now = Date.now();
         if (busy ||
+            btwPanel?.pending ||
             view.items.some((i) => i.kind === "tool" && i.status === "running") ||
             panelNodes().some((n) => n.status === "running")) {
             clock.frame++;

package/dist/tui/btw.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Pure state of the TUI `/btw` panel: a pending side question, its answer, and browsing earlier
+ * answers of the session. The panel lives in the picker slot and never touches the transcript.
+ *
+ * Keys: ←/→ earlier/later answer, ↑/↓ (and PgUp/PgDn) scroll a long answer, Esc cancels a pending
+ * question or closes the panel.
+ */
+import type { SideQuestionEntry } from "@alisio/sdk";
+export declare const BTW_USAGE = "Usage: /btw <question>";
+export declare const BTW_DESCRIPTION = "Ask a side question about the current session without adding to the conversation.";
+export interface BtwState {
+    entries: SideQuestionEntry[];
+    /** Index of the entry on screen (ignored while `pending`). */
+    index: number;
+    /** A question waiting for its answer. */
+    pending?: {
+        question: string;
+        startedAt: number;
+    };
+    /** Why the last question failed (shown until the user navigates). */
+    error?: {
+        question: string;
+        message: string;
+    };
+    /** First answer line on screen. */
+    scroll: number;
+}
+export type BtwAction = {
+    type: "prev";
+} | {
+    type: "next";
+} | {
+    type: "scroll";
+    lines: number;
+} | {
+    type: "answered";
+    entries: SideQuestionEntry[];
+} | {
+    type: "failed";
+    message: string;
+};
+/** The browser for `/btw` without a question: the newest entry, or undefined when none. */
+export declare function btwBrowser(entries: SideQuestionEntry[]): BtwState | undefined;
+/** The panel while `question` is being answered (earlier entries stay browsable afterwards). */
+export declare function btwPending(entries: SideQuestionEntry[], question: string, now?: number): BtwState;
+export declare function reduceBtw(state: BtwState, action: BtwAction): BtwState;
+/** The entry on screen, if the panel is not pending or showing an error. */
+export declare function btwCurrent(state: BtwState): SideQuestionEntry | undefined;
+/** "2/5" for the entry on screen; empty while pending or on an error. */
+export declare function btwPosition(state: BtwState): string;
+/** Footer hints for the current state. */
+export declare function btwHints(state: BtwState, overflow: boolean): string;
+/** "model · 12 in · 3 out tokens" for an entry. */
+export declare function btwUsageLine(entry: SideQuestionEntry): string;
+/** The visible slice of `lines` for `scroll` (clamped) and whether more lines exist. */
+export declare function btwWindow(lines: string[], scroll: number, height: number): {
+    lines: string[];
+    scroll: number;
+    above: boolean;
+    below: boolean;
+};

package/dist/tui/btw.js

@@ -0,0 +1,84 @@
+export const BTW_USAGE = "Usage: /btw <question>";
+export const BTW_DESCRIPTION = "Ask a side question about the current session without adding to the conversation.";
+/** The browser for `/btw` without a question: the newest entry, or undefined when none. */
+export function btwBrowser(entries) {
+    return entries.length ? { entries, index: entries.length - 1, scroll: 0 } : undefined;
+}
+/** The panel while `question` is being answered (earlier entries stay browsable afterwards). */
+export function btwPending(entries, question, now = Date.now()) {
+    return {
+        entries,
+        index: Math.max(0, entries.length - 1),
+        pending: { question, startedAt: now },
+        scroll: 0,
+    };
+}
+export function reduceBtw(state, action) {
+    switch (action.type) {
+        case "prev":
+        case "next": {
+            if (state.pending || !state.entries.length)
+                return state;
+            const step = action.type === "prev" ? -1 : 1;
+            // Leaving an error shows the stored entries again (the newest first).
+            const from = state.error ? state.entries.length : state.index;
+            const index = Math.min(state.entries.length - 1, Math.max(0, from + step));
+            if (index === state.index && !state.error)
+                return state;
+            return { entries: state.entries, index, scroll: 0 };
+        }
+        case "scroll":
+            return { ...state, scroll: Math.max(0, state.scroll + action.lines) };
+        case "answered":
+            return {
+                entries: action.entries,
+                index: Math.max(0, action.entries.length - 1),
+                scroll: 0,
+            };
+        case "failed": {
+            const { pending: _pending, ...rest } = state;
+            return {
+                ...rest,
+                error: { question: state.pending?.question ?? "", message: action.message },
+                scroll: 0,
+            };
+        }
+    }
+}
+/** The entry on screen, if the panel is not pending or showing an error. */
+export function btwCurrent(state) {
+    return state.pending || state.error ? undefined : state.entries[state.index];
+}
+/** "2/5" for the entry on screen; empty while pending or on an error. */
+export function btwPosition(state) {
+    return btwCurrent(state) ? `${state.index + 1}/${state.entries.length}` : "";
+}
+/** Footer hints for the current state. */
+export function btwHints(state, overflow) {
+    if (state.pending)
+        return "Esc cancel";
+    const current = btwCurrent(state);
+    const hints = [
+        ...(state.entries.length > 1 || (state.error && state.entries.length)
+            ? ["←/→ earlier/later"]
+            : []),
+        ...(overflow ? ["↑/↓ scroll"] : []),
+        "Esc close",
+    ];
+    return current || state.error ? hints.join(" · ") : "Esc close";
+}
+/** "model · 12 in · 3 out tokens" for an entry. */
+export function btwUsageLine(entry) {
+    return `${entry.model} · ${entry.usage.input} in · ${entry.usage.output} out tokens${entry.truncated ? " · truncated" : ""}`;
+}
+/** The visible slice of `lines` for `scroll` (clamped) and whether more lines exist. */
+export function btwWindow(lines, scroll, height) {
+    const max = Math.max(0, lines.length - height);
+    const start = Math.min(Math.max(0, scroll), max);
+    return {
+        lines: lines.slice(start, start + height),
+        scroll: start,
+        above: start > 0,
+        below: start + height < lines.length,
+    };
+}

package/dist/tui/components.d.ts

@@ -1,6 +1,7 @@
 import type { PanelNode, TreeNode, UiBlock } from "@alisio/sdk";
 import { type Component, Container } from "@earendil-works/pi-tui";
 import { type PendingAttachment } from "./attachments.ts";
+import { type BtwAction, type BtwState } from "./btw.ts";
 import { type QuestionPanelState, type QuestionSpec } from "./questions.ts";
 import { type ContextBudget, type FoldableKind, type FoldCandidate, type GroupedTool, type IdentityInput, type TranscriptEntry, type TranscriptItem, type ViewState } from "./state.ts";
 export declare const SPINNER: string[];
@@ -255,3 +256,21 @@ export declare class QuestionPanel implements Component {
     handleInput(data: string): void;
     render(width: number): string[];
 }
+/**
+ * The `/btw` side-question panel (picker slot, never the transcript): a pending question with a
+ * spinner, then the answer rendered as Markdown like assistant text, scrollable, with ←/→ through
+ * the session's earlier side answers. `onClose` runs on Esc (the app cancels a pending question).
+ */
+export declare class BtwPanel implements Component {
+    private state;
+    private readonly onClose;
+    private readonly height;
+    private markdown?;
+    constructor(state: BtwState, onClose: () => void, height: () => number);
+    get pending(): boolean;
+    dispatch(action: BtwAction): void;
+    invalidate(): void;
+    handleInput(data: string): void;
+    private answerLines;
+    render(width: number): string[];
+}

package/dist/tui/components.js

@@ -1,6 +1,7 @@
 import { Container, getCapabilities, getImageDimensions, Image, Key, Markdown, matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi, } from "@earendil-works/pi-tui";
 import { terminalCapabilities } from "../banner.js";
 import { attachmentCaption, MAX_ATTACHMENTS_PER_MESSAGE, } from "./attachments.js";
+import { btwCurrent, btwHints, btwPosition, btwUsageLine, btwWindow, reduceBtw, } from "./btw.js";
 import { branchDisplay } from "./git-branch.js";
 import { initialQuestionState, reduceQuestions, } from "./questions.js";
 import { contextLevel, contextPercent, editSummary, entryKeyOf, fitIdentityParts, fitSegments, foldCandidateOf, formatContext, formatDuration, formatTokens, groupIdentity, groupToolEntries, humanizeToolName, isUiBlock, previewLinesFor, previewRows, REASONING_EXPAND_MAX_LINES, reasoningDurationMs, } from "./state.js";
@@ -1113,3 +1114,89 @@ export class QuestionPanel {
         return fit(lines, width);
     }
 }
+/**
+ * The `/btw` side-question panel (picker slot, never the transcript): a pending question with a
+ * spinner, then the answer rendered as Markdown like assistant text, scrollable, with ←/→ through
+ * the session's earlier side answers. `onClose` runs on Esc (the app cancels a pending question).
+ */
+export class BtwPanel {
+    state;
+    onClose;
+    height;
+    markdown;
+    constructor(state, onClose, height) {
+        this.state = state;
+        this.onClose = onClose;
+        this.height = height;
+    }
+    get pending() {
+        return !!this.state.pending;
+    }
+    dispatch(action) {
+        this.state = reduceBtw(this.state, action);
+    }
+    invalidate() {
+        this.markdown = undefined;
+    }
+    handleInput(data) {
+        if (matchesKey(data, Key.escape))
+            return this.onClose();
+        if (matchesKey(data, Key.left))
+            return this.dispatch({ type: "prev" });
+        if (matchesKey(data, Key.right))
+            return this.dispatch({ type: "next" });
+        if (matchesKey(data, Key.up))
+            return this.dispatch({ type: "scroll", lines: -1 });
+        if (matchesKey(data, Key.down))
+            return this.dispatch({ type: "scroll", lines: 1 });
+        if (matchesKey(data, Key.pageUp))
+            return this.dispatch({ type: "scroll", lines: -this.height() });
+        if (matchesKey(data, Key.pageDown))
+            return this.dispatch({ type: "scroll", lines: this.height() });
+    }
+    answerLines(id, text, width) {
+        if (this.markdown?.id === id && this.markdown.width === width)
+            return this.markdown.lines;
+        const lines = new Markdown(text, 0, 0, markdownTheme, markdownDefaultTextStyle, {
+            transform: markdownTransform,
+        }).render(Math.max(1, width));
+        this.markdown = { id, width, lines };
+        return lines;
+    }
+    render(width) {
+        const s = this.state;
+        const inner = Math.max(1, width - 2);
+        const bar = style.gray("│");
+        const current = btwCurrent(s);
+        const position = btwPosition(s);
+        const lines = [
+            "",
+            `${style.bold(style.yellow("btw"))}${position ? ` ${style.dim(position)}` : ""}${style.dim(" · side question, not added to the conversation")}`,
+        ];
+        const question = s.pending?.question ?? s.error?.question ?? current?.question ?? "";
+        lines.push(...wrap(question, inner).map((l) => `${bar} ${style.bold(l)}`));
+        let overflow = false;
+        if (s.pending) {
+            const spinner = SPINNER[clock.frame % SPINNER.length] ?? "…";
+            lines.push(`${bar} ${style.cyan(spinner)} Thinking… ${style.dim(formatDuration(clock.now - s.pending.startedAt))}`);
+        }
+        else if (s.error) {
+            lines.push(...wrap(s.error.message, inner).map((l) => `${bar} ${style.red(l)}`));
+        }
+        else if (current) {
+            const body = this.answerLines(current.id, current.answer, inner);
+            const view = btwWindow(body, s.scroll, Math.max(3, this.height()));
+            if (view.scroll !== s.scroll)
+                this.state = { ...s, scroll: view.scroll };
+            overflow = view.above || view.below;
+            if (view.above)
+                lines.push(`${bar} ${style.dim("↑ more")}`);
+            lines.push(...view.lines.map((l) => `${bar} ${l}`));
+            if (view.below)
+                lines.push(`${bar} ${style.dim("↓ more")}`);
+            lines.push(`${bar} ${style.dim(btwUsageLine(current))}`);
+        }
+        lines.push(style.dim(`  ${btwHints(this.state, overflow)}`));
+        return fit(lines, width);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alisio/alisio-code",
-  "version": "0.1.0-alpha.21",
+  "version": "0.1.0-alpha.22",
   "description": "Alisio: an extensible, provider-agnostic coding-agent harness for your terminal. TUI, OpenAI-compatible providers, permissioned local tools, context compaction, persistent memory and a typed plugin SDK.",
   "author": "Gustavo Gutiérrez",
   "license": "MIT",
@@ -45,12 +45,12 @@
     "alisio": "./dist/main.js"
   },
   "dependencies": {
-    "@alisio/core": "0.1.0-alpha.18",
+    "@alisio/core": "0.1.0-alpha.19",
     "@alisio/plugin-memory": "0.1.0-alpha.9",
     "@alisio/plugin-openai-compatible": "0.1.0-alpha.9",
     "@alisio/plugin-subagents": "0.1.0-alpha.10",
-    "@alisio/sdk": "0.1.0-alpha.15",
-    "@alisio/server": "0.1.0-alpha.1",
+    "@alisio/sdk": "0.1.0-alpha.16",
+    "@alisio/server": "0.1.0-alpha.2",
     "@earendil-works/pi-tui": "0.87.1",
     "commander": "15.0.0"
   },