@alisio/alisio-code 0.1.0-alpha.10

package/dist/tui/attachments.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Image attachments for the TUI message composer: clipboard image paste (Ctrl+V), a bounded
+ * pending list shown above the editor, and the SDK content shape sent with the next message.
+ * Pure and dependency-injected so it is fully unit-testable; pi-tui APIs (native clipboard,
+ * image dimensions, rendering) are wired in by apps/cli/src/tui/app.ts.
+ */
+import type { Attachment } from "@alisio/sdk";
+/** Single image cap (raw bytes, before base64). */
+export declare const MAX_IMAGE_BYTES: number;
+/** Attachments allowed on one outgoing message. */
+export declare const MAX_ATTACHMENTS_PER_MESSAGE = 4;
+export interface PendingAttachment {
+    id: string;
+    mimeType: string;
+    /** Base64-encoded bytes, no `data:` prefix. */
+    data: string;
+    bytes: number;
+    width?: number;
+    height?: number;
+}
+export type AttachmentRejection = "empty" | "unsupported-format" | "too-large" | "too-many";
+/** Detects PNG/JPEG/GIF/WebP by magic bytes; other formats are not supported. */
+export declare function sniffImageMime(bytes: Uint8Array): string | undefined;
+export interface BuildOptions {
+    maxBytes?: number;
+    /** Injected so the pure module never imports a pi-tui image decoder itself. */
+    dimensions?: (base64: string, mimeType: string) => {
+        widthPx: number;
+        heightPx: number;
+    } | null;
+    id?: () => string;
+}
+export declare function buildAttachment(bytes: Uint8Array, options?: BuildOptions): {
+    ok: true;
+    attachment: PendingAttachment;
+} | {
+    ok: false;
+    error: AttachmentRejection;
+};
+export interface ListOptions extends BuildOptions {
+    maxCount?: number;
+}
+/** Appends within the count limit; the input list is never mutated. */
+export declare function addAttachment(list: readonly PendingAttachment[], bytes: Uint8Array, options?: ListOptions): {
+    list: PendingAttachment[];
+    error?: AttachmentRejection;
+};
+export declare function removeLastAttachment(list: readonly PendingAttachment[]): {
+    list: PendingAttachment[];
+    removed?: PendingAttachment;
+};
+/** `[N] image/png 1024x768, 42.0 KB` — a compact fallback for terminals without inline images. */
+export declare function attachmentCaption(a: PendingAttachment, index: number): string;
+export declare function rejectionMessage(error: AttachmentRejection, options?: ListOptions): string;
+/** The SDK content shape sent alongside the message text. */
+export declare function toApiAttachment(a: PendingAttachment): Attachment;
+export interface ClipboardImageSource {
+    getImage(): Promise<Uint8Array | null | undefined>;
+}
+/**
+ * Ctrl+V: undefined clipboard (no platform helper, e.g. plain SSH without X11/wl-clipboard) is a
+ * graceful no-op; `getImage()` resolving `null` means an empty (non-image) clipboard, `undefined`
+ * means the image source itself is unavailable; a rejected read is reported, never thrown.
+ */
+export declare function pasteImageFromClipboard(clipboard: ClipboardImageSource | undefined, current: readonly PendingAttachment[], options?: ListOptions): Promise<{
+    list: PendingAttachment[];
+    message?: string;
+}>;

package/dist/tui/attachments.js

