@abacus-ai/cli 1.106.25008 → 2.0.0-canary.1

package/src/lib/text-utils.ts

@@ -0,0 +1,272 @@
+import { stripVTControlCharacters } from "node:util";
+import stringWidth from "string-width";
+
+import { stripAnsi, ansiRegex } from "./ansi.js";
+
+/**
+ * Dangerous ANSI sequences that affect parent terminal.
+ * These are stripped. Color codes (SGR - \x1b[...m) are preserved.
+ */
+const ESC = String.fromCharCode(27);
+const BEL = String.fromCharCode(7);
+const DANGEROUS_SEQUENCES: RegExp[] = [
+  new RegExp(ESC + "\\[2J", "g"), // Clear screen (ED - Erase Display)
+  new RegExp(ESC + "\\[H", "g"), // Cursor home
+  new RegExp(ESC + "\\[\\d+(;\\d+)?H", "g"), // Cursor position (CUP: row or row;col)
+  new RegExp(ESC + "c", "g"), // Reset terminal (RIS)
+  new RegExp(ESC + "\\[!p", "g"), // Soft reset (DECSTR)
+  new RegExp(ESC + "\\[\\?1049[hl]", "g"), // Alternate screen buffer
+  new RegExp(ESC + "\\[\\d*[ABCD]", "g"), // Cursor movement (up/down/forward/back)
+  new RegExp(ESC + "\\[s", "g"), // Save cursor position (SCP)
+  new RegExp(ESC + "\\[u", "g"), // Restore cursor position (RCP)
+  new RegExp(ESC + "\\[\\d*J", "g"), // Erase display variants (except colors)
+  new RegExp(ESC + "\\[\\d*K", "g"), // Erase line variants
+  new RegExp(ESC + "\\[\\?25[hl]", "g"), // Show/hide cursor
+  new RegExp(BEL, "g"), // Bell (BEL)
+];
+
+/**
+ * Strip dangerous terminal sequences but preserve colors.
+ *
+ * Preserved: \x1b[...m (SGR color codes like \x1b[31m for red, \x1b[0m for reset)
+ * Stripped: cursor movement, screen clearing, terminal resets, bell
+ */
+export function stripDangerousSequences(str: string): string {
+  let result = str;
+  for (const pattern of DANGEROUS_SEQUENCES) {
+    result = result.replace(pattern, "");
+  }
+  return result;
+}
+
+/**
+ * Trim leading and trailing empty lines.
+ */
+export function trimWhitespace(str: string): string {
+  const lines = str.split("\n");
+  let start = 0;
+  while (start < lines.length && lines[start]?.trim() === "") {
+    start++;
+  }
+  let end = lines.length - 1;
+  while (end >= 0 && lines[end]?.trim() === "") {
+    end--;
+  }
+  if (start > end) {
+    return "";
+  }
+  return lines.slice(start, end + 1).join("\n");
+}
+
+/**
+ * Calculates the maximum width of a multi-line ASCII art string.
+ * @param asciiArt The ASCII art string.
+ * @returns The length of the longest line in the ASCII art.
+ */
+export const getAsciiArtWidth = (asciiArt: string): number => {
+  if (!asciiArt) {
+    return 0;
+  }
+  const lines = asciiArt.split("\n");
+  return Math.max(...lines.map((line) => line.length));
+};
+
+/*
+ * -------------------------------------------------------------------------
+ *  Unicode‑aware helpers (work at the code‑point level rather than UTF‑16
+ *  code units so that surrogate‑pair emoji count as one "column".)
+ * ---------------------------------------------------------------------- */
+
+// Cache for code points to reduce GC pressure
+const codePointsCache = new Map<string, string[]>();
+const MAX_STRING_LENGTH_TO_CACHE = 1000;
+
+export function toCodePoints(str: string): string[] {
+  // ASCII fast path - check if all chars are ASCII (0-127)
+  let isAscii = true;
+  for (let i = 0; i < str.length; i++) {
+    if (str.charCodeAt(i) > 127) {
+      isAscii = false;
+      break;
+    }
+  }
+  if (isAscii) {
+    return str.split("");
+  }
+
+  // Cache short strings
+  if (str.length <= MAX_STRING_LENGTH_TO_CACHE) {
+    const cached = codePointsCache.get(str);
+    if (cached) {
+      return cached;
+    }
+  }
+
+  const result = Array.from(str);
+
+  // Cache result (unlimited like Ink)
+  if (str.length <= MAX_STRING_LENGTH_TO_CACHE) {
+    codePointsCache.set(str, result);
+  }
+
+  return result;
+}
+
+export function cpLen(str: string): number {
+  return toCodePoints(str).length;
+}
+
+export function cpSlice(str: string, start: number, end?: number): string {
+  // Slice by code‑point indices and re‑join.
+  const arr = toCodePoints(str).slice(start, end);
+  return arr.join("");
+}
+
+/**
+ * Strip characters that can break terminal rendering.
+ *
+ * Uses Node.js built-in stripVTControlCharacters to handle VT sequences,
+ * then filters remaining control characters that can disrupt display.
+ *
+ * Characters stripped:
+ * - ANSI escape sequences (via strip-ansi)
+ * - VT control sequences (via Node.js util.stripVTControlCharacters)
+ * - C0 control chars (0x00-0x1F) except CR/LF which are handled elsewhere
+ * - C1 control chars (0x80-0x9F) that can cause display issues
+ *
+ * Characters preserved:
+ * - All printable Unicode including emojis
+ * - DEL (0x7F) - handled functionally by applyOperations, not a display issue
+ * - CR/LF (0x0D/0x0A) - needed for line breaks
+ * - TAB (0x09) - preserve tabs
+ */
+export function stripUnsafeCharacters(str: string): string {
+  const strippedAnsi = stripAnsi(str);
+  const strippedVT = stripVTControlCharacters(strippedAnsi);
+
+  return toCodePoints(strippedVT)
+    .filter((char) => {
+      const code = char.codePointAt(0);
+      if (code === undefined) {
+        return false;
+      }
+
+      // Preserve CR/LF/TAB for line handling
+      if (code === 0x0a || code === 0x0d || code === 0x09) {
+        return true;
+      }
+
+      // Remove C0 control chars (except CR/LF) that can break display
+      // Examples: BELL(0x07) makes noise, BS(0x08) moves cursor, VT(0x0B), FF(0x0C)
+      if (code >= 0x00 && code <= 0x1f) {
+        return false;
+      }
+
+      // Remove C1 control chars (0x80-0x9f) - legacy 8-bit control codes
+      if (code >= 0x80 && code <= 0x9f) {
+        return false;
+      }
+
+      // Preserve DEL (0x7f) - it's handled functionally by applyOperations as backspace
+      // and doesn't cause rendering issues when displayed
+
+      // Preserve all other characters including Unicode/emojis
+      return true;
+    })
+    .join("");
+}
+
+// String width caching for performance optimization
+const stringWidthCache = new Map<string, number>();
+
+/**
+ * Cached version of stringWidth function for better performance
+ * Follows Ink's approach with unlimited cache (no eviction)
+ */
+export const getCachedStringWidth = (str: string): number => {
+  // ASCII printable chars have width 1
+  if (/^[\u0020-\u007E]*$/.test(str)) {
+    return str.length;
+  }
+
+  if (stringWidthCache.has(str)) {
+    return stringWidthCache.get(str)!;
+  }
+
+  const width = stringWidth(str);
+  stringWidthCache.set(str, width);
+
+  return width;
+};
+
+/**
+ * Clear the string width cache
+ */
+export const clearStringWidthCache = (): void => {
+  stringWidthCache.clear();
+};
+
+const regex = ansiRegex();
+
+/* Recursively traverses a JSON-like structure (objects, arrays, primitives)
+ * and escapes all ANSI control characters found in any string values.
+ *
+ * This function is designed to be robust, handling deeply nested objects and
+ * arrays. It applies a regex-based replacement to all string values to
+ * safely escape control characters.
+ *
+ * To optimize performance, this function uses a "copy-on-write" strategy.
+ * It avoids allocating new objects or arrays if no nested string values
+ * required escaping, returning the original object reference in such cases.
+ *
+ * @param obj The JSON-like value (object, array, string, etc.) to traverse.
+ * @returns A new value with all nested string fields escaped, or the
+ * original `obj` reference if no changes were necessary.
+ */
+export function escapeAnsiCtrlCodes<T>(obj: T): T {
+  if (typeof obj === "string") {
+    if (obj.search(regex) === -1) {
+      return obj; // No changes return original string
+    }
+
+    regex.lastIndex = 0; // needed for global regex
+    return obj.replace(regex, (match) => JSON.stringify(match).slice(1, -1)) as T;
+  }
+
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+
+  if (Array.isArray(obj)) {
+    let newArr: unknown[] | null = null;
+
+    for (let i = 0; i < obj.length; i++) {
+      const value = obj[i];
+      const escapedValue = escapeAnsiCtrlCodes(value);
+      if (escapedValue !== value) {
+        if (newArr === null) {
+          newArr = [...obj];
+        }
+        newArr[i] = escapedValue;
+      }
+    }
+    return (newArr !== null ? newArr : obj) as T;
+  }
+
+  let newObj: T | null = null;
+  const keys = Object.keys(obj);
+
+  for (const key of keys) {
+    const value = (obj as Record<string, unknown>)[key];
+    const escapedValue = escapeAnsiCtrlCodes(value);
+
+    if (escapedValue !== value) {
+      if (newObj === null) {
+        newObj = { ...obj };
+      }
+      (newObj as Record<string, unknown>)[key] = escapedValue;
+    }
+  }
+
+  return newObj !== null ? newObj : obj;
+}

