@travisennis/acai 0.0.5 → 0.0.6

package/dist/tui/components/text.js

@@ -0,0 +1,143 @@
+import style from "../../terminal/style.js";
+import { visibleWidth } from "../utils.js";
+/**
+ * Text component - displays multi-line text with word wrapping
+ */
+export class Text {
+    text;
+    paddingX; // Left/right padding
+    paddingY; // Top/bottom padding
+    customBgRgb;
+    // Cache for rendered output
+    cachedText;
+    cachedWidth;
+    cachedLines;
+    constructor(text = "", paddingX = 1, paddingY = 1, customBgRgb) {
+        this.text = text;
+        this.paddingX = paddingX;
+        this.paddingY = paddingY;
+        this.customBgRgb = customBgRgb;
+    }
+    setText(text) {
+        this.text = text;
+        // Invalidate cache when text changes
+        this.cachedText = undefined;
+        this.cachedWidth = undefined;
+        this.cachedLines = undefined;
+    }
+    setCustomBgRgb(customBgRgb) {
+        this.customBgRgb = customBgRgb;
+        // Invalidate cache when color changes
+        this.cachedText = undefined;
+        this.cachedWidth = undefined;
+        this.cachedLines = undefined;
+    }
+    render(width) {
+        // Check cache
+        if (this.cachedLines &&
+            this.cachedText === this.text &&
+            this.cachedWidth === width) {
+            return this.cachedLines;
+        }
+        // Calculate available width for content (subtract horizontal padding)
+        const contentWidth = Math.max(1, width - this.paddingX * 2);
+        // Don't render anything if there's no actual text
+        if (!this.text || this.text.trim() === "") {
+            const result = [];
+            // Update cache
+            this.cachedText = this.text;
+            this.cachedWidth = width;
+            this.cachedLines = result;
+            return result;
+        }
+        // Replace tabs with 3 spaces for consistent rendering
+        const normalizedText = this.text.replace(/\t/g, "   ");
+        const lines = [];
+        const textLines = normalizedText.split("\n");
+        for (const line of textLines) {
+            // Measure visible length (strip ANSI codes)
+            const visibleLineLength = visibleWidth(line);
+            if (visibleLineLength <= contentWidth) {
+                lines.push(line);
+            }
+            else {
+                // Word wrap
+                const words = line.split(" ");
+                let currentLine = "";
+                for (const word of words) {
+                    const currentVisible = visibleWidth(currentLine);
+                    const wordVisible = visibleWidth(word);
+                    // If word is too long, truncate it
+                    let finalWord = word;
+                    if (wordVisible > contentWidth) {
+                        // Truncate word to fit
+                        let truncated = "";
+                        for (const char of word) {
+                            if (visibleWidth(truncated + char) > contentWidth) {
+                                break;
+                            }
+                            truncated += char;
+                        }
+                        finalWord = truncated;
+                    }
+                    if (currentVisible === 0) {
+                        currentLine = finalWord;
+                    }
+                    else if (currentVisible + 1 + visibleWidth(finalWord) <=
+                        contentWidth) {
+                        currentLine += ` ${finalWord}`;
+                    }
+                    else {
+                        lines.push(currentLine);
+                        currentLine = finalWord;
+                    }
+                }
+                if (currentLine.length > 0) {
+                    lines.push(currentLine);
+                }
+            }
+        }
+        // Add padding to each line
+        const leftPad = " ".repeat(this.paddingX);
+        const paddedLines = [];
+        for (const line of lines) {
+            // Calculate visible length (strip ANSI codes)
+            const visibleLength = visibleWidth(line);
+            // Right padding to fill to width (accounting for left padding and content)
+            const rightPadLength = Math.max(0, width - this.paddingX - visibleLength);
+            const rightPad = " ".repeat(rightPadLength);
+            let paddedLine = leftPad + line + rightPad;
+            // Apply background color if specified
+            if (this.customBgRgb) {
+                paddedLine = style.bgRgb(this.customBgRgb.r, this.customBgRgb.g, this.customBgRgb.b)(paddedLine);
+            }
+            paddedLines.push(paddedLine);
+        }
+        // Add top padding (empty lines)
+        const emptyLine = " ".repeat(width);
+        const topPadding = [];
+        for (let i = 0; i < this.paddingY; i++) {
+            let emptyPaddedLine = emptyLine;
+            if (this.customBgRgb) {
+                emptyPaddedLine = style.bgRgb(this.customBgRgb.r, this.customBgRgb.g, this.customBgRgb.b)(emptyPaddedLine);
+            }
+            topPadding.push(emptyPaddedLine);
+        }
+        // Add bottom padding (empty lines)
+        const bottomPadding = [];
+        for (let i = 0; i < this.paddingY; i++) {
+            let emptyPaddedLine = emptyLine;
+            if (this.customBgRgb) {
+                emptyPaddedLine = style.bgRgb(this.customBgRgb.r, this.customBgRgb.g, this.customBgRgb.b)(emptyPaddedLine);
+            }
+            bottomPadding.push(emptyPaddedLine);
+        }
+        // Combine top padding, content, and bottom padding
+        const result = [...topPadding, ...paddedLines, ...bottomPadding];
+        // Update cache
+        this.cachedText = this.text;
+        this.cachedWidth = width;
+        this.cachedLines = result;
+        return result.length > 0 ? result : [""];
+    }
+}

