mu-harness 0.16.3

package/esm/harness/npm/src/tui/components/transcript.js

@@ -0,0 +1,4 @@
+export const messagesView = (ctx) => ({
+    render: (s) => ctx.components.column(ctx.channel.messages.map(ctx.renderMessage)).render(s),
+});
+export const transcript = (ctx) => ctx.components.scrollView(messagesView(ctx));

package/esm/harness/npm/src/tui/index.d.ts

@@ -0,0 +1,7 @@
+import type { Channel } from '../channels/index.js';
+import type { ChatApp, ChatAppOptions } from './types.js';
+export * from './types.js';
+export * from './kit.js';
+export * from './components/index.js';
+export { createChatApp } from './channel.js';
+export declare const runChat: (channel: Channel, opts?: ChatAppOptions) => ChatApp;

package/esm/harness/npm/src/tui/index.js

@@ -0,0 +1,10 @@
+import { createChatApp } from './channel.js';
+export * from './types.js';
+export * from './kit.js';
+export * from './components/index.js';
+export { createChatApp } from './channel.js';
+export const runChat = (channel, opts) => {
+    const app = createChatApp(channel, opts);
+    app.start();
+    return app;
+};

package/esm/harness/npm/src/tui/kit.d.ts

@@ -0,0 +1,15 @@
+import { type Component, type FlexItem } from 'mu-tui';
+export interface EditorHandle extends Component {
+    getValue(): string;
+    setValue(value: string): void;
+}
+export interface ComponentKit {
+    text(value: string): Component;
+    column(children: (Component | FlexItem)[]): Component;
+    scrollView(content: Component): Component;
+    editor(opts: {
+        placeholder?: string;
+        onSubmit?: (value: string) => void;
+    }): EditorHandle;
+}
+export declare const defaultKit: ComponentKit;

package/esm/harness/npm/src/tui/kit.js

@@ -0,0 +1,7 @@
+import { column, editor, scrollView, text } from 'mu-tui';
+export const defaultKit = {
+    text,
+    column,
+    scrollView,
+    editor,
+};

package/esm/harness/npm/src/tui/types.d.ts

@@ -0,0 +1,38 @@
+import type { Message } from 'mu-core';
+import type { Component, Terminal, TUI } from 'mu-tui';
+import type { Channel } from '../channels/index.js';
+import type { ComponentKit } from './kit.js';
+export type ChatStatus = 'idle' | 'thinking' | 'error';
+export interface ChatContext {
+    channel: Channel;
+    components: ComponentKit;
+    renderMessage: (message: Message) => Component;
+    status: {
+        current: ChatStatus;
+    };
+}
+export interface ChatParts {
+    header: Component;
+    transcript: Component;
+    status: Component;
+    composer: Component;
+}
+export interface ChatSlots {
+    message?: (message: Message, ctx: ChatContext) => Component;
+    header?: (ctx: ChatContext) => Component;
+    transcript?: (ctx: ChatContext) => Component;
+    status?: (ctx: ChatContext) => Component;
+    composer?: (ctx: ChatContext) => Component;
+    layout?: (parts: ChatParts, ctx: ChatContext) => Component;
+}
+export interface ChatAppOptions {
+    terminal?: Terminal;
+    components?: Partial<ComponentKit>;
+    slots?: ChatSlots;
+    onExit?: () => void;
+}
+export interface ChatApp {
+    readonly tui: TUI;
+    start(): void;
+    stop(): void;
+}

package/esm/harness/npm/src/tui/types.js

@@ -0,0 +1 @@
+export {};

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/tui/src/capabilities.d.ts