@@ -0,0 +1,132 @@
+/** Single image cap (raw bytes, before base64). */
+export const MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+/** Attachments allowed on one outgoing message. */
+export const MAX_ATTACHMENTS_PER_MESSAGE = 4;
+const MAGIC = [
+    {
+        mime: "image/png",
+        test: (b) => b.length >= 8 && b[0] === 0x89 && b[1] === 0x50 && b[2] === 0x4e && b[3] === 0x47,
+    },
+    {
+        mime: "image/jpeg",
+        test: (b) => b.length >= 3 && b[0] === 0xff && b[1] === 0xd8 && b[2] === 0xff,
+    },
+    {
+        mime: "image/gif",
+        test: (b) => b.length >= 6 && b[0] === 0x47 && b[1] === 0x49 && b[2] === 0x46,
+    },
+    {
+        mime: "image/webp",
+        test: (b) => b.length >= 12 &&
+            b[0] === 0x52 &&
+            b[1] === 0x49 &&
+            b[2] === 0x46 &&
+            b[3] === 0x46 &&
+            b[8] === 0x57 &&
+            b[9] === 0x45 &&
+            b[10] === 0x42 &&
+            b[11] === 0x50,
+    },
+];
+/** Detects PNG/JPEG/GIF/WebP by magic bytes; other formats are not supported. */
+export function sniffImageMime(bytes) {
+    return MAGIC.find((m) => m.test(bytes))?.mime;
+}
+const defaultId = () => crypto.randomUUID();
+export function buildAttachment(bytes, options = {}) {
+    if (!bytes.length)
+        return { ok: false, error: "empty" };
+    if (bytes.length > (options.maxBytes ?? MAX_IMAGE_BYTES))
+        return { ok: false, error: "too-large" };
+    const mimeType = sniffImageMime(bytes);
+    if (!mimeType)
+        return { ok: false, error: "unsupported-format" };
+    const data = Buffer.from(bytes).toString("base64");
+    const dims = options.dimensions?.(data, mimeType) ?? null;
+    return {
+        ok: true,
+        attachment: {
+            id: (options.id ?? defaultId)(),
+            mimeType,
+            data,
+            bytes: bytes.length,
+            ...(dims ? { width: dims.widthPx, height: dims.heightPx } : {}),
+        },
+    };
+}
+/** Appends within the count limit; the input list is never mutated. */
+export function addAttachment(list, bytes, options = {}) {
+    if (list.length >= (options.maxCount ?? MAX_ATTACHMENTS_PER_MESSAGE))
+        return { list: [...list], error: "too-many" };
+    const result = buildAttachment(bytes, options);
+    if (!result.ok)
+        return { list: [...list], error: result.error };
+    return { list: [...list, result.attachment] };
+}
+export function removeLastAttachment(list) {
+    if (!list.length)
+        return { list: [] };
+    return { list: list.slice(0, -1), removed: list.at(-1) };
+}
+const kb = (bytes) => (bytes / 1024).toFixed(1);
+/** `[N] image/png 1024x768, 42.0 KB` — a compact fallback for terminals without inline images. */
+export function attachmentCaption(a, index) {
+    const dims = a.width && a.height ? `${a.width}x${a.height}, ` : "";
+    return `[${index + 1}] ${a.mimeType} ${dims}${kb(a.bytes)} KB`;
+}
+export function rejectionMessage(error, options = {}) {
+    const maxMb = (options.maxBytes ?? MAX_IMAGE_BYTES) / (1024 * 1024);
+    const maxCount = options.maxCount ?? MAX_ATTACHMENTS_PER_MESSAGE;
+    switch (error) {
+        case "empty":
+            return "The clipboard image is empty.";
+        case "unsupported-format":
+            return "Unsupported image format (only PNG, JPEG, GIF and WebP are recognized).";
+        case "too-large":
+            return `Image exceeds the ${maxMb} MB limit per attachment.`;
+        case "too-many":
+            return `Maximum ${maxCount} attachments per message.`;
+    }
+}
+/** The SDK content shape sent alongside the message text. */
+export function toApiAttachment(a) {
+    return {
+        kind: "image",
+        mimeType: a.mimeType,
+        data: a.data,
+        bytes: a.bytes,
+        ...(a.width !== undefined ? { width: a.width } : {}),
+        ...(a.height !== undefined ? { height: a.height } : {}),
+    };
+}
+/**
+ * Ctrl+V: undefined clipboard (no platform helper, e.g. plain SSH without X11/wl-clipboard) is a
+ * graceful no-op; `getImage()` resolving `null` means an empty (non-image) clipboard, `undefined`
+ * means the image source itself is unavailable; a rejected read is reported, never thrown.
+ */
+export async function pasteImageFromClipboard(clipboard, current, options = {}) {
+    if (!clipboard)
+        return {
+            list: [...current],
+            message: "No native clipboard access here (e.g. over SSH, or without a platform clipboard helper).",
+        };
+    let bytes;
+    try {
+        bytes = await clipboard.getImage();
+    }
+    catch (error) {
+        return {
+            list: [...current],
+            message: `Clipboard read failed: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+    if (bytes === undefined)
+        return {
+            list: [...current],
+            message: "Image clipboard access is not available on this platform or session.",
+        };
+    if (bytes === null)
+        return { list: [...current], message: "Clipboard has no image." };
+    const { list, error } = addAttachment(current, bytes, options);
+    return error ? { list, message: rejectionMessage(error, options) } : { list };
+}

package/dist/tui/clipboard.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Clipboard adapter for the TUI. Command selection is pure and the process spawner is
+ * injected, so tests never touch a real clipboard.
+ */
+/** Resolves with the exit code; rejects when the executable cannot be started. */
+export type Spawn = (command: string, args: string[], input: string) => Promise<number>;
+export interface ClipboardCommand {
+    command: string;
+    args: string[];
+}
+export interface CopyResult {
+    ok: boolean;
+    /** Tool that succeeded, `osc52` (unverified) or `none`. */
+    method: string;
+}
+export declare function clipboardCommands(platform: NodeJS.Platform, env: Record<string, string | undefined>): ClipboardCommand[];
+export declare const osc52: (text: string) => string;
+/**
+ * Tries native tools in order (stdin input, no shell) and succeeds only on exit code 0.
+ * Otherwise writes OSC 52 when a writer is available; that path cannot be verified, so it
+ * reports `ok: false` with method `osc52`.
+ */
+export declare function copyText(text: string, deps: {
+    platform: NodeJS.Platform;
+    env: Record<string, string | undefined>;
+    spawn: Spawn;
+    writeOsc52?: (sequence: string) => void;
+}): Promise<CopyResult>;
+/** Real spawner (node:child_process): no shell, text on stdin, output ignored, 3s timeout. */
+export declare const nodeSpawn: Spawn;

package/dist/tui/clipboard.js

@@ -0,0 +1,57 @@
+import { spawn } from "node:child_process";
+export function clipboardCommands(platform, env) {
+    const windows = [
+        { command: "clip.exe", args: [] },
+        {
+            command: "powershell.exe",
+            args: ["-NoProfile", "-NonInteractive", "-Command", "Set-Clipboard -Value $input"],
+        },
+    ];
+    if (platform === "darwin")
+        return [{ command: "pbcopy", args: [] }];
+    if (platform === "win32")
+        return windows;
+    return [
+        { command: "wl-copy", args: [] },
+        { command: "xclip", args: ["-selection", "clipboard"] },
+        { command: "xsel", args: ["-b"] },
+        ...(env.WSL_DISTRO_NAME ? windows : []),
+    ];
+}
+export const osc52 = (text) => `\x1b]52;c;${Buffer.from(text, "utf8").toString("base64")}\x07`;
+/**
+ * Tries native tools in order (stdin input, no shell) and succeeds only on exit code 0.
+ * Otherwise writes OSC 52 when a writer is available; that path cannot be verified, so it
+ * reports `ok: false` with method `osc52`.
+ */
+export async function copyText(text, deps) {
+    for (const { command, args } of clipboardCommands(deps.platform, deps.env)) {
+        try {
+            if ((await deps.spawn(command, args, text)) === 0)
+                return { ok: true, method: command };
+        }
+        catch {
+            /* Not installed or not startable: try the next tool. */
+        }
+    }
+    if (deps.writeOsc52) {
+        deps.writeOsc52(osc52(text));
+        return { ok: false, method: "osc52" };
+    }
+    return { ok: false, method: "none" };
+}
+/** Real spawner (node:child_process): no shell, text on stdin, output ignored, 3s timeout. */
+export const nodeSpawn = (command, args, input) => new Promise((resolveCode, reject) => {
+    const child = spawn(command, args, { stdio: ["pipe", "ignore", "ignore"], windowsHide: true });
+    const timer = setTimeout(() => child.kill(), 3_000);
+    child.once("error", (error) => {
+        clearTimeout(timer);
+        reject(error);
+    });
+    child.once("close", (code) => {
+        clearTimeout(timer);
+        resolveCode(code ?? 1);
+    });
+    child.stdin.on("error", () => { });
+    child.stdin.end(input);
+});

package/dist/tui/components.d.ts

@@ -0,0 +1,159 @@
+import type { PanelNode } from "@alisio/sdk";
+import { type Component, Container } from "@earendil-works/pi-tui";
+import { type PendingAttachment } from "./attachments.ts";
+import { type QuestionPanelState, type QuestionSpec } from "./questions.ts";
+import { type ContextBudget, type TranscriptItem, type ViewState } from "./state.ts";
+export declare const SPINNER: string[];
+/** Shared animation clock advanced by the app while work is running. */
+export declare const clock: {
+    frame: number;
+    now: number;
+};
+export type PermissionState = "on" | "ask" | "off";
+export interface HeaderInfo {
+    version: string;
+    host: string;
+    apiMode: string;
+    provider?: string;
+    cwd: string;
+    session: string;
+    write: PermissionState;
+    process: PermissionState;
+    mcp: boolean;
+    readOnly: boolean;
+}
+export declare class Header implements Component {
+    private info;
+    private view;
+    constructor(info: () => HeaderInfo, view: () => ViewState);
+    invalidate(): void;
+    render(width: number): string[];
+}
+export declare class Footer implements Component {
+    private view;
+    private budget;
+    private hint;
+    private statuses;
+    constructor(view: () => ViewState, budget: () => ContextBudget | undefined, hint: () => string | undefined, statuses?: () => string[]);
+    invalidate(): void;
+    render(width: number): string[];
+}
+export declare class UserBlock implements Component {
+    private text;
+    constructor(text: string);
+    invalidate(): void;
+    render(width: number): string[];
+}
+export declare class AssistantBlock implements Component {
+    private markdown;
+    private item;
+    constructor(item: Extract<TranscriptItem, {
+        kind: "assistant";
+    }>);
+    update(item: Extract<TranscriptItem, {
+        kind: "assistant";
+    }>): void;
+    invalidate(): void;
+    render(width: number): string[];
+}
+export declare class ToolBlock implements Component {
+    item: Extract<TranscriptItem, {
+        kind: "tool";
+    }>;
+    constructor(item: Extract<TranscriptItem, {
+        kind: "tool";
+    }>);
+    invalidate(): void;
+    render(width: number): string[];
+}
+export declare class LineBlock implements Component {
+    private text;
+    private kind;
+    constructor(text: string, kind: "notice" | "error");
+    invalidate(): void;
+    render(width: number): string[];
+}
+export declare class InfoBlock implements Component {
+    private markdown;
+    constructor(text: string);
+    invalidate(): void;
+    render(width: number): string[];
+}
+export declare function componentFor(item: TranscriptItem): Component;
+/** Startup screen rendered by core for the current width (cached until the width changes). */
+export declare class BannerBlock implements Component {
+    private renderLines;
+    private cache?;
+    constructor(renderLines: (width: number) => string[]);
+    invalidate(): void;
+    render(width: number): string[];
+}
+/** Keeps a container of transcript components in step with view-model items. */
+export declare class TranscriptSync {
+    readonly container: Container;
+    private rendered;
+    sync(items: TranscriptItem[]): void;
+    reset(): void;
+}
+/** Renders one of several components (main conversation or a read-only child view). */
+export declare class Switch implements Component {
+    private pick;
+    constructor(pick: () => Component);
+    invalidate(): void;
+    render(width: number): string[];
+}
+export interface TreePanelView {
+    title: string;
+    rows: Array<{
+        node: PanelNode;
+        depth: number;
+        hasChildren: boolean;
+        collapsed: boolean;
+    }>;
+    total: PanelNode[];
+    focused: boolean;
+    selected?: string;
+    confirm?: {
+        id: string;
+        count: number;
+    };
+}
+/** Collapsible tree panel under the editor (generic; fed by plugin panel providers). */
+export declare class TreePanel implements Component {
+    private view;
+    constructor(view: () => TreePanelView | undefined);
+    invalidate(): void;
+    render(width: number): string[];
+}
+/**
+ * Pending image attachments shown above the editor: an inline thumbnail (Kitty/iTerm2) when the
+ * terminal supports it, otherwise a compact one-line fallback. Empty when there are none.
+ */
+export declare class AttachmentsBar implements Component {
+    private items;
+    private thumbnails;
+    constructor(items: () => PendingAttachment[]);
+    invalidate(): void;
+    render(width: number): string[];
+}
+/**
+ * Interactive multiple-choice question panel (`ask_user_question` / `/ask`). Shows one question at
+ * a time (stepped), for legibility in narrow terminals — a single scrollable panel holding every
+ * question's options at once would overflow or force heavy truncation below ~60 columns, whereas a
+ * step keeps each question fully readable and reflows independently on resize.
+ *
+ * Keys: ↑↓ move (wraps), →/Space toggle a multi-select option, Enter confirms the current question
+ * and advances (submits on the last one), ←/Backspace goes back to change an earlier answer (only
+ * offered when there is one), Esc skips the CURRENT question only (marks it undefined) and still
+ * advances — it never aborts the whole batch, so an earlier or later question is unaffected.
+ */
+export declare class QuestionPanel implements Component {
+    private onSubmit;
+    private label?;
+    private state;
+    constructor(questions: QuestionSpec[], onSubmit: (answers: QuestionPanelState["answers"]) => void, label?: string | undefined);
+    invalidate(): void;
+    private dispatch;
+    handleInput(data: string): void;
+    render(width: number): string[];
+}