@travisennis/acai 0.0.1

package/source/terminal/index.ts

@@ -0,0 +1,518 @@
+/**
+ * Terminal Interface Module
+ *
+ * Provides a user interface for interacting with Claude Code in the terminal.
+ * Handles input/output, formatting, and display.
+ */
+
+import chalk, { type ChalkInstance } from "chalk";
+import Table from "cli-table3";
+import ora from "ora";
+import wrapAnsi from "wrap-ansi";
+import { logger } from "../logger.ts";
+import { getPackageVersion } from "../version.ts";
+import {
+  clearTerminal,
+  getTerminalSize,
+  setTerminalTitle,
+  link as terminalLink,
+} from "./formatting.ts";
+import { applyMarkdown } from "./markdown.ts";
+import type { SpinnerInstance, TerminalConfig } from "./types.ts";
+
+/**
+ * Initialize the terminal interface
+ */
+export function initTerminal(config: Partial<TerminalConfig> = {}): Terminal {
+  logger.debug("Initializing terminal interface");
+
+  const terminalConfig: 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 {
+  private config: TerminalConfig;
+  private activeSpinners: Map<string, SpinnerInstance> = new Map();
+  private terminalWidth: number;
+  private terminalHeight: number;
+  private isInteractive: boolean;
+
+  constructor(config: TerminalConfig) {
+    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: string) {
+    setTerminalTitle(title);
+  }
+
+  getLogo(): string {
+    return `
+   █████╗  ██████╗ █████╗ ██╗
+  ██╔══██╗██╔════╝██╔══██╗██║
+  ███████║██║     ███████║██║
+  ██╔══██║██║     ██╔══██║██║
+  ██║  ██║╚██████╗██║  ██║██║
+  ╚═╝  ╚═╝ ╚═════╝╚═╝  ╚═╝╚═╝
+                                       `;
+  }
+
+  /**
+   * Display the welcome message
+   */
+  displayWelcome(): void {
+    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(): void {
+    if (this.isInteractive) {
+      clearTerminal();
+    }
+  }
+
+  /**
+   * Display formatted content
+   */
+  display(content: string, wrap = false): void {
+    this.writeln(this.formatMarkdown(content, wrap));
+  }
+
+  /**
+   * Display a message with emphasis
+   */
+  emphasize(message: string): void {
+    if (this.config.useColors) {
+      this.writeln(chalk.cyan.bold(message));
+    } else {
+      this.writeln(message.toUpperCase());
+    }
+  }
+
+  /**
+   * Display an informational message
+   */
+  info(message: string): void {
+    if (this.config.useColors) {
+      this.writeln(chalk.blue(`ℹ ${message}`));
+    } else {
+      this.writeln(`INFO: ${message}`);
+    }
+  }
+
+  /**
+   * Display a success message
+   */
+  success(message: string): void {
+    if (this.config.useColors) {
+      this.writeln(chalk.green(`✓ ${message}`));
+    } else {
+      this.writeln(`SUCCESS: ${message}`);
+    }
+  }
+
+  /**
+   * Display a warning message
+   */
+  warn(message: string): void {
+    if (this.config.useColors) {
+      this.writeln(chalk.yellow(`⚠ ${message}`));
+    } else {
+      this.writeln(`WARNING: ${message}`);
+    }
+  }
+
+  /**
+   * Display an error message
+   */
+  error(message: string): void {
+    if (this.config.useColors) {
+      this.writeln(chalk.red(`✗ ${message}`));
+    } else {
+      this.writeln(`ERROR: ${message}`);
+    }
+  }
+
+  /**
+   * Emits an alert.
+   */
+  alert(): void {
+    if (!this.isInteractive) {
+      return;
+    }
+
+    const t = "acai";
+    const b = "";
+    try {
+      process.stdout.write("\x07");
+      const esc = "\u001b";
+      const bel = "\u0007";
+      const safe = (s: string) =>
+        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: string): void {
+    process.stdout.write(input);
+  }
+
+  writeln(input: string): void {
+    process.stdout.write(`${input}\n`);
+  }
+
+  lineBreak() {
+    this.writeln("");
+  }
+
+  header(header: string, chalkFn: ChalkInstance = chalk.green): void {
+    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: string, content: string): Promise<void> {
+    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: string): string =>
+      // 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: ChalkInstance = chalk.gray): void {
+    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: string, url: string): string {
+    return terminalLink(text, url);
+  }
+
+  /**
+   * Display a table of data
+   */
+  table(
+    data: [string, string | number][],
+    options: { header?: string[]; colWidths?: number[] } = {},
+  ): void {
+    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: number[] = 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: string, id = "default"): SpinnerInstance {
+    // 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: SpinnerInstance = {
+        id,
+        update: (newText: string) => {
+          spinner.text = newText;
+          return spinnerInstance;
+        },
+        succeed: (text?: string) => {
+          spinner.succeed(text);
+          this.activeSpinners.delete(id);
+          return spinnerInstance;
+        },
+        fail: (text?: string) => {
+          spinner.fail(text);
+          this.activeSpinners.delete(id);
+          return spinnerInstance;
+        },
+        warn: (text?: string) => {
+          spinner.warn(text);
+          this.activeSpinners.delete(id);
+          return spinnerInstance;
+        },
+        info: (text?: string) => {
+          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: SpinnerInstance = {
+      id,
+      update: (newText: string) => {
+        if (newText !== text) {
+          console.info(newText);
+        }
+        return dummySpinner;
+      },
+      succeed: (text?: string) => {
+        if (text) {
+          this.success(text);
+        }
+        return dummySpinner;
+      },
+      fail: (text?: string) => {
+        if (text) {
+          this.error(text);
+        }
+        return dummySpinner;
+      },
+      warn: (text?: string) => {
+        if (text) {
+          this.warn(text);
+        }
+        return dummySpinner;
+      },
+      info: (text?: string) => {
+        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: number, total: number): void {
+    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: number): string => {
+      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}  `);
+  }
+
+  private formatMarkdown(content: string, wrap = false): string {
+    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.ts";

package/source/terminal/markdown-utils.ts

@@ -0,0 +1,89 @@
+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: string): boolean {
+  // 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: number): string {
+  if (i <= 0) {
+    return "";
+  }
+  const letters: string[] = [];
+  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: number): string {
+  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],
+  ] as const;
+
+  let num = i;
+  let result = "";
+  for (const [roman, value] of romanNumerals) {
+    while (num >= value) {
+      result += roman;
+      num -= value;
+    }
+  }
+  return result;
+}
+
+export function getListNumber(
+  listDepth: number,
+  orderedListNumber: number,
+): string {
+  switch (listDepth) {
+    case 0:
+    case 1:
+      return orderedListNumber.toString();
+    case 2:
+      return getDepth1ListNumber(orderedListNumber);
+    case 3:
+      return getDepth2ListNumber(orderedListNumber);
+    default:
+      return orderedListNumber.toString();
+  }
+}