package/dist/tui/components/thinking-block.d.ts

@@ -0,0 +1,14 @@
+import { Container } from "../tui.ts";
+/**
+ * Component that renders a thinking block
+ */
+export declare class ThinkingBlockComponent extends Container {
+    private contentContainer;
+    constructor(message?: {
+        content: string;
+    });
+    updateContent(message: {
+        content: string;
+    }): void;
+}
+//# sourceMappingURL=thinking-block.d.ts.map

package/dist/tui/components/thinking-block.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thinking-block.d.ts","sourceRoot":"","sources":["../../../source/tui/components/thinking-block.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAItC;;GAEG;AACH,qBAAa,sBAAuB,SAAQ,SAAS;IACnD,OAAO,CAAC,gBAAgB,CAAY;gBAExB,OAAO,CAAC,EAAE;QACpB,OAAO,EAAE,MAAM,CAAC;KACjB;IAYD,aAAa,CAAC,OAAO,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;CAsBlD"}

package/dist/tui/components/thinking-block.js

@@ -0,0 +1,30 @@
+import style from "../../terminal/style.js";
+import { Container } from "../tui.js";
+import { Markdown } from "./markdown.js";
+import { Spacer } from "./spacer.js";
+/**
+ * Component that renders a thinking block
+ */
+export class ThinkingBlockComponent extends Container {
+    contentContainer;
+    constructor(message) {
+        super();
+        // Container for text/thinking content
+        this.contentContainer = new Container();
+        this.addChild(this.contentContainer);
+        if (message) {
+            this.updateContent(message);
+        }
+    }
+    updateContent(message) {
+        // Clear content container
+        this.contentContainer.clear();
+        if (message.content.length > 0) {
+            this.contentContainer.addChild(new Spacer(1));
+        }
+        const content = message.content;
+        // Assistant text messages with no background - trim the text
+        // Set paddingY=0 to avoid extra spacing before tool executions
+        this.contentContainer.addChild(new Markdown(style.dim(content.trim()), undefined, undefined, undefined, 1, 0));
+    }
+}

package/dist/tui/components/tool-execution.d.ts

@@ -0,0 +1,17 @@
+import type { ToolEvent } from "../../agent/index.ts";
+import { Container } from "../index.ts";
+export declare class ToolExecutionComponent extends Container {
+    private contentContainer;
+    private toolName;
+    private events;
+    constructor(event: ToolEvent);
+    update(event: ToolEvent): void;
+    private renderDisplay;
+    private getIndicator;
+    private handleToolInitMessage;
+    private handleToolUpdateMessage;
+    private handleToolCompletionMessage;
+    private handleToolErrorMessage;
+    private processEventsInOrder;
+}
+//# sourceMappingURL=tool-execution.d.ts.map

