@travisennis/acai 0.0.1

package/dist/source/terminal/index.js

@@ -0,0 +1,420 @@
+/**
+ * Terminal Interface Module
+ *
+ * Provides a user interface for interacting with Claude Code in the terminal.
+ * Handles input/output, formatting, and display.
+ */
+import chalk from "chalk";
+import Table from "cli-table3";
+import ora from "ora";
+import wrapAnsi from "wrap-ansi";
+import { logger } from "../logger.js";
+import { getPackageVersion } from "../version.js";
+import { clearTerminal, getTerminalSize, setTerminalTitle, link as terminalLink, } from "./formatting.js";
+import { applyMarkdown } from "./markdown.js";
+/**
+ * Initialize the terminal interface
+ */
+export function initTerminal(config = {}) {
+    logger.debug("Initializing terminal interface");
+    const terminalConfig = {
+        theme: config.theme || "system",
+        useColors: config.useColors !== false,
+        showProgressIndicators: config.showProgressIndicators !== false,
+        codeHighlighting: config.codeHighlighting !== false,
+        maxHeight: config.maxHeight,
+        maxWidth: config.maxWidth,
+    };
+    const terminal = new Terminal(terminalConfig);
+    try {
+        // Detect terminal capabilities
+        terminal.detectCapabilities();
+        return terminal;
+    }
+    catch (error) {
+        logger.warn(error, "Error initializing terminal interface:");
+        // Return a basic terminal interface even if there was an error
+        return terminal;
+    }
+}
+/**
+ * Terminal class for handling user interaction
+ */
+export class Terminal {
+    config;
+    activeSpinners = new Map();
+    terminalWidth;
+    terminalHeight;
+    isInteractive;
+    constructor(config) {
+        this.config = config;
+        // Get initial terminal size
+        const { rows, columns } = getTerminalSize();
+        this.terminalHeight = config.maxHeight || rows;
+        this.terminalWidth = config.maxWidth || columns;
+        // Assume interactive by default
+        this.isInteractive = process.stdout.isTTY && process.stdin.isTTY;
+        // Listen for terminal resize events
+        process.stdout.on("resize", () => {
+            const { rows, columns } = getTerminalSize();
+            this.terminalHeight = config.maxHeight || rows;
+            this.terminalWidth = config.maxWidth || columns;
+            logger.debug(`Terminal resized to ${columns}x${rows}`);
+        });
+    }
+    /**
+     * Detect terminal capabilities
+     */
+    detectCapabilities() {
+        // Check if the terminal is interactive
+        this.isInteractive = Boolean(process.stdout.isTTY && process.stdin.isTTY);
+        logger.debug({
+            isInteractive: this.isInteractive,
+            colorSupport: this.config.useColors ? "yes" : "no",
+            size: `${this.terminalWidth}x${this.terminalHeight}`,
+        }, "Terminal capabilities detected");
+    }
+    setTitle(title) {
+        setTerminalTitle(title);
+    }
+    getLogo() {
+        return `
+   █████╗  ██████╗ █████╗ ██╗
+  ██╔══██╗██╔════╝██╔══██╗██║
+  ███████║██║     ███████║██║
+  ██╔══██║██║     ██╔══██║██║
+  ██║  ██║╚██████╗██║  ██║██║
+  ╚═╝  ╚═╝ ╚═════╝╚═╝  ╚═╝╚═╝
+                                       `;
+    }
+    /**
+     * Display the welcome message
+     */
+    displayWelcome() {
+        this.clear();
+        const version = getPackageVersion();
+        this.writeln(chalk.magenta(this.getLogo()));
+        this.lineBreak();
+        this.writeln(chalk.magenta("Greetings! I am acai."));
+        this.writeln(chalk.gray(`  Version ${version}`));
+        this.lineBreak();
+        this.writeln(chalk.white(`  Type ${chalk.cyan("/help")} to see available commands.`));
+        this.writeln(chalk.white("  You can ask acai to explain code, fix issues, or perform tasks."));
+        this.writeln(chalk.white(`  Example: "${chalk.italic("Please analyze this codebase and explain its structure.")}"`));
+        this.writeln(chalk.dim("  Use Ctrl+C to interrupt acai and exit."));
+        this.lineBreak();
+        this.writeln(chalk.yellow(`The current working directory is ${process.cwd()}`));
+        this.lineBreak();
+    }
+    /**
+     * Clear the terminal screen
+     */
+    clear() {
+        if (this.isInteractive) {
+            clearTerminal();
+        }
+    }
+    /**
+     * Display formatted content
+     */
+    display(content, wrap = false) {
+        this.writeln(this.formatMarkdown(content, wrap));
+    }
+    /**
+     * Display a message with emphasis
+     */
+    emphasize(message) {
+        if (this.config.useColors) {
+            this.writeln(chalk.cyan.bold(message));
+        }
+        else {
+            this.writeln(message.toUpperCase());
+        }
+    }
+    /**
+     * Display an informational message
+     */
+    info(message) {
+        if (this.config.useColors) {
+            this.writeln(chalk.blue(`ℹ ${message}`));
+        }
+        else {
+            this.writeln(`INFO: ${message}`);
+        }
+    }
+    /**
+     * Display a success message
+     */
+    success(message) {
+        if (this.config.useColors) {
+            this.writeln(chalk.green(`✓ ${message}`));
+        }
+        else {
+            this.writeln(`SUCCESS: ${message}`);
+        }
+    }
+    /**
+     * Display a warning message
+     */
+    warn(message) {
+        if (this.config.useColors) {
+            this.writeln(chalk.yellow(`⚠ ${message}`));
+        }
+        else {
+            this.writeln(`WARNING: ${message}`);
+        }
+    }
+    /**
+     * Display an error message
+     */
+    error(message) {
+        if (this.config.useColors) {
+            this.writeln(chalk.red(`✗ ${message}`));
+        }
+        else {
+            this.writeln(`ERROR: ${message}`);
+        }
+    }
+    /**
+     * Emits an alert.
+     */
+    alert() {
+        if (!this.isInteractive) {
+            return;
+        }
+        const t = "acai";
+        const b = "";
+        try {
+            process.stdout.write("\x07");
+            const esc = "\u001b";
+            const bel = "\u0007";
+            const safe = (s) => s.replaceAll("\u0007", "").replaceAll("\u001b", "");
+            const payload = `${esc}]777;notify;${safe(t)};${safe(b)}${bel}`;
+            process.stdout.write(payload);
+        }
+        catch (err) {
+            logger.warn({ err }, "Failed to emit alert");
+        }
+    }
+    write(input) {
+        process.stdout.write(input);
+    }
+    writeln(input) {
+        process.stdout.write(`${input}\n`);
+    }
+    lineBreak() {
+        this.writeln("");
+    }
+    header(header, chalkFn = chalk.green) {
+        const cols = this.terminalWidth > 0 ? this.terminalWidth : 80;
+        const width = Math.max(0, cols - header.length - 4);
+        this.writeln(chalkFn(`\n── ${header} ${"─".repeat(width)}  `));
+    }
+    async box(header, content) {
+        const cols = this.terminalWidth > 0 ? this.terminalWidth : 80;
+        const width = Math.max(4, cols - 4);
+        // Helper to strip ANSI sequences for accurate visible-width calculation
+        const stripAnsi = (s) => 
+        // biome-ignore lint/suspicious/noControlCharactersInRegex: need to detect ansi control characters
+        s.replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, "");
+        const paddedHeader = ` ${header} `;
+        const headerVisibleLen = stripAnsi(paddedHeader).length;
+        const headerStartPos = 1;
+        // Top border with header (use visible header length)
+        const leftDashes = headerStartPos;
+        const rightDashes = Math.max(0, width - leftDashes - headerVisibleLen);
+        const topBorder = `┌${"─".repeat(leftDashes)}${paddedHeader}${"─".repeat(rightDashes)}┐`;
+        // Prepare inner content: format markdown first, then wrap to inner width
+        const innerWidth = Math.max(1, width - 2);
+        const formatted = applyMarkdown(content);
+        const wrapped = wrapAnsi(formatted, innerWidth, { trim: false });
+        const contentLines = wrapped
+            .split("\n")
+            .map((line) => {
+            const visibleLen = stripAnsi(line).length;
+            const padCount = Math.max(0, innerWidth - visibleLen);
+            return `│ ${line}${" ".repeat(padCount)} │`;
+        })
+            .join("\n");
+        // Bottom border
+        const bottomBorder = `└${"─".repeat(width)}┘`;
+        // Write the box
+        this.writeln(`${topBorder}\n${contentLines}\n${bottomBorder}`);
+    }
+    hr(chalkFn = chalk.gray) {
+        const cols = this.terminalWidth > 0 ? this.terminalWidth : 80;
+        this.writeln(chalkFn(`${"─".repeat(Math.max(1, cols - 1))} `));
+    }
+    /**
+     * Create a clickable link in the terminal if supported
+     */
+    link(text, url) {
+        return terminalLink(text, url);
+    }
+    /**
+     * Display a table of data
+     */
+    table(data, options = {}) {
+        const { header, colWidths } = options;
+        // Calculate column widths based on terminal width
+        const padding = 5; // Account for table borders and padding
+        const availableWidth = Math.max(10, this.terminalWidth - padding);
+        const colCount = header?.length ?? 1;
+        const width = Math.max(10, Math.floor(availableWidth / Math.max(1, colCount)));
+        const computedColWidths = colWidths
+            ? colWidths.map((percent) => Math.max(10, Math.floor((percent / 100) * availableWidth)))
+            : new Array(colCount).fill(width);
+        const table = new Table({
+            head: header,
+            colWidths: computedColWidths,
+            wordWrap: true, // Enable word wrapping for the description column
+        });
+        table.push(...data);
+        this.writeln(table.toString());
+    }
+    /**
+     * Create a spinner for showing progress
+     */
+    spinner(text, id = "default") {
+        // Clean up existing spinner with the same ID
+        if (this.activeSpinners.has(id)) {
+            this.activeSpinners.get(id)?.stop();
+            this.activeSpinners.delete(id);
+        }
+        // Create spinner only if progress indicators are enabled and terminal is interactive
+        if (this.config.showProgressIndicators && this.isInteractive) {
+            const spinner = ora({
+                text,
+                spinner: "dots",
+                color: "cyan",
+            }).start();
+            const spinnerInstance = {
+                id,
+                update: (newText) => {
+                    spinner.text = newText;
+                    return spinnerInstance;
+                },
+                succeed: (text) => {
+                    spinner.succeed(text);
+                    this.activeSpinners.delete(id);
+                    return spinnerInstance;
+                },
+                fail: (text) => {
+                    spinner.fail(text);
+                    this.activeSpinners.delete(id);
+                    return spinnerInstance;
+                },
+                warn: (text) => {
+                    spinner.warn(text);
+                    this.activeSpinners.delete(id);
+                    return spinnerInstance;
+                },
+                info: (text) => {
+                    spinner.info(text);
+                    this.activeSpinners.delete(id);
+                    return spinnerInstance;
+                },
+                clear: () => {
+                    spinner.clear();
+                    this.activeSpinners.delete(id);
+                    return spinnerInstance;
+                },
+                stop: () => {
+                    spinner.stop();
+                    this.activeSpinners.delete(id);
+                    return spinnerInstance;
+                },
+            };
+            this.activeSpinners.set(id, spinnerInstance);
+            return spinnerInstance;
+        }
+        // Fallback for non-interactive terminals or when progress indicators are disabled
+        console.info(text);
+        // Return a dummy spinner
+        const dummySpinner = {
+            id,
+            update: (newText) => {
+                if (newText !== text) {
+                    console.info(newText);
+                }
+                return dummySpinner;
+            },
+            succeed: (text) => {
+                if (text) {
+                    this.success(text);
+                }
+                return dummySpinner;
+            },
+            fail: (text) => {
+                if (text) {
+                    this.error(text);
+                }
+                return dummySpinner;
+            },
+            warn: (text) => {
+                if (text) {
+                    this.warn(text);
+                }
+                return dummySpinner;
+            },
+            info: (text) => {
+                if (text) {
+                    this.info(text);
+                }
+                return dummySpinner;
+            },
+            clear: () => {
+                return dummySpinner;
+            },
+            stop: () => {
+                return dummySpinner;
+            },
+        };
+        return dummySpinner;
+    }
+    /**
+     * Displays a horizontal progress bar in the console.
+     * @param current The current value.
+     * @param total The target value.
+     */
+    displayProgressBar(current, total) {
+        const terminalWidth = this.terminalWidth > 0 ? this.terminalWidth : 80; // Default to 80 if columns not available
+        // Function to format numbers concisely (e.g., 1.2K, 5M)
+        const formatNumber = (num) => {
+            if (num < 1000) {
+                return num.toString();
+            }
+            if (num < 1_000_000) {
+                return `${(num / 1000).toFixed(1)}K`;
+            }
+            if (num < 1_000_000_000) {
+                return `${(num / 1_000_000).toFixed(1)}M`;
+            }
+            return `${(num / 1_000_000_000).toFixed(1)}G`;
+        };
+        const currentFormatted = formatNumber(current);
+        const totalFormatted = formatNumber(total);
+        const progressText = `${currentFormatted}/${totalFormatted}`;
+        const progressTextLength = progressText.length + 1; // Add 1 for space
+        const progressBarMaxWidth = Math.max(1, terminalWidth - progressTextLength - 1);
+        const percentage = total === 0 ? 1 : current / total;
+        const filledWidth = Math.max(0, Math.min(progressBarMaxWidth, Math.floor(percentage * progressBarMaxWidth)));
+        const emptyWidth = Math.max(0, progressBarMaxWidth - filledWidth);
+        const a = chalk.yellow("─"); //"█"
+        const b = chalk.gray("─"); // "░"
+        const filledBar = a.repeat(filledWidth);
+        const emptyBar = b.repeat(emptyWidth);
+        // Use \r to move cursor to the beginning of the line for updates
+        this.writeln(`\r${filledBar}${emptyBar} ${progressText}  `);
+    }
+    formatMarkdown(content, wrap = false) {
+        const columns = this.terminalWidth;
+        const formatted = applyMarkdown(content);
+        if (wrap) {
+            return wrapAnsi(formatted, columns - 6, { trim: false });
+        }
+        return formatted;
+    }
+}
+// Re-export the types
+export * from "./types.js";