package/src/lib/timing.ts

@@ -0,0 +1,63 @@
+/**
+ * Shared timing utilities for performance tracking
+ */
+
+export class Timing {
+  private startTime: number;
+
+  constructor() {
+    this.startTime = performance.now();
+  }
+
+  /**
+   * Get elapsed time in seconds
+   */
+  getElapsedSeconds(): number {
+    return (performance.now() - this.startTime) / 1000;
+  }
+
+  /**
+   * Get elapsed time in milliseconds
+   */
+  getElapsedMs(): number {
+    return performance.now() - this.startTime;
+  }
+
+  /**
+   * Format duration for display in human-readable format (hours, minutes, seconds)
+   */
+  getFormattedDuration(): string {
+    return formatDurationMs(this.getElapsedMs());
+  }
+
+  /**
+   * Reset the timer
+   */
+  reset(): void {
+    this.startTime = performance.now();
+  }
+}
+
+/**
+ * Format a duration in milliseconds to human-readable format
+ * Standalone utility version of Timing.getFormattedDuration()
+ */
+export function formatDurationMs(ms: number): string {
+  const totalSeconds = Math.floor(ms / 1000);
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor((totalSeconds % 3600) / 60);
+  const seconds = totalSeconds % 60;
+
+  const parts: string[] = [];
+  if (hours > 0) {
+    parts.push(`${hours}h`);
+  }
+  if (minutes > 0) {
+    parts.push(`${minutes}m`);
+  }
+  if (seconds > 0 || parts.length === 0) {
+    parts.push(`${seconds}s`);
+  }
+
+  return parts.join(" ");
+}