package/dist/tui/components/tool-execution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-execution.d.ts","sourceRoot":"","sources":["../../../source/tui/components/tool-execution.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAGtD,OAAO,EAAE,SAAS,EAAgB,MAAM,aAAa,CAAC;AAItD,qBAAa,sBAAuB,SAAQ,SAAS;IACnD,OAAO,CAAC,gBAAgB,CAAY;IACpC,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,MAAM,CAAc;gBAEhB,KAAK,EAAE,SAAS;IAY5B,MAAM,CAAC,KAAK,EAAE,SAAS;IAKvB,OAAO,CAAC,aAAa;IAwDrB,OAAO,CAAC,YAAY;IAgBpB,OAAO,CAAC,qBAAqB;IAU7B,OAAO,CAAC,uBAAuB;IAkB/B,OAAO,CAAC,2BAA2B;IAcnC,OAAO,CAAC,sBAAsB;IAI9B,OAAO,CAAC,oBAAoB;CA+C7B"}

package/dist/tui/components/tool-execution.js

@@ -0,0 +1,153 @@
+import { capitalize } from "../../formatting.js";
+import style from "../../terminal/style.js";
+import { Container, Spacer, Text } from "../index.js";
+export class ToolExecutionComponent extends Container {
+    contentContainer;
+    toolName;
+    events;
+    constructor(event) {
+        super();
+        this.toolName = event.name;
+        this.events = [event];
+        // Container for text/thinking content
+        this.contentContainer = new Container();
+        this.addChild(this.contentContainer);
+        this.renderDisplay();
+    }
+    update(event) {
+        this.events.push(event);
+        this.renderDisplay();
+    }
+    renderDisplay() {
+        // Clear content container
+        this.contentContainer.clear();
+        const lines = [];
+        // Build display from complete event history with proper ordering
+        const processedEvents = this.processEventsInOrder();
+        for (let i = 0; i < processedEvents.length; i++) {
+            const event = processedEvents[i];
+            const eventType = event.type;
+            switch (eventType) {
+                case "tool-call-start":
+                    lines.push(`${this.handleToolInitMessage(event)}`);
+                    break;
+                case "tool-call-update":
+                    lines.push(`├── ${this.handleToolUpdateMessage(event.msg)}`);
+                    break;
+                case "tool-call-end":
+                    lines.push(`└── ${this.handleToolCompletionMessage(event.msg)}`);
+                    break;
+                case "tool-call-error":
+                    lines.push(`└── ${this.handleToolErrorMessage(event.msg)}`);
+                    break;
+                default: {
+                    eventType;
+                }
+            }
+        }
+        // Render all lines with proper indicators
+        const currentStatus = this.events[this.events.length - 1].type;
+        const indicator = this.getIndicator(currentStatus);
+        const displayLines = [];
+        for (let i = 0; i < lines.length; i++) {
+            let line = lines[i];
+            if (i === 0) {
+                line = `${indicator} ${line}`;
+            }
+            displayLines.push(line);
+        }
+        this.contentContainer.addChild(new Spacer(1));
+        this.contentContainer.addChild(new Text(displayLines.join("\n"), 1, 1, {
+            r: 52,
+            g: 53,
+            b: 65,
+        }));
+    }
+    getIndicator(status) {
+        switch (status) {
+            case "tool-call-start":
+                return style.blue.bold("●");
+            case "tool-call-update":
+                return style.yellow.bold("●");
+            case "tool-call-end":
+                return style.green.bold("●");
+            case "tool-call-error":
+                return style.red.bold("●");
+            default:
+                status;
+        }
+        return style.blue.bold("●");
+    }
+    handleToolInitMessage(event) {
+        const message = event.msg;
+        let result = `${style.bold(capitalize(this.toolName))} `;
+        result += message.trim() ? `${style.bold(message)} ` : "";
+        result += style.dim(JSON.stringify(event.args).slice(0, 50));
+        return result;
+    }
+    handleToolUpdateMessage(message) {
+        const newlineIndex = message.indexOf("\n");
+        let result = "";
+        if (newlineIndex === -1) {
+            result += style.bold(message);
+        }
+        else {
+            const firstLine = message.slice(0, newlineIndex);
+            // const remainingLines = message.slice(newlineIndex + 1);
+            result += style.bold(firstLine);
+            // if (remainingLines.trim()) {
+            //   terminal.display(remainingLines);
+            // }
+        }
+        return result;
+    }
+    handleToolCompletionMessage(message) {
+        const newlineIndex = message.indexOf("\n");
+        let result = "";
+        if (newlineIndex === -1) {
+            result += style.bold(message);
+        }
+        else {
+            const firstLine = message.slice(0, newlineIndex);
+            result += style.bold(firstLine);
+        }
+        return result;
+    }
+    handleToolErrorMessage(message) {
+        return style.bold.red(message);
+    }
+    processEventsInOrder() {
+        const events = [...this.events];
+        const processed = [];
+        // Ensure we have a tool-call-start event
+        const hasStartEvent = events.some((event) => event.type === "tool-call-start");
+        if (!hasStartEvent && events.length > 0) {
+            // Create synthetic start event using the first event's name
+            const firstEvent = events[0];
+            processed.push({
+                type: "tool-call-start",
+                name: firstEvent.name,
+                toolCallId: firstEvent.toolCallId,
+                msg: "",
+                args: firstEvent.args,
+            });
+        }
+        // Process events in the correct order: start → update → end/error
+        const startEvents = events.filter((event) => event.type === "tool-call-start");
+        const updateEvents = events.filter((event) => event.type === "tool-call-update");
+        const endEvents = events.filter((event) => event.type === "tool-call-end");
+        const errorEvents = events.filter((event) => event.type === "tool-call-error");
+        // Add start events first
+        processed.push(...startEvents);
+        // Add update events
+        processed.push(...updateEvents);
+        // Add end or error events (only one should be present)
+        if (endEvents.length > 0) {
+            processed.push(...endEvents);
+        }
+        else if (errorEvents.length > 0) {
+            processed.push(...errorEvents);
+        }
+        return processed;
+    }
+}