package/dist/source/terminal/markdown-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function isMarkdown(input: string): boolean;
+export declare function getListNumber(listDepth: number, orderedListNumber: number): string;

package/dist/source/terminal/markdown-utils.js

@@ -0,0 +1,81 @@
+const markdownHeaderRegex = /^#{1,6}\s/m;
+const markdownBoldRegex = /(\*\*|__)(.*?)\1/;
+const markdownItalicRegex = /(\*|_)(.*?)\1/;
+const markdownCodeRegex = /`{1,3}[^`]+`{1,3}/;
+const markdownLinkRegex = /\((.*?)\]\((.*?)\)/;
+const markdownBlockquoteRegex = /^>\s/m;
+const markdownUnorderedListRegex = /^-\s|\*\s|\+\s/m;
+const markdownOrderedListRegex = /^\d+\.\s/m;
+const markdownHorizontalRuleRegex = /^---$/m;
+const markdownImageRegex = /!\[(.*?)\]\((.*?)\)/;
+export function isMarkdown(input) {
+    // Simple heuristics: look for common markdown syntax
+    const markdownPatterns = [
+        markdownHeaderRegex, // headings
+        markdownBoldRegex, // bold
+        markdownItalicRegex, // italic
+        markdownCodeRegex, // inline code or code block
+        markdownLinkRegex, // links
+        markdownBlockquoteRegex, // blockquote
+        markdownUnorderedListRegex, // unordered list
+        markdownOrderedListRegex, // ordered list
+        markdownHorizontalRuleRegex, // horizontal rule
+        markdownImageRegex, // images
+    ];
+    return markdownPatterns.some((pattern) => pattern.test(input));
+}
+function getDepth1ListNumber(i) {
+    if (i <= 0) {
+        return "";
+    }
+    const letters = [];
+    let num = i;
+    while (num > 0) {
+        num--; // Adjust for 0-indexing
+        letters.unshift(String.fromCharCode(97 + (num % 26)));
+        num = Math.floor(num / 26);
+    }
+    return letters.join("");
+}
+function getDepth2ListNumber(i) {
+    if (i <= 0) {
+        return "";
+    }
+    const romanNumerals = [
+        ["m", 1000],
+        ["cm", 900],
+        ["d", 500],
+        ["cd", 400],
+        ["c", 100],
+        ["xc", 90],
+        ["l", 50],
+        ["xl", 40],
+        ["x", 10],
+        ["ix", 9],
+        ["v", 5],
+        ["iv", 4],
+        ["i", 1],
+    ];
+    let num = i;
+    let result = "";
+    for (const [roman, value] of romanNumerals) {
+        while (num >= value) {
+            result += roman;
+            num -= value;
+        }
+    }
+    return result;
+}
+export function getListNumber(listDepth, orderedListNumber) {
+    switch (listDepth) {
+        case 0:
+        case 1:
+            return orderedListNumber.toString();
+        case 2:
+            return getDepth1ListNumber(orderedListNumber);
+        case 3:
+            return getDepth2ListNumber(orderedListNumber);
+        default:
+            return orderedListNumber.toString();
+    }
+}

package/dist/source/terminal/markdown.d.ts

@@ -0,0 +1 @@
+export declare function applyMarkdown(content: string): string;

package/dist/source/terminal/markdown.js

@@ -0,0 +1,111 @@
+import { EOL } from "node:os";
+import chalk from "chalk";
+import { highlight, supportsLanguage } from "cli-highlight";
+import Table from "cli-table3";
+import { marked } from "marked";
+import { logger } from "../logger.js";
+import { link as terminalLink } from "./formatting.js";
+import { getListNumber } from "./markdown-utils.js";
+function logError(msg) {
+    logger.error(msg);
+}
+export function applyMarkdown(content) {
+    return marked
+        .lexer(content)
+        .map((token) => format(token))
+        .join("")
+        .trim();
+}
+function format(token, listDepth = 0, orderedListNumber = null, parent = null) {
+    switch (token.type) {
+        case "blockquote":
+            return chalk.dim.italic((token.tokens ?? [])
+                .map((_) => format(_))
+                .map((l) => `  ${l}`)
+                .join(""));
+        case "code": {
+            if (token.lang && supportsLanguage(token.lang)) {
+                return highlight(token.text, { language: token.lang }) + EOL;
+            }
+            logError(`Language not supported while highlighting code, falling back to markdown: ${token.lang}`);
+            return highlight(token.text, { language: "markdown" }) + EOL;
+        }
+        case "codespan":
+            // inline code
+            return chalk.blue(token.text);
+        case "em":
+            return chalk.italic((token.tokens ?? []).map((_) => format(_)).join(""));
+        case "strong":
+            return chalk.bold((token.tokens ?? []).map((_) => format(_)).join(""));
+        case "heading":
+            switch (token.depth) {
+                case 1: // h1
+                    return (chalk.bold.italic.underline((token.tokens ?? []).map((_) => format(_)).join("")) +
+                        EOL +
+                        EOL);
+                case 2: // h2
+                    return (chalk.bold((token.tokens ?? []).map((_) => format(_)).join("")) +
+                        EOL +
+                        EOL);
+                default: // h3+
+                    return (chalk.bold.dim((token.tokens ?? []).map((_) => format(_)).join("")) +
+                        EOL +
+                        EOL);
+            }
+        case "hr":
+            return "---";
+        case "image": {
+            const alt = (token.title ?? token.text ?? "").toString().trim();
+            if (alt.length > 0) {
+                return `[Image: ${alt} (${token.href})]`;
+            }
+            return `[Image: ${token.href}]`;
+        }
+        case "link":
+            return terminalLink(token.text, token.href);
+        case "list": {
+            return token.items
+                .map((_, index) => format(_, listDepth, token.ordered ? token.start + index : null, token))
+                .join("");
+        }
+        case "list_item":
+            return (token.tokens ?? [])
+                .map((_) => `${"  ".repeat(listDepth)}${format(_, listDepth + 1, orderedListNumber, token)}`)
+                .join("");
+        case "paragraph":
+            return (token.tokens ?? []).map((_) => format(_)).join("") + EOL;
+        case "space":
+            return EOL;
+        case "text": {
+            if (parent?.type === "list_item") {
+                return `${orderedListNumber === null ? "-" : `${getListNumber(listDepth, orderedListNumber)}.`} ${token.tokens ? token.tokens.map((_) => format(_, listDepth, orderedListNumber, token)).join("") : token.text}${EOL}`;
+            }
+            return token.text;
+        }
+        case "table": {
+            const header = Array.isArray(token.header)
+                ? token.header
+                : [token.header];
+            const rows = Array.isArray(token.rows) ? token.rows : [token.rows];
+            // Calculate column widths based on terminal width
+            const padding = 5; // Account for table borders and padding
+            const availableWidth = Math.max(10, (process.stdout.columns || 80) - padding);
+            const colCount = header?.length ?? 1;
+            const width = Math.max(10, Math.floor(availableWidth / Math.max(1, colCount)));
+            const computedColWidths = new Array(colCount).fill(width);
+            const table = new Table({
+                head: header.map((h) => h.text),
+                colWidths: computedColWidths,
+                wordWrap: true, // Enable word wrapping for the description column
+            });
+            table.push(...rows.map((row) => row.map((c) => c.text)));
+            return `${table.toString()}\n`;
+        }
+        case "del": {
+            return chalk.strikethrough(token.text);
+        }
+        default:
+            console.log(token.type);
+            return "";
+    }
+}

package/dist/source/terminal/types.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Terminal theme options
+ */
+type TerminalTheme = "dark" | "light" | "system";
+/**
+ * Terminal configuration
+ */
+export interface TerminalConfig {
+    /**
+     * Terminal color theme
+     */
+    theme: TerminalTheme;
+    /**
+     * Whether to use colors in output
+     */
+    useColors: boolean;
+    /**
+     * Whether to show progress indicators
+     */
+    showProgressIndicators: boolean;
+    /**
+     * Whether to enable syntax highlighting for code
+     */
+    codeHighlighting: boolean;
+    /**
+     * Maximum terminal height (rows)
+     */
+    maxHeight?: number | undefined;
+    /**
+     * Maximum terminal width (columns)
+     */
+    maxWidth?: number | undefined;
+}
+/**
+ * Spinner instance for progress indicators
+ */
+export interface SpinnerInstance {
+    /**
+     * Spinner identifier
+     */
+    id: string;
+    /**
+     * Update spinner text
+     */
+    update(text: string): SpinnerInstance;
+    /**
+     * Mark spinner as successful and stop
+     */
+    succeed(text?: string): SpinnerInstance;
+    /**
+     * Mark spinner as failed and stop
+     */
+    fail(text?: string): SpinnerInstance;
+    /**
+     * Mark spinner with warning and stop
+     */
+    warn(text?: string): SpinnerInstance;
+    /**
+     * Mark spinner with info and stop
+     */
+    info(text?: string): SpinnerInstance;
+    /**
+     * Clear spinner without any indicator
+     */
+    clear(): SpinnerInstance;
+    /**
+     * Stop spinner without any indicator
+     */
+    stop(): SpinnerInstance;
+}
+export {};

package/dist/source/terminal/types.js

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