@@ -0,0 +1,72 @@
+export type CapabilitySource = 'default' | 'env' | 'terminfo' | 'probe' | 'policy' | 'feature' | 'configured' | 'disabled';
+export interface Capability<T> {
+    value: T;
+    source: CapabilitySource;
+}
+export interface TerminalIdentity {
+    term: string;
+    program: string;
+    multiplexer: 'none' | 'tmux' | 'screen' | 'zellij' | 'unknown';
+    transport: 'tty' | 'pipe' | 'ssh' | 'conpty' | 'unknown';
+    platform: NodeJS.Platform;
+}
+export interface ScreenCapabilities {
+    alternateScreen: Capability<boolean>;
+}
+export interface ColorCapabilities {
+    ansi16: Capability<boolean>;
+    palette256: Capability<boolean>;
+    truecolor: Capability<boolean>;
+}
+export interface InputCapabilities {
+    legacy: Capability<boolean>;
+    xtermModifiedKeys: Capability<boolean>;
+    kittyKeyboard: Capability<boolean>;
+    bracketedPaste: Capability<boolean>;
+    focusEvents: Capability<boolean>;
+}
+export interface MouseCapabilities {
+    sgr: Capability<boolean>;
+    drag: Capability<boolean>;
+}
+export interface OscCapabilities {
+    title: Capability<boolean>;
+    hyperlinks: Capability<boolean>;
+    shellIntegration: Capability<boolean>;
+}
+export interface GraphicsCapabilities {
+    unicode: Capability<boolean>;
+    kitty: Capability<boolean>;
+    iterm2: Capability<boolean>;
+}
+export interface SecurityPolicy {
+    hyperlinks: 'deny' | 'allow';
+    clipboardWrite: 'deny' | 'ask' | 'allow';
+    clipboardRead: 'deny' | 'ask' | 'allow';
+    images: 'deny' | 'allow';
+    shellIntegration: 'deny' | 'allow';
+    maxPayloadBytes: number;
+}
+export interface Capabilities {
+    identity: TerminalIdentity;
+    screen: ScreenCapabilities;
+    colors: ColorCapabilities;
+    input: InputCapabilities;
+    mouse: MouseCapabilities;
+    osc: OscCapabilities;
+    graphics: GraphicsCapabilities;
+    security: SecurityPolicy;
+}
+export type PartialCapabilities = Partial<{
+    identity: Partial<TerminalIdentity>;
+    screen: Partial<ScreenCapabilities>;
+    colors: Partial<ColorCapabilities>;
+    input: Partial<InputCapabilities>;
+    mouse: Partial<MouseCapabilities>;
+    osc: Partial<OscCapabilities>;
+    graphics: Partial<GraphicsCapabilities>;
+    security: Partial<SecurityPolicy>;
+}>;
+export declare function capability<T>(value: T, source?: CapabilitySource): Capability<T>;
+export declare function createDefaultCapabilities(env?: NodeJS.ProcessEnv): Capabilities;
+export declare function mergeCapabilities(base: Capabilities, patch?: PartialCapabilities): Capabilities;

package/esm/tui/src/capabilities.js