package/dist/tui/components/user-message.d.ts

@@ -0,0 +1,9 @@
+import { Container } from "../tui.ts";
+/**
+ * Component that renders a user message
+ */
+export declare class UserMessageComponent extends Container {
+    private markdown;
+    constructor(text: string);
+}
+//# sourceMappingURL=user-message.d.ts.map

package/dist/tui/components/user-message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-message.d.ts","sourceRoot":"","sources":["../../../source/tui/components/user-message.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAItC;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,SAAS;IACjD,OAAO,CAAC,QAAQ,CAAW;gBAEf,IAAI,EAAE,MAAM;CAezB"}

package/dist/tui/components/user-message.js

@@ -0,0 +1,21 @@
+import { Container } from "../tui.js";
+import { Markdown } from "./markdown.js";
+import { Spacer } from "./spacer.js";
+/**
+ * Component that renders a user message
+ */
+export class UserMessageComponent extends Container {
+    markdown;
+    constructor(text) {
+        super();
+        this.addChild(new Spacer(1));
+        // User messages with dark gray background
+        this.markdown = new Markdown(text, undefined, undefined, {
+            r: 52,
+            g: 53,
+            b: 65,
+        });
+        this.addChild(this.markdown);
+        this.addChild(new Spacer(1));
+    }
+}

package/dist/tui/components/welcome.d.ts

@@ -0,0 +1,6 @@
+import type { Component } from "../tui.ts";
+export declare class Welcome implements Component {
+    render(_width: number): string[];
+    private getLogo;
+}
+//# sourceMappingURL=welcome.d.ts.map

package/dist/tui/components/welcome.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"welcome.d.ts","sourceRoot":"","sources":["../../../source/tui/components/welcome.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE3C,qBAAa,OAAQ,YAAW,SAAS;IACvC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE;IAiChC,OAAO,CAAC,OAAO;CAUhB"}

package/dist/tui/components/welcome.js

@@ -0,0 +1,30 @@
+import style from "../../terminal/style.js";
+import { getPackageVersion } from "../../version.js";
+export class Welcome {
+    render(_width) {
+        const version = getPackageVersion();
+        const result = [];
+        result.push(style.magenta(this.getLogo()));
+        result.push("");
+        result.push(style.magenta("Greetings! I am acai."));
+        result.push(style.gray(`  Version ${version}`));
+        result.push("");
+        result.push(style.white(`  Type ${style.cyan("/help")} to see available commands.`));
+        result.push(style.white("  You can ask acai to explain code, fix issues, or perform tasks."));
+        result.push(style.white(`  Example: "${style.italic("Please analyze this codebase and explain its structure.")}"`));
+        result.push(style.dim("  Use Ctrl+C to interrupt acai and exit."));
+        result.push("");
+        result.push(style.yellow(`The current working directory is ${process.cwd()}`));
+        return result;
+    }
+    getLogo() {
+        return `
+   █████╗  ██████╗ █████╗ ██╗
+  ██╔══██╗██╔════╝██╔══██╗██║
+  ███████║██║     ███████║██║
+  ██╔══██║██║     ██╔══██║██║
+  ██║  ██║╚██████╗██║  ██║██║
+  ╚═╝  ╚═╝ ╚═════╝╚═╝  ╚═╝╚═╝
+                                       `;
+    }
+}

