@alisio/alisio-code 0.1.0-alpha.8 → 0.1.0

package/dist/tui/open-path.js

@@ -0,0 +1,80 @@
+/**
+ * Opening and revealing local files with the desktop's default application, portably and without
+ * a shell: arguments are an array (no `cmd /c start`, no `sh -c`), so a file name can never inject
+ * a command. Only paths returned by the artifact store are opened, never a path the model wrote.
+ */
+import { spawn } from "node:child_process";
+import { dirname } from "node:path";
+/** Commands that open `path` with the default app, in fallback order. */
+export function openCommands(path, platform) {
+    if (platform === "darwin")
+        return [{ command: "open", args: [path] }];
+    if (platform === "win32")
+        return [{ command: "explorer.exe", args: [path] }];
+    return [
+        { command: "xdg-open", args: [path] },
+        { command: "gio", args: ["open", path] },
+    ];
+}
+/** Commands that show `path` selected in the file manager (its folder on Linux/BSD). */
+export function revealCommands(path, platform) {
+    if (platform === "darwin")
+        return [{ command: "open", args: ["-R", path] }];
+    if (platform === "win32")
+        return [{ command: "explorer.exe", args: [`/select,${path}`] }];
+    return [
+        { command: "xdg-open", args: [dirname(path)] },
+        { command: "gio", args: ["open", dirname(path)] },
+    ];
+}
+/**
+ * Whether a desktop session can show a window: never over SSH; on Linux/BSD only with a display
+ * (`DISPLAY` or `WAYLAND_DISPLAY`). macOS and Windows always have one locally.
+ */
+export function desktopAvailable(platform, env) {
+    if (env.SSH_CONNECTION || env.SSH_TTY)
+        return false;
+    if (platform === "darwin" || platform === "win32")
+        return true;
+    return !!(env.DISPLAY || env.WAYLAND_DISPLAY);
+}
+/** Starts one detached launcher; resolves false when it cannot start (e.g. `ENOENT`). */
+function start(launch, deps) {
+    return new Promise((resolve) => {
+        let child;
+        try {
+            child = (deps.spawn ?? spawn)(launch.command, launch.args, {
+                detached: true,
+                stdio: "ignore",
+                shell: false,
+                windowsHide: true,
+            });
+        }
+        catch {
+            resolve(false);
+            return;
+        }
+        child.once("error", () => resolve(false));
+        child.once("spawn", () => {
+            child.unref();
+            resolve(true);
+        });
+    });
+}
+async function run(launches, deps) {
+    const platform = deps.platform ?? process.platform;
+    if (!desktopAvailable(platform, deps.env ?? process.env))
+        return { ok: false, reason: "no-desktop" };
+    for (const launch of launches)
+        if (await start(launch, deps))
+            return { ok: true };
+    return { ok: false, reason: "unavailable" };
+}
+/** Opens a file with the default application. */
+export const openPath = (path, deps = {}) => run(openCommands(path, deps.platform ?? process.platform), deps);
+/** Shows a file in the system file manager. */
+export const revealPath = (path, deps = {}) => run(revealCommands(path, deps.platform ?? process.platform), deps);
+/** The notice shown when nothing could be opened (the caller offers "Copy path"). */
+export const cannotOpenMessage = (path, outcome) => outcome.reason === "no-desktop"
+    ? `Can't open files here (no desktop session). Path: ${path}`
+    : `No program to open files was found. Path: ${path}`;