@@ -0,0 +1,90 @@
+import process from 'node:process';
+export function capability(value, source = 'default') {
+    return { value, source };
+}
+export function createDefaultCapabilities(env = process.env) {
+    const term = env.TERM ?? 'dumb';
+    const program = env.TERM_PROGRAM ?? env.TERMINAL_EMULATOR ?? (env.KITTY_WINDOW_ID ? 'kitty' : 'unknown');
+    const multiplexer = detectMultiplexer(env);
+    const transport = detectTransport(env);
+    const truecolor = env.COLORTERM === 'truecolor' || env.COLORTERM === '24bit';
+    const modernTerm = /xterm|kitty|wezterm|ghostty|alacritty|foot|tmux|screen|vte|rxvt|iterm|mintty/i.test(term);
+    return {
+        identity: {
+            term,
+            program,
+            multiplexer,
+            transport,
+            platform: process.platform,
+        },
+        screen: {
+            alternateScreen: capability(modernTerm, modernTerm ? 'env' : 'default'),
+        },
+        colors: {
+            ansi16: capability(term !== 'dumb'),
+            palette256: capability(term.includes('256color'), term.includes('256color') ? 'env' : 'default'),
+            truecolor: capability(truecolor, truecolor ? 'env' : 'default'),
+        },
+        input: {
+            legacy: capability(true),
+            xtermModifiedKeys: capability(modernTerm, modernTerm ? 'env' : 'default'),
+            kittyKeyboard: capability(Boolean(env.KITTY_WINDOW_ID), env.KITTY_WINDOW_ID ? 'env' : 'default'),
+            bracketedPaste: capability(modernTerm, modernTerm ? 'env' : 'default'),
+            focusEvents: capability(modernTerm, modernTerm ? 'env' : 'default'),
+        },
+        mouse: {
+            sgr: capability(modernTerm, modernTerm ? 'env' : 'default'),
+            drag: capability(modernTerm, modernTerm ? 'env' : 'default'),
+        },
+        osc: {
+            title: capability(modernTerm, modernTerm ? 'env' : 'default'),
+            hyperlinks: capability(modernTerm, modernTerm ? 'env' : 'default'),
+            shellIntegration: capability(false),
+        },
+        graphics: {
+            unicode: capability(true),
+            kitty: capability(Boolean(env.KITTY_WINDOW_ID), env.KITTY_WINDOW_ID ? 'env' : 'default'),
+            iterm2: capability(program === 'iTerm.app', program === 'iTerm.app' ? 'env' : 'default'),
+        },
+        security: {
+            hyperlinks: 'allow',
+            clipboardWrite: 'deny',
+            clipboardRead: 'deny',
+            images: 'deny',
+            shellIntegration: 'deny',
+            maxPayloadBytes: 1024 * 1024,
+        },
+    };
+}
+export function mergeCapabilities(base, patch) {
+    if (!patch)
+        return base;
+    return {
+        identity: { ...base.identity, ...patch.identity },
+        screen: { ...base.screen, ...patch.screen },
+        colors: { ...base.colors, ...patch.colors },
+        input: { ...base.input, ...patch.input },
+        mouse: { ...base.mouse, ...patch.mouse },
+        osc: { ...base.osc, ...patch.osc },
+        graphics: { ...base.graphics, ...patch.graphics },
+        security: { ...base.security, ...patch.security },
+    };
+}
+function detectMultiplexer(env) {
+    if (env.TMUX)
+        return 'tmux';
+    if (env.STY)
+        return 'screen';
+    if (env.ZELLIJ)
+        return 'zellij';
+    return 'none';
+}
+function detectTransport(env) {
+    if (env.SSH_TTY || env.SSH_CONNECTION)
+        return 'ssh';
+    if (env.WT_SESSION || process.platform === 'win32')
+        return 'conpty';
+    if (process.stdin.isTTY && process.stdout.isTTY)
+        return 'tty';
+    return 'pipe';
+}

package/esm/tui/src/components/command-palette.d.ts

@@ -0,0 +1,24 @@
+import type { InputEvent } from '../events';
+import type { Component, Surface } from '../surface';
+export interface Command {
+    id: string;
+    label: string;
+    run: () => void;
+}
+export interface CommandPaletteOptions {
+    onRun: (command: Command) => void;
+    placeholder?: string;
+    width?: number;
+}
+export declare class CommandPalette implements Component {
+    private readonly commands;
+    private readonly query;
+    private readonly list;
+    private readonly width;
+    private readonly onRun;
+    constructor(commands: Command[], opts: CommandPaletteOptions);
+    render(s: Surface): void;
+    handleInput(event: InputEvent): void;
+    private refilter;
+}
+export declare const commandPalette: (commands: Command[], opts: CommandPaletteOptions) => CommandPalette;

package/esm/tui/src/components/command-palette.js