package/src/lib/types.ts

@@ -0,0 +1,295 @@
+import type { ParsedToolResult, ToolDisplayData } from "@codellm/agent";
+import type {
+  ComputerToolUseRequest,
+  IResponseChatHistory,
+  IResponseChatHistorySegment,
+  ToolUseResult,
+} from "@codellm/api";
+
+export enum Status {
+  Idle = "idle",
+  Loading = "loading",
+  Error = "error",
+}
+
+export type SegmentStatus = "transient" | "completed";
+
+export interface HistorySegment extends Omit<IResponseChatHistorySegment, "type"> {
+  id: string; // Unique segment ID
+  status: SegmentStatus; // transient or completed
+  source: "user" | "bot"; // Who generated this segment
+  /** SDK-native types + all API types */
+  type?:
+    | IResponseChatHistorySegment["type"]
+    | "thinking" // Active/completed thinking block (SDK-native)
+    | "code_llm_tool_call"; // Tool call + result (SDK-native)
+  // client only fields
+  toolUseResult?: ToolUseResult;
+  parsedResult?: ParsedToolResult;
+  thinkingStartTime?: number;
+  thinkingEndTime?: number;
+  toolDisplayData?: ToolDisplayData;
+  /** Incremented to trigger a flash/attention effect on duplicate notifications */
+  flashKey?: number;
+}
+
+export interface HistoryItem extends Omit<IResponseChatHistory, "segments"> {
+  id?: string;
+  processingStartTime?: number;
+  segments?: HistorySegment[];
+  isToolResult?: boolean;
+  selectionContext?: {
+    file: string;
+    startLine: number;
+    endLine: number;
+  };
+}
+
+export interface FileAttachment {
+  doc_id?: string;
+  filename?: string;
+  filePath: string;
+  fileName: string;
+  content: string | Buffer;
+  mimeType: string;
+  mime_type?: string;
+  size?: number;
+  metadata?: Record<string, unknown>;
+}
+
+// Copied from src/vs/workbench/contrib/abacus/common/fileSystemTools.ts
+
+export type UndoableAction = {
+  filePath: string;
+} & (
+  | {
+      type: "mkdir" | "create";
+    }
+  | {
+      type: "str_replace";
+      oldStr: string;
+      newStr: string;
+      previousNewStrings: number;
+    }
+  | {
+      type: "insert";
+      insertLine: number;
+      newStr: string;
+    }
+);
+
+export type GrepResult = {
+  /** The matching file paths with context */
+  matches: string[];
+  /** Metadata about the search results */
+  metadata: {
+    /** Starting offset position */
+    offset: number;
+    /** Number of results requested */
+    limit: number;
+    /** Total number of matches found across all files */
+    totalMatches: number;
+    /** Whether there are more results available */
+    hasMore: boolean;
+  };
+};
+
+export type GrepCommonOpts = {
+  /** The maximum number of results to return. @default MAX_RESULTS_GREP */
+  maxResults?: number;
+  /** The glob patterns for folders to exclude. @default [] */
+  folderExcludes?: string[];
+  /** The glob patterns for folders to include. @default [] */
+  folderIncludes?: string[];
+  /** Starting offset position for pagination. @default 0 */
+  offset?: number;
+};
+
+export type GrepOpts = GrepCommonOpts & {
+  /** The regex pattern to search for */
+  query: string;
+  /** Whether to use case sensitive search. @default false */
+  isCaseSensitive?: boolean;
+  /** The maximum file size to search in characters. @default MAX_FILE_SIZE */
+  maxFileSize?: number;
+  /** File or directory to search in (relative to workspace). @default workspace root */
+  path?: string;
+  /** Output mode: "content" shows matching lines, "files_with_matches" shows file paths, "count" shows match counts. @default "files_with_matches" */
+  outputMode?: "content" | "files_with_matches" | "count";
+  /** Number of lines to show before each match (ripgrep -B) */
+  contextBefore?: number;
+  /** Number of lines to show after each match (ripgrep -A) */
+  contextAfter?: number;
+  /** Number of lines to show before and after each match (ripgrep -C) */
+  contextLines?: number;
+  /** Show line numbers in output (ripgrep -n). @default true for content mode */
+  showLineNumbers?: boolean;
+  /** File type to search (ripgrep --type). Common types: js, py, rust, go, java, etc. */
+  fileType?: string;
+  /** Limit output to first N lines/entries. @default based on maxResults */
+  headLimit?: number;
+  /** Enable multiline mode where . matches newlines (ripgrep -U --multiline-dotall). @default false */
+  multiline?: boolean;
+};
+
+export type GrepFileOpts = GrepCommonOpts & {
+  /** The glob or fuzzy pattern to search for */
+  query: string;
+  /** Whether to use fuzzy match instead of glob (* patterns will not work) @default false */
+  fuzzyMatch?: boolean;
+  /** The cache key to use for the search (e.g. time based cache). @default undefined */
+  cacheKey?: string;
+};
+
+export interface FileSystemTools {
+  ls: (path: string, showHidden?: boolean) => Promise<string>;
+  mkdir: (path: string) => Promise<UndoableAction>;
+  view: (path: string, viewRange?: [number, number]) => Promise<string>;
+  readRawFile: (path: string) => Promise<string>;
+  create: (path: string, content: string) => Promise<UndoableAction>;
+  readFile: (
+    path: string,
+    startLineOneIndexed: number,
+    endLineOneIndexed: number,
+    shouldReadEntireFile: boolean,
+  ) => Promise<string>;
+  deleteFile: (path: string) => Promise<void>;
+  listDir: (path: string) => Promise<string>;
+  strReplace: (
+    path: string,
+    oldStr: string,
+    newStr: string,
+    similarityThreshold?: number,
+    startLine?: number,
+    endLine?: number,
+  ) => Promise<UndoableAction>;
+  grep(params: GrepOpts): Promise<GrepResult>;
+  grepFile: (params: GrepFileOpts) => Promise<string[]>;
+  grepTextFile: (params: GrepFileOpts) => Promise<string[]>;
+}
+
+// Note: AbacusEditingService removed - TUI uses direct file operations for better simplicity and reliability
+
+export type ICommandResult = {
+  id: number;
+  command: string;
+  output: string;
+  exitCode?: number;
+  cwd?: string;
+  duration?: number;
+};
+
+export interface ICommand {
+  running?: Promise<void>;
+  result: {
+    get(): ICommandResult;
+  };
+}
+
+export interface ITerminalService {
+  executeCommand(
+    command: string,
+    options?: {
+      terminalId?: number;
+      revealTerminal?: boolean;
+      alwaysCreateNew?: boolean;
+      interactiveMode?: boolean;
+    },
+  ): Promise<ICommand>;
+  getOutput(id: number): ICommandResult[];
+  stopCommand(id: number): Promise<boolean>;
+  closeTerminal?(id: number): Promise<void>;
+  dispose(): void;
+}
+
+// MCP Configuration Types
+export interface IMcpConfiguration {
+  inputs?: unknown[];
+  servers?: Record<string, IMcpServerConfig>;
+}
+
+export type IMcpServerConfig = IMcpStdioServerConfig | IMcpHttpServerConfig;
+
+export interface IMcpStdioServerConfig {
+  type?: "stdio";
+  command: string;
+  args?: readonly string[];
+  env?: Record<string, string | number | null>;
+  envFile?: string;
+  cwd?: string;
+}
+
+export interface IMcpHttpServerConfig {
+  type?: "http";
+  url: string;
+  headers?: Record<string, string>;
+}
+
+export interface IMcpServerInfo {
+  id: string;
+  name: string;
+  config: IMcpServerConfig;
+  status?: "running" | "stopped" | "error";
+  description?: string;
+}
+
+// Minimal interface for MCP management in TUI
+export interface IMcpManagementService {
+  listServers(): Promise<IMcpServerInfo[]>;
+  addServer(name: string, config: IMcpServerConfig): Promise<void>;
+  removeServer(name: string): Promise<void>;
+  getServer(name: string): Promise<IMcpServerInfo | undefined>;
+  addServerFromJson(name: string, jsonConfig: string): Promise<void>;
+  addServerFromUrl(name: string, url: string, args?: string[]): Promise<void>;
+  formatServerInfo(server: IMcpServerInfo): string;
+  formatServerList(servers: IMcpServerInfo[]): string;
+}
+
+// Interface for MCP service with tool execution capabilities (like GUI's AbacusMcpService)
+export interface ITuiMcpService {
+  listAllToolDefinitions(): Promise<AbacusMcpTool[]>;
+  callTool(serverId: string, toolName: string, params: Record<string, unknown>): Promise<any>;
+  reloadConnections(): Promise<void>;
+  getServerStatus(serverId: string): "running" | "stopped" | "error";
+}
+
+// MCP tool type for TUI (matching API client's AbacusMcpTool)
+export interface AbacusMcpTool {
+  name: string;
+  description?: string;
+  inputSchema: any;
+  serverId: string;
+  originalName?: string;
+}
+export interface ElementAction {
+  action: "click" | "type" | "hover" | "scroll" | "focus" | "select";
+  text?: string;
+  scroll_direction?: "up" | "down" | "left" | "right";
+  scroll_amount?: number;
+  held_keys?: string;
+}
+
+export type EncodedId = `${number}-${number}`;
+
+export interface IAbacusBrowserService {
+  navigateTo(url?: string): Promise<void>;
+  openTab(url?: string): Promise<number>;
+  switchActiveTab(id: number): Promise<void>;
+  closeTab(id: number): Promise<void>;
+  refreshTab(id?: number): Promise<void>;
+  getTabContent(id?: number): Promise<{
+    text: string;
+    metadata: { offset: number; limit: number; totalLength: number; hasMore: boolean };
+  }>;
+  do(
+    input: AbacusBrowserIO,
+  ): Promise<{ content: { text?: string; images?: { base64: string; mime_type: string }[] } }>;
+  getInteractiveElements(tabId?: number): Promise<string>;
+  doOnElementId(
+    id: EncodedId,
+    action: ElementAction,
+    tabId?: number,
+  ): Promise<{ content: { text?: string; images?: { base64: string; mime_type: string }[] } }>;
+}
+
+export type AbacusBrowserIO = ComputerToolUseRequest["input"];