package/dist/tui/index.d.ts

@@ -0,0 +1,14 @@
+export { type AutocompleteItem, type AutocompleteProvider, CombinedAutocompleteProvider, type SlashCommand, } from "./autocomplete.ts";
+export { Editor, type TextEditorConfig } from "./components/editor.ts";
+export { Input } from "./components/input.ts";
+export { Loader } from "./components/loader.ts";
+export { Markdown } from "./components/markdown.ts";
+export { Modal, ModalTable, ModalText } from "./components/modal.ts";
+export { type SelectItem, SelectList } from "./components/select-list.ts";
+export { Spacer } from "./components/spacer.ts";
+export { Text } from "./components/text.ts";
+export { UserMessageComponent } from "./components/user-message.ts";
+export { ProcessTerminal, type Terminal } from "./terminal.ts";
+export { type Component, Container, TUI } from "./tui.ts";
+export { visibleWidth } from "./utils.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/tui/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/tui/index.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,EACzB,4BAA4B,EAC5B,KAAK,YAAY,GAClB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,MAAM,EAAE,KAAK,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AACvE,OAAO,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAC9C,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACpD,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACrE,OAAO,EAAE,KAAK,UAAU,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAC1E,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAChD,OAAO,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAC;AAC5C,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAEpE,OAAO,EAAE,eAAe,EAAE,KAAK,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC/D,OAAO,EAAE,KAAK,SAAS,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAE1D,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC"}

package/dist/tui/index.js

@@ -0,0 +1,18 @@
+// Core TUI interfaces and classes
+// Autocomplete support
+export { CombinedAutocompleteProvider, } from "./autocomplete.js";
+// Components
+export { Editor } from "./components/editor.js";
+export { Input } from "./components/input.js";
+export { Loader } from "./components/loader.js";
+export { Markdown } from "./components/markdown.js";
+export { Modal, ModalTable, ModalText } from "./components/modal.js";
+export { SelectList } from "./components/select-list.js";
+export { Spacer } from "./components/spacer.js";
+export { Text } from "./components/text.js";
+export { UserMessageComponent } from "./components/user-message.js";
+// Terminal interface and implementations
+export { ProcessTerminal } from "./terminal.js";
+export { Container, TUI } from "./tui.js";
+// Utilities
+export { visibleWidth } from "./utils.js";

package/dist/tui/terminal.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Minimal terminal interface for TUI
+ */
+export interface Terminal {
+    start(onInput: (data: string) => void, onResize: () => void): void;
+    stop(): void;
+    write(data: string): void;
+    get columns(): number;
+    get rows(): number;
+    moveBy(lines: number): void;
+    hideCursor(): void;
+    showCursor(): void;
+    clearLine(): void;
+    clearFromCursor(): void;
+    clearScreen(): void;
+}
+/**
+ * Real terminal using process.stdin/stdout
+ */
+export declare class ProcessTerminal implements Terminal {
+    private wasRaw;
+    private inputHandler?;
+    private resizeHandler?;
+    private rl?;
+    start(onInput: (data: string) => void, onResize: () => void): void;
+    stop(): void;
+    write(data: string): void;
+    get columns(): number;
+    get rows(): number;
+    moveBy(lines: number): void;
+    hideCursor(): void;
+    showCursor(): void;
+    clearLine(): void;
+    clearFromCursor(): void;
+    clearScreen(): void;
+}
+//# sourceMappingURL=terminal.d.ts.map