@@ -0,0 +1,60 @@
+import { box } from '../views';
+import { editor } from './editor';
+import { selectList } from './select-list';
+export class CommandPalette {
+    commands;
+    query;
+    list;
+    width;
+    onRun;
+    constructor(commands, opts) {
+        this.commands = commands;
+        this.onRun = opts.onRun;
+        this.width = opts.width ?? 60;
+        this.query = editor({ placeholder: opts.placeholder ?? 'Rechercher une commande…' });
+        this.list = selectList([]);
+        this.refilter();
+    }
+    render(s) {
+        s.fill({ x: 0, y: 0, width: s.width, height: s.height }, '#000000', 0.5);
+        const panel = {
+            render: (ps) => {
+                ps.child(this.query, { x: 0, y: 0, width: ps.width, height: 1 }, { focused: true });
+                const listHeight = ps.measure(this.list, ps.width);
+                ps.child(this.list, { x: 0, y: 1, width: ps.width, height: listHeight });
+            },
+        };
+        const boxed = box(panel, { border: true, background: '#1c1c1c' });
+        const w = Math.min(this.width, Math.max(0, s.width - 2));
+        const h = Math.min(s.measure(boxed, w), Math.max(0, s.height - 2));
+        const x = Math.max(0, Math.floor((s.width - w) / 2));
+        const y = Math.max(0, Math.floor((s.height - h) / 3));
+        s.child(boxed, { x, y, width: w, height: h });
+    }
+    handleInput(event) {
+        if (event.type === 'key' && event.kind !== 'release') {
+            if (event.key === 'up') {
+                this.list.move(-1);
+                return;
+            }
+            if (event.key === 'down') {
+                this.list.move(1);
+                return;
+            }
+            if (event.key === 'enter') {
+                const item = this.list.selectedItem();
+                if (item)
+                    this.onRun(item.value);
+                return;
+            }
+        }
+        this.query.handleInput(event);
+        this.refilter();
+    }
+    refilter() {
+        const query = this.query.getValue().toLowerCase();
+        const matched = this.commands.filter((command) => command.label.toLowerCase().includes(query));
+        this.list.setItems(matched.map((command) => ({ label: command.label, value: command })));
+    }
+}
+export const commandPalette = (commands, opts) => new CommandPalette(commands, opts);

package/esm/tui/src/components/editor.d.ts

@@ -0,0 +1,26 @@
+import type { InputEvent } from '../events';
+import type { Component, Surface } from '../surface';
+export interface EditorOptions {
+    value?: string;
+    placeholder?: string;
+    onSubmit?: (value: string) => void;
+    onChange?: (value: string) => void;
+}
+export declare class Editor implements Component {
+    private value;
+    private cursor;
+    private scroll;
+    private readonly placeholder;
+    onSubmit?: (value: string) => void;
+    onChange?: (value: string) => void;
+    constructor(opts?: EditorOptions);
+    getValue(): string;
+    setValue(value: string): void;
+    render(s: Surface): void;
+    handleInput(event: InputEvent): void;
+    private handleKey;
+    private insert;
+    private backspace;
+    private deleteForward;
+}
+export declare const editor: (opts?: EditorOptions) => Editor;

package/esm/tui/src/components/editor.js

@@ -0,0 +1,111 @@
+import { sliceByColumn } from '../utils';
+const CURSOR = '\x1b[7m';
+const RESET = '\x1b[0m';
+const DIM = '\x1b[2m';
+export class Editor {
+    value;
+    cursor;
+    scroll = 0;
+    placeholder;
+    onSubmit;
+    onChange;
+    constructor(opts = {}) {
+        this.value = opts.value ?? '';
+        this.cursor = this.value.length;
+        this.placeholder = opts.placeholder ?? '';
+        this.onSubmit = opts.onSubmit;
+        this.onChange = opts.onChange;
+    }
+    getValue() {
+        return this.value;
+    }
+    setValue(value) {
+        this.value = value;
+        if (this.cursor > value.length)
+            this.cursor = value.length;
+        this.onChange?.(value);
+    }
+    render(s) {
+        const width = s.width;
+        if (width <= 0)
+            return;
+        if (this.value.length === 0 && this.placeholder && !s.focused) {
+            s.text(0, 0, `${DIM}${sliceByColumn(this.placeholder, 0, width, true)}${RESET}`);
+            return;
+        }
+        if (this.cursor < this.scroll)
+            this.scroll = this.cursor;
+        else if (this.cursor >= this.scroll + width)
+            this.scroll = this.cursor - width + 1;
+        const visible = this.value.slice(this.scroll, this.scroll + width);
+        if (!s.focused) {
+            s.text(0, 0, visible);
+            return;
+        }
+        const col = this.cursor - this.scroll;
+        const before = visible.slice(0, col);
+        const at = visible.slice(col, col + 1) || ' ';
+        const after = visible.slice(col + 1);
+        s.text(0, 0, `${before}${CURSOR}${at}${RESET}${after}`);
+    }
+    handleInput(event) {
+        if (event.type === 'paste') {
+            this.insert(event.text.replace(/\n/g, ' '));
+            return;
+        }
+        if (event.type === 'text') {
+            this.insert(event.text);
+            return;
+        }
+        if (event.type !== 'key' || event.kind === 'release')
+            return;
+        this.handleKey(event);
+    }
+    handleKey(event) {
+        switch (event.key) {
+            case 'enter':
+                this.onSubmit?.(this.value);
+                return;
+            case 'backspace':
+                this.backspace();
+                return;
+            case 'delete':
+                this.deleteForward();
+                return;
+            case 'left':
+                this.cursor = Math.max(0, this.cursor - 1);
+                return;
+            case 'right':
+                this.cursor = Math.min(this.value.length, this.cursor + 1);
+                return;
+            case 'home':
+                this.cursor = 0;
+                return;
+            case 'end':
+                this.cursor = this.value.length;
+                return;
+            default:
+                if (event.text && !event.ctrl && !event.meta && !event.alt)
+                    this.insert(event.text);
+        }
+    }
+    insert(text) {
+        this.value = this.value.slice(0, this.cursor) + text + this.value.slice(this.cursor);
+        this.cursor += text.length;
+        this.onChange?.(this.value);
+    }
+    backspace() {
+        if (this.cursor === 0)
+            return;
+        this.value = this.value.slice(0, this.cursor - 1) + this.value.slice(this.cursor);
+        this.cursor -= 1;
+        this.onChange?.(this.value);
+    }
+    deleteForward() {
+        if (this.cursor >= this.value.length)
+            return;
+        this.value = this.value.slice(0, this.cursor) + this.value.slice(this.cursor + 1);
+        this.onChange?.(this.value);
+    }
+}
+export const editor = (opts) => new Editor(opts);

package/esm/tui/src/components/scroll-view.d.ts

@@ -0,0 +1,14 @@
+import type { InputEvent } from '../events';
+import type { Component, Surface } from '../surface';
+export declare class ScrollView implements Component {
+    private content;
+    private scrollY;
+    private stick;
+    constructor(content: Component);
+    setContent(content: Component): void;
+    scrollToBottom(): void;
+    render(s: Surface): void;
+    handleInput(event: InputEvent): void;
+    private scrollBy;
+}
+export declare const scrollView: (content: Component) => ScrollView;

package/esm/tui/src/components/scroll-view.js

@@ -0,0 +1,45 @@
+export class ScrollView {
+    content;
+    scrollY = 0;
+    stick = true;
+    constructor(content) {
+        this.content = content;
+    }
+    setContent(content) {
+        this.content = content;
+    }
+    scrollToBottom() {
+        this.stick = true;
+    }
+    render(s) {
+        const contentHeight = s.measure(this.content, s.width);
+        if (Number.isFinite(s.height)) {
+            const maxScroll = Math.max(0, contentHeight - s.height);
+            if (!this.stick && this.scrollY >= maxScroll)
+                this.stick = true;
+            this.scrollY = this.stick ? maxScroll : Math.min(this.scrollY, maxScroll);
+        }
+        const scroll = Number.isFinite(s.height) ? this.scrollY : 0;
+        s.child(this.content, { x: 0, y: -scroll, width: s.width, height: contentHeight });
+    }
+    handleInput(event) {
+        if (event.type === 'mouse' && event.kind === 'wheel') {
+            if (event.button === 'wheelUp')
+                this.scrollBy(-1);
+            else if (event.button === 'wheelDown')
+                this.scrollBy(1);
+            return;
+        }
+        if (event.type !== 'key' || event.kind === 'release')
+            return;
+        if (event.key === 'up')
+            this.scrollBy(-1);
+        else if (event.key === 'down')
+            this.scrollBy(1);
+    }
+    scrollBy(delta) {
+        this.stick = false;
+        this.scrollY = Math.max(0, this.scrollY + delta);
+    }
+}
+export const scrollView = (content) => new ScrollView(content);