package/dist/tui/plan-review.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Pure, pi-tui-free reducer of the plan review panel (`exit_plan`): three decisions and, for "Add
+ * context", a one-line text field. Same convention as `questions.ts`: state + action ->
+ * {state, effect}, fully testable without a terminal. Esc means "Skip for now" while choosing and
+ * "back to the choices" while typing; Enter submits; an empty text never submits.
+ */
+import { type ConnectInputState } from "./connect-input.ts";
+export interface PlanReviewOption {
+    value: string;
+    label: string;
+    description?: string;
+    recommended?: boolean;
+    /** Choosing it asks for free text first. */
+    textInput?: boolean;
+}
+export interface PlanReviewState {
+    options: PlanReviewOption[];
+    cursor: number;
+    mode: "choose" | "text";
+    text: ConnectInputState;
+    done: boolean;
+}
+export type PlanReviewAction = {
+    type: "up" | "down" | "confirm" | "escape";
+} | {
+    type: "left" | "right" | "home" | "end" | "backspace" | "delete";
+} | {
+    type: "insert";
+    text: string;
+};
+export interface PlanReviewEffect {
+    type: "submit";
+    /** The option value: `approve`, `skip` or `context`. */
+    value: string;
+    text?: string;
+}
+export declare const SKIP_VALUE = "skip";
+export declare function initialPlanReviewState(options: PlanReviewOption[]): PlanReviewState;
+export declare function reducePlanReview(state: PlanReviewState, action: PlanReviewAction): {
+    state: PlanReviewState;
+    effect?: PlanReviewEffect;
+};
+/** The plan as the transcript shows it while the decision is pending. */
+export declare function planTranscriptMarkdown(plan: {
+    title: string;
+    revision: number;
+    markdown: string;
+}): string;

package/dist/tui/plan-review.js

@@ -0,0 +1,76 @@
+/**
+ * Pure, pi-tui-free reducer of the plan review panel (`exit_plan`): three decisions and, for "Add
+ * context", a one-line text field. Same convention as `questions.ts`: state + action ->
+ * {state, effect}, fully testable without a terminal. Esc means "Skip for now" while choosing and
+ * "back to the choices" while typing; Enter submits; an empty text never submits.
+ */
+import { printableInput, reduceConnectInput } from "./connect-input.js";
+export const SKIP_VALUE = "skip";
+export function initialPlanReviewState(options) {
+    const recommended = options.findIndex((option) => option.recommended);
+    return {
+        options,
+        cursor: recommended >= 0 ? recommended : 0,
+        mode: "choose",
+        text: { value: "", cursor: 0 },
+        done: false,
+    };
+}
+export function reducePlanReview(state, action) {
+    if (state.done || !state.options.length)
+        return { state };
+    const option = state.options[state.cursor];
+    if (state.mode === "text") {
+        switch (action.type) {
+            case "escape":
+                return { state: { ...state, mode: "choose" } };
+            case "confirm": {
+                const text = state.text.value.trim();
+                if (!text)
+                    return { state };
+                return {
+                    state: { ...state, done: true },
+                    effect: { type: "submit", value: option.value, text },
+                };
+            }
+            case "insert": {
+                const text = printableInput(action.text);
+                return text
+                    ? { state: { ...state, text: reduceConnectInput(state.text, { type: "insert", text }) } }
+                    : { state };
+            }
+            case "left":
+            case "right":
+            case "home":
+            case "end":
+            case "backspace":
+            case "delete":
+                return { state: { ...state, text: reduceConnectInput(state.text, { type: action.type }) } };
+            default:
+                return { state };
+        }
+    }
+    switch (action.type) {
+        case "up":
+            return {
+                state: {
+                    ...state,
+                    cursor: (state.cursor - 1 + state.options.length) % state.options.length,
+                },
+            };
+        case "down":
+            return { state: { ...state, cursor: (state.cursor + 1) % state.options.length } };
+        case "confirm":
+            if (option.textInput)
+                return { state: { ...state, mode: "text" } };
+            return { state: { ...state, done: true }, effect: { type: "submit", value: option.value } };
+        case "escape":
+            return { state: { ...state, done: true }, effect: { type: "submit", value: SKIP_VALUE } };
+        default:
+            return { state };
+    }
+}
+/** The plan as the transcript shows it while the decision is pending. */
+export function planTranscriptMarkdown(plan) {
+    return `**Plan: ${plan.title}**${plan.revision > 1 ? ` (revision ${plan.revision})` : ""}\n\n${plan.markdown}`;
+}

package/dist/tui/queue.d.ts

@@ -15,6 +15,8 @@
 export interface QueueAsker {
     sessionId?: string;
     label?: string;
+    /** What is being asked (a goal waits differently for a permission than for an answer). */
+    kind?: "approval" | "question";
 }
 export interface QueueJob<T> extends QueueAsker {
     signal?: AbortSignal;

package/dist/tui/queue.js

@@ -18,7 +18,11 @@ export class InteractiveQueue {
     submit(job) {
         return new Promise((resolve, reject) => {
             let settled = false;
-            const asker = { sessionId: job.sessionId, label: job.label };
+            const asker = {
+                sessionId: job.sessionId,
+                label: job.label,
+                ...(job.kind ? { kind: job.kind } : {}),
+            };
             const entry = {
                 asker,
                 start: () => {

package/dist/tui/scroll.d.ts

@@ -0,0 +1,8 @@
+/** Pure scrolling helper shared by the panels that show long text in the picker slot. */
+/** The visible slice of `lines` for `scroll` (clamped) and whether more lines exist. */
+export declare function scrollWindow(lines: string[], scroll: number, height: number): {
+    lines: string[];
+    scroll: number;
+    above: boolean;
+    below: boolean;
+};

package/dist/tui/scroll.js

@@ -0,0 +1,12 @@
+/** Pure scrolling helper shared by the panels that show long text in the picker slot. */
+/** The visible slice of `lines` for `scroll` (clamped) and whether more lines exist. */
+export function scrollWindow(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/settings-menu.d.ts

@@ -0,0 +1,40 @@
+/**
+ * OpenCode-style settings menu for the TUI: two-column rows (name + current value), live
+ * type-to-search, Enter/Space to change a setting (or navigate), Esc to leave, a `(n/total)`
+ * counter and a footer with the highlighted row's description.
+ *
+ * This component is a thin shell: all decision logic (key decoding, filtering, cycling, counter)
+ * lives in the pure `settings.ts` module, which is fully unit-tested without pi-tui.
+ */
+import { type Component } from "@earendil-works/pi-tui";
+import { type SettingRow } from "./settings.ts";
+export declare class SettingsMenu implements Component {
+    private title;
+    /** A setting value changed: persist and apply it. The host re-refreshes on success/failure. */
+    private onChange;
+    /** A navigation row was activated (Enter/Space): route to its manager. */
+    private onNavigate;
+    /** Esc pressed: leave the menu (the host returns to the editor). */
+    private onCancel;
+    /** Optional dim lines under the title (e.g. the current provider/model). */
+    private detail?;
+    private full;
+    private filtered;
+    private state;
+    constructor(title: string, rows: SettingRow[], 
+    /** A setting value changed: persist and apply it. The host re-refreshes on success/failure. */
+    onChange: (row: SettingRow, value: unknown) => void, 
+    /** A navigation row was activated (Enter/Space): route to its manager. */
+    onNavigate: (row: SettingRow) => void, 
+    /** Esc pressed: leave the menu (the host returns to the editor). */
+    onCancel: () => void, 
+    /** Optional dim lines under the title (e.g. the current provider/model). */
+    detail?: string | undefined);
+    /** Rebuild rows from the live config after a write; keeps the filter and re-selects the row. */
+    refresh(rows: SettingRow[]): void;
+    /** Update the displayed value of one row without rebuilding the whole list. */
+    updateValue(id: string, value: unknown): void;
+    invalidate(): void;
+    handleInput(data: string): void;
+    render(width: number): string[];
+}

package/dist/tui/settings-menu.js

@@ -0,0 +1,132 @@
+/**
+ * OpenCode-style settings menu for the TUI: two-column rows (name + current value), live
+ * type-to-search, Enter/Space to change a setting (or navigate), Esc to leave, a `(n/total)`
+ * counter and a footer with the highlighted row's description.
+ *
+ * This component is a thin shell: all decision logic (key decoding, filtering, cycling, counter)
+ * lives in the pure `settings.ts` module, which is fully unit-tested without pi-tui.
+ */
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import { filterSettingRows, formatSettingValue, initialSettingsMenuState, reduceSettingsInput, settingsCounter, settingsKeyAction, } from "./settings.js";
+import { style } from "./theme.js";
+const MAX_VISIBLE = 10;
+const wrapText = (text, width) => {
+    const rows = [];
+    let row = "";
+    for (const word of text.split(/\s+/)) {
+        if (row && [...`${row} ${word}`].length > width) {
+            rows.push(row);
+            row = word;
+        }
+        else
+            row = row ? `${row} ${word}` : word;
+    }
+    if (row)
+        rows.push(row);
+    return rows;
+};
+export class SettingsMenu {
+    title;
+    onChange;
+    onNavigate;
+    onCancel;
+    detail;
+    full;
+    filtered;
+    state = initialSettingsMenuState();
+    constructor(title, rows, 
+    /** A setting value changed: persist and apply it. The host re-refreshes on success/failure. */
+    onChange, 
+    /** A navigation row was activated (Enter/Space): route to its manager. */
+    onNavigate, 
+    /** Esc pressed: leave the menu (the host returns to the editor). */
+    onCancel, 
+    /** Optional dim lines under the title (e.g. the current provider/model). */
+    detail) {
+        this.title = title;
+        this.onChange = onChange;
+        this.onNavigate = onNavigate;
+        this.onCancel = onCancel;
+        this.detail = detail;
+        this.full = rows;
+        this.filtered = rows;
+    }
+    /** Rebuild rows from the live config after a write; keeps the filter and re-selects the row. */
+    refresh(rows) {
+        const previous = this.filtered[this.state.selected]?.id;
+        this.full = rows;
+        this.filtered = filterSettingRows(rows, this.state.filter);
+        const index = previous ? this.filtered.findIndex((row) => row.id === previous) : -1;
+        this.state = { ...this.state, selected: index >= 0 ? index : 0 };
+    }
+    /** Update the displayed value of one row without rebuilding the whole list. */
+    updateValue(id, value) {
+        for (const row of this.full)
+            if (row.id === id)
+                row.current = value;
+    }
+    invalidate() { }
+    handleInput(data) {
+        const action = settingsKeyAction(data, this.state);
+        const { state, effect } = reduceSettingsInput(this.state, action, this.filtered);
+        this.state = state;
+        // Re-apply the live filter so typing narrows the list before the next render/input.
+        this.filtered = filterSettingRows(this.full, state.filter);
+        switch (effect.type) {
+            case "change":
+                // Optimistically reflect the new value; the host refreshes from the config on success.
+                effect.row.current = effect.value;
+                this.onChange(effect.row, effect.value);
+                break;
+            case "navigate":
+                this.onNavigate(effect.row);
+                break;
+            case "cancel":
+                this.onCancel();
+                break;
+            case "none":
+                break;
+        }
+    }
+    render(width) {
+        const lines = [truncateToWidth(style.bold(style.yellow(this.title)), width)];
+        if (this.detail?.trim())
+            for (const line of wrapText(this.detail, Math.max(20, width - 2)))
+                lines.push(truncateToWidth(style.dim(`  ${line}`), width));
+        if (this.state.filter)
+            lines.push(truncateToWidth(style.dim(`  filter: ${this.state.filter}`), width));
+        const rows = this.filtered;
+        if (!rows.length) {
+            lines.push(truncateToWidth(style.yellow(this.full.length ? "  No matching settings" : "  No settings available"), width));
+            lines.push("");
+            lines.push(truncateToWidth(style.dim("  Type to search · Esc to cancel"), width));
+            return lines;
+        }
+        // Two-column layout: labels padded to the widest row (capped), values right beside them.
+        const maxLabel = Math.min(36, Math.max(...rows.map((row) => [...row.label].length)));
+        const start = Math.max(0, Math.min(this.state.selected - Math.floor(MAX_VISIBLE / 2), rows.length - MAX_VISIBLE));
+        const visible = rows.slice(start, start + MAX_VISIBLE);
+        for (let i = 0; i < visible.length; i++) {
+            const row = visible[i];
+            if (!row)
+                continue;
+            const selected = start + i === this.state.selected;
+            const label = row.label.padEnd(maxLabel);
+            const value = row.kind === "setting" ? formatSettingValue(row, row.current) : "";
+            const rendered = selected
+                ? `${style.cyan("›")} ${style.bold(style.cyan(label))}${value ? `  ${style.bold(style.cyan(value))}` : ""}`
+                : `  ${label}${value ? `  ${value}` : ""}`;
+            lines.push(truncateToWidth(rendered, width));
+        }
+        lines.push(truncateToWidth(style.dim(`  ${settingsCounter(rows, this.state.selected)}`), width));
+        const selectedRow = rows[this.state.selected];
+        if (selectedRow?.description) {
+            lines.push("");
+            for (const wrapped of wrapText(selectedRow.description, Math.max(20, width - 4)))
+                lines.push(truncateToWidth(style.gray(`  ${wrapped}`), width));
+            lines.push("");
+        }
+        lines.push(truncateToWidth(style.dim("  Type to search · Enter/Space to change · Esc to cancel"), width));
+        return lines;
+    }
+}

package/dist/tui/settings.d.ts

@@ -0,0 +1,194 @@
+/**
+ * Pure settings-menu logic for the TUI: row building, filtering, value cycling, counter and
+ * keyboard reduction. No terminal or pi-tui imports here — the `SettingsMenu` component in
+ * `settings-menu.ts` is a thin shell over this module.
+ *
+ * Only settings Alisio actually supports are defined here. The row set is the honest, wired
+ * list: every "setting" row maps to a real config key persisted through the atomic
+ * `setConfigValue` writer (or the MCP consent path) and is applied to the running process.
+ */
+export type SettingValueType = "boolean" | "number" | "percent" | "enum";
+export interface SettingRow {
+    /** Config key (or MCP consent id) this row edits; navigation rows carry their action id. */
+    id: string;
+    label: string;
+    description: string;
+    /** Group the row belongs to; also matched by the filter ("type" of the row). */
+    category: string;
+    kind: "setting" | "navigation";
+    /** Current raw value for setting rows (read live from the config at build time). */
+    current?: unknown;
+    /** Ordered candidate values cycled by Enter/Space; wraps around at the ends. */
+    values?: unknown[];
+    valueType?: SettingValueType;
+    /** Displayed but not editable in this run (e.g. under `--read-only`). */
+    readOnly?: boolean;
+    /** Navigation target id for navigation rows; the host maps it to a concrete action. */
+    action?: string;
+}
+export interface SettingsNavigationAction {
+    id: string;
+    label: string;
+    description: string;
+}
+/** Ordered candidates of the `websearch.provider` enum, aligned exactly with the config schema. */
+export declare const WEBSEARCH_PROVIDERS: readonly ["searxng", "duckduckgo-instant", "duckduckgo-html", "tavily", "brave", "serpapi", "native"];
+/**
+ * The config surface the menu reads. A structural view of the loaded config: rows are built only
+ * from the documented fields below, so unknown keys in a real config are ignored by construction.
+ */
+export interface SettingsConfigView {
+    compaction: {
+        auto: boolean;
+        threshold: number;
+        keepTurns: number;
+        maxOutputTokens: number;
+    };
+    context: {
+        claudeMdFallback: boolean;
+        maxBytes: number;
+    };
+    limits: {
+        maxTurns: number;
+        /** Only present when the user set it; unset means "the model's declared limit, else 16384". */
+        maxOutputTokens?: number | undefined;
+        maxContextChars: number;
+        timeoutMs: number;
+    };
+    tui: {
+        paddingX: number;
+        contentPaddingX: number;
+        skillSlashCommands: boolean;
+    };
+    mcp: {
+        allow?: boolean;
+    };
+    websearch: {
+        provider?: (typeof WEBSEARCH_PROVIDERS)[number];
+    };
+    pluginHooks: {
+        timeoutMs: number;
+    };
+    analysis: {
+        enabled: boolean;
+        limits: {
+            timeoutMs: number;
+        };
+        retention: {
+            jobsDays: number;
+            intermediateDays: number;
+            artifactsDays: number;
+        };
+    };
+    tasks: {
+        enabled: boolean;
+        maxPerSession: number;
+        retentionDays: number;
+    };
+    goal: {
+        enabled: boolean;
+        maxTurns: number;
+        maxMinutes: number;
+        repeatedReplyLimit: number;
+        noToolTurnsLimit: number;
+        blockedRepeats: number;
+    };
+}
+export interface SettingsMenuInput {
+    config: SettingsConfigView;
+    /** Whether global MCP consent (`mcp.allow`) is persisted for this user right now. */
+    mcpAllowPersisted: boolean;
+    /** `--read-only` run: every row is shown but none can be changed. */
+    readOnly: boolean;
+}
+/** The config view with the schema defaults; also the canonical fixture for tests. */
+export declare const defaultConfig: SettingsConfigView;
+interface SettingDefinition {
+    id: string;
+    label: string;
+    category: string;
+    description: string;
+    valueType: SettingValueType;
+    values: unknown[];
+    read: (config: SettingsConfigView, mcpAllowPersisted: boolean) => unknown;
+}
+/**
+ * Every real, wired setting the menu offers. `read` maps the live config to the current value;
+ * the keys are exactly the ones `setConfigValue` accepts (`compaction.*`, `context.*`, `limits.*`,
+ * `pluginHooks.timeoutMs`, `tui.*` and `websearch.provider`), and `mcp.allow` flows through the
+ * application's consent path instead. `limits.timeoutMs` is displayed in seconds (the values are
+ * seconds); the app host multiplies by 1000 before persisting the milliseconds.
+ */
+export declare const SETTINGS_DEFINITIONS: readonly SettingDefinition[];
+/**
+ * Builds the full settings menu: the real, wired setting rows followed by the navigation rows the
+ * host wires to the existing managers (`/model`, `/connect`, `/plugins`, `/skills`, `/mcps`, ...).
+ * Under `--read-only` every setting row is marked read-only: nothing can be persisted.
+ */
+export declare function settingsMenuRows(input: SettingsMenuInput, navigation: SettingsNavigationAction[]): SettingRow[];
+/** Whether a row matches every whitespace-separated filter term, on label/id/category/description. */
+export declare function matchSettingRow(row: SettingRow, terms: string[]): boolean;
+/** Filters rows by name, id, category (type) and description; an empty query returns everything. */
+export declare function filterSettingRows(rows: SettingRow[], filter: string): SettingRow[];
+/** The value shown in the right-hand column of a setting row. */
+export declare function formatSettingValue(row: SettingRow, value: unknown): string;
+/**
+ * The next candidate after the current value in the row's ordered `values`, wrapping around.
+ * A current value that is not in the list (hand-edited config) moves to the next candidate at or
+ * above it for numbers, or wraps to the first candidate otherwise. Never mutates the row.
+ */
+export declare function cycleSettingValue(row: SettingRow, current: unknown): unknown | undefined;
+/** OpenCode-style `(n/total)` counter; empty when there are no rows to count. */
+export declare function settingsCounter(rows: SettingRow[], selected: number): string;
+export interface SettingsMenuState {
+    /** Live type-to-search filter (matched against name, id, category and description). */
+    filter: string;
+    /** Index into the FILTERED row list. */
+    selected: number;
+}
+export declare const initialSettingsMenuState: () => SettingsMenuState;
+/**
+ * Normalized keyboard actions for the settings menu, decoded from raw terminal input with plain
+ * string matching so the logic stays testable without pi-tui. The component just forwards
+ * `handleInput(data)` here and maps the resulting effect to its callbacks.
+ */
+export type SettingsKeyAction = {
+    kind: "move";
+    direction: "up" | "down" | "start" | "end" | "pageUp" | "pageDown";
+} | {
+    kind: "type";
+    char: string;
+} | {
+    kind: "backspace";
+}
+/** Enter, or Space while the filter is empty (Space with an active filter types a space). */
+ | {
+    kind: "change";
+} | {
+    kind: "cancel";
+} | {
+    kind: "ignore";
+};
+export declare function settingsKeyAction(data: string, state: SettingsMenuState): SettingsKeyAction;
+export type SettingsMenuEffect = {
+    type: "change";
+    row: SettingRow;
+    value: unknown;
+} | {
+    type: "navigate";
+    row: SettingRow;
+} | {
+    type: "cancel";
+} | {
+    type: "none";
+};
+/**
+ * Pure keyboard reducer over the menu state. `rows` is the current FILTERED list (navigation rows
+ * and settings rows alike); Enter/Space changes a setting or navigates, Esc cancels, typing
+ * filters, Backspace edits the filter, and movement keys move/clamp the selection.
+ */
+export declare function reduceSettingsInput(state: SettingsMenuState, action: SettingsKeyAction, rows: SettingRow[]): {
+    state: SettingsMenuState;
+    effect: SettingsMenuEffect;
+};
+export {};