package/dist/tui/terminal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminal.d.ts","sourceRoot":"","sources":["../../source/tui/terminal.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,QAAQ;IAEvB,KAAK,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI,CAAC;IAGnE,IAAI,IAAI,IAAI,CAAC;IAGb,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAG1B,IAAI,OAAO,IAAI,MAAM,CAAC;IACtB,IAAI,IAAI,IAAI,MAAM,CAAC;IAGnB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAG5B,UAAU,IAAI,IAAI,CAAC;IACnB,UAAU,IAAI,IAAI,CAAC;IAGnB,SAAS,IAAI,IAAI,CAAC;IAClB,eAAe,IAAI,IAAI,CAAC;IACxB,WAAW,IAAI,IAAI,CAAC;CACrB;AAID;;GAEG;AACH,qBAAa,eAAgB,YAAW,QAAQ;IAC9C,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,YAAY,CAAC,CAAyB;IAC9C,OAAO,CAAC,aAAa,CAAC,CAAa;IACnC,OAAO,CAAC,EAAE,CAAC,CAAqB;IAEhC,KAAK,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI;IA2ClE,IAAI,IAAI,IAAI;IA0BZ,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAIzB,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAW3B,UAAU,IAAI,IAAI;IAIlB,UAAU,IAAI,IAAI;IAIlB,SAAS,IAAI,IAAI;IAIjB,eAAe,IAAI,IAAI;IAIvB,WAAW,IAAI,IAAI;CAGpB"}

package/dist/tui/terminal.js

@@ -0,0 +1,104 @@
+import readline from "node:readline";
+/**
+ * Real terminal using process.stdin/stdout
+ */
+export class ProcessTerminal {
+    wasRaw = false;
+    inputHandler;
+    resizeHandler;
+    rl;
+    start(onInput, onResize) {
+        this.inputHandler = onInput;
+        this.resizeHandler = onResize;
+        // Save previous state
+        this.wasRaw = process.stdin.isRaw || false;
+        // Check if we're in a TTY environment
+        const isTty = process.stdin.isTTY && process.stdout.isTTY;
+        if (isTty) {
+            // Create readline interface for reliable input handling
+            this.rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+                terminal: true,
+            });
+            // Enable raw mode for character-by-character input
+            if (process.stdin.setRawMode) {
+                process.stdin.setRawMode(true);
+            }
+            process.stdin.setEncoding("utf8");
+            process.stdin.resume();
+            // Enable bracketed paste mode - terminal will wrap pastes in \x1b[200~ ... \x1b[201~
+            process.stdout.write("\x1b[?2004h");
+            // Set up input handler
+            process.stdin.on("data", this.inputHandler);
+            process.stdout.on("resize", this.resizeHandler);
+        }
+        else {
+            console.warn("Not running in a TTY environment - input will not work");
+            // In non-TTY environments, we can't use raw mode
+            // But we can still set up basic input handling if needed
+            process.stdin.setEncoding("utf8");
+            if (process.stdin.isPaused()) {
+                process.stdin.resume();
+            }
+            process.stdin.on("data", this.inputHandler);
+        }
+    }
+    stop() {
+        // Disable bracketed paste mode
+        process.stdout.write("\x1b[?2004l");
+        // Remove event handlers
+        if (this.inputHandler) {
+            process.stdin.removeListener("data", this.inputHandler);
+            this.inputHandler = undefined;
+        }
+        if (this.resizeHandler) {
+            process.stdout.removeListener("resize", this.resizeHandler);
+            this.resizeHandler = undefined;
+        }
+        // Close readline interface
+        if (this.rl) {
+            this.rl.close();
+            this.rl = undefined;
+        }
+        // Restore raw mode state
+        if (process.stdin.setRawMode) {
+            process.stdin.setRawMode(this.wasRaw);
+        }
+    }
+    write(data) {
+        process.stdout.write(data);
+    }
+    get columns() {
+        return process.stdout.columns || 80;
+    }
+    get rows() {
+        return process.stdout.rows || 24;
+    }
+    moveBy(lines) {
+        if (lines > 0) {
+            // Move down
+            process.stdout.write(`\x1b[${lines}B`);
+        }
+        else if (lines < 0) {
+            // Move up
+            process.stdout.write(`\x1b[${-lines}A`);
+        }
+        // lines === 0: no movement
+    }
+    hideCursor() {
+        process.stdout.write("\x1b[?25l");
+    }
+    showCursor() {
+        process.stdout.write("\x1b[?25h");
+    }
+    clearLine() {
+        process.stdout.write("\x1b[K");
+    }
+    clearFromCursor() {
+        process.stdout.write("\x1b[J");
+    }
+    clearScreen() {
+        process.stdout.write("\x1b[2J\x1b[H"); // Clear screen and move to home (1,1)
+    }
+}