package/esm/tui/src/components/select-list.d.ts

@@ -0,0 +1,24 @@
+import type { InputEvent } from '../events';
+import type { Component, Surface } from '../surface';
+export interface SelectItem<T> {
+    label: string;
+    value: T;
+}
+export declare class SelectList<T> implements Component {
+    private items;
+    private selected;
+    private top;
+    private readonly maxRows;
+    onSelect?: (item: SelectItem<T>) => void;
+    constructor(items?: SelectItem<T>[], opts?: {
+        maxRows?: number;
+    });
+    setItems(items: SelectItem<T>[]): void;
+    selectedItem(): SelectItem<T> | undefined;
+    move(delta: number): void;
+    render(s: Surface): void;
+    handleInput(event: InputEvent): void;
+}
+export declare const selectList: <T>(items?: SelectItem<T>[], opts?: {
+    maxRows?: number;
+}) => SelectList<T>;

package/esm/tui/src/components/select-list.js

@@ -0,0 +1,69 @@
+import { truncateToWidth, visibleWidth } from '../utils';
+const SELECTED = '\x1b[7m';
+const RESET = '\x1b[0m';
+const pad = (value, width) => {
+    const fitted = visibleWidth(value) > width ? truncateToWidth(value, width) : value;
+    const gap = width - visibleWidth(fitted);
+    return gap > 0 ? fitted + ' '.repeat(gap) : fitted;
+};
+export class SelectList {
+    items;
+    selected = 0;
+    top = 0;
+    maxRows;
+    onSelect;
+    constructor(items = [], opts = {}) {
+        this.items = items;
+        this.maxRows = opts.maxRows ?? 10;
+    }
+    setItems(items) {
+        this.items = items;
+        if (this.selected >= items.length)
+            this.selected = Math.max(0, items.length - 1);
+    }
+    selectedItem() {
+        return this.items[this.selected];
+    }
+    move(delta) {
+        if (this.items.length === 0)
+            return;
+        this.selected = (this.selected + delta + this.items.length) % this.items.length;
+    }
+    render(s) {
+        const rows = Math.min(this.items.length, this.maxRows, s.height === Infinity ? this.maxRows : s.height);
+        if (this.selected < this.top)
+            this.top = this.selected;
+        else if (this.selected >= this.top + rows)
+            this.top = this.selected - rows + 1;
+        for (let i = 0; i < rows; i++) {
+            const index = this.top + i;
+            const item = this.items[index];
+            if (!item)
+                break;
+            const line = pad(item.label, s.width);
+            s.text(0, i, index === this.selected ? `${SELECTED}${line}${RESET}` : line);
+        }
+    }
+    handleInput(event) {
+        if (event.type === 'mouse' && event.kind === 'press' && event.button === 'left') {
+            const index = this.top + (event.localY ?? 0);
+            if (index >= 0 && index < this.items.length) {
+                this.selected = index;
+                this.onSelect?.(this.items[index]);
+            }
+            return;
+        }
+        if (event.type !== 'key' || event.kind === 'release')
+            return;
+        if (event.key === 'up')
+            this.move(-1);
+        else if (event.key === 'down')
+            this.move(1);
+        else if (event.key === 'enter') {
+            const item = this.selectedItem();
+            if (item)
+                this.onSelect?.(item);
+        }
+    }
+}
+export const selectList = (items, opts) => new SelectList(items ?? [], opts ?? {});