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

package/src/lib/clipboard.ts

@@ -0,0 +1,226 @@
+import { execFileSync } from "node:child_process";
+import { copyFileSync, existsSync, mkdirSync, statSync, writeFileSync } from "node:fs";
+import path from "node:path";
+
+// ── macOS screenshot detection ────────────────────────────────────────────
+
+const MACOS_TEMP_SCREENSHOT_PATTERN =
+  /\/var\/folders\/.*\/T\/TemporaryItems\/.*screencaptureui.*\//i;
+const SCREENSHOTS_DIR = ".abacusai/screenshots";
+
+export function isMacOSTempScreenshot(filePath: string): boolean {
+  return MACOS_TEMP_SCREENSHOT_PATTERN.test(filePath);
+}
+
+export function copyTempScreenshotToProject(tempPath: string): string | null {
+  try {
+    const unescaped = tempPath.replace(/\\ /g, " ");
+    const cleaned = stripFileProtocol(unescaped);
+
+    if (!existsSync(cleaned)) {
+      return null;
+    }
+
+    const screenshotsDir = path.resolve(process.cwd(), SCREENSHOTS_DIR);
+    if (!existsSync(screenshotsDir)) {
+      mkdirSync(screenshotsDir, { recursive: true });
+    }
+
+    const filename = path.basename(cleaned);
+    const destPath = path.join(screenshotsDir, filename);
+
+    copyFileSync(cleaned, destPath);
+    return destPath;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Strips the file:// protocol prefix from a path if present.
+ * Also percent-decodes URI-encoded characters (e.g. %20 → space).
+ */
+export function stripFileProtocol(text: string): string {
+  if (text.startsWith("file://")) {
+    try {
+      return decodeURIComponent(text.slice("file://".length));
+    } catch {
+      return text.slice("file://".length);
+    }
+  }
+  return text;
+}
+
+// ── Linux clipboard tool detection ───────────────────────────────────────
+
+let linuxClipboardTool: "wl-paste" | "xclip" | null | undefined;
+
+function detectLinuxClipboardTool(): "wl-paste" | "xclip" | null {
+  if (linuxClipboardTool !== undefined) return linuxClipboardTool;
+  try {
+    execFileSync("which", ["wl-paste"], { stdio: "ignore" });
+    linuxClipboardTool = "wl-paste";
+    return "wl-paste";
+  } catch {
+    // not found
+  }
+  try {
+    execFileSync("which", ["xclip"], { stdio: "ignore" });
+    linuxClipboardTool = "xclip";
+    return "xclip";
+  } catch {
+    // not found
+  }
+  linuxClipboardTool = null;
+  return null;
+}
+
+// ── Clipboard image detection ─────────────────────────────────────────────
+
+export async function clipboardHasImage(): Promise<boolean> {
+  try {
+    if (process.platform === "darwin") {
+      const result = execFileSync("osascript", ["-e", "clipboard info"], {
+        encoding: "utf8",
+        timeout: 2000,
+      });
+      return /PNGf|JPEG|TIFF|GIF/i.test(result);
+    }
+    if (process.platform === "win32") {
+      const result = execFileSync(
+        "powershell",
+        [
+          "-NoProfile",
+          "-Command",
+          "Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.Clipboard]::ContainsImage()",
+        ],
+        { encoding: "utf8", timeout: 2000 },
+      );
+      return result.trim().toLowerCase() === "true";
+    }
+    // Linux
+    const tool = detectLinuxClipboardTool();
+    if (tool === "wl-paste") {
+      const result = execFileSync("wl-paste", ["--list-types"], {
+        encoding: "utf8",
+        timeout: 2000,
+      });
+      return result.includes("image/");
+    }
+    if (tool === "xclip") {
+      const result = execFileSync("xclip", ["-selection", "clipboard", "-t", "TARGETS", "-o"], {
+        encoding: "utf8",
+        timeout: 2000,
+      });
+      return result.includes("image/");
+    }
+  } catch {
+    // ignore — clipboard tools may not be available
+  }
+  return false;
+}
+
+// ── Save clipboard image to disk ──────────────────────────────────────────
+
+export async function saveClipboardImage(cwd: string): Promise<string | null> {
+  try {
+    const screenshotsDir = path.resolve(cwd, SCREENSHOTS_DIR);
+    if (!existsSync(screenshotsDir)) {
+      mkdirSync(screenshotsDir, { recursive: true });
+    }
+
+    const timestamp = Date.now();
+    const destPath = path.join(screenshotsDir, `clipboard-${timestamp}.png`);
+
+    if (process.platform === "darwin") {
+      // Try PNG first, then JPEG
+      const script = `
+        set destFile to "${destPath}"
+        try
+          set imgData to (clipboard info for «class PNGf»)
+          set fileRef to open for access POSIX file destFile with write permission
+          set eof of fileRef to 0
+          write (clipboard as «class PNGf») to fileRef
+          close access fileRef
+        on error
+          try
+            set imgData to (clipboard info for «class JPEG»)
+            set fileRef to open for access POSIX file destFile with write permission
+            set eof of fileRef to 0
+            write (clipboard as «class JPEG») to fileRef
+            close access fileRef
+          end try
+        end try
+      `;
+      execFileSync("osascript", ["-e", script], { timeout: 5000 });
+    } else if (process.platform === "win32") {
+      execFileSync(
+        "powershell",
+        [
+          "-NoProfile",
+          "-Command",
+          `Add-Type -Assembly System.Windows.Forms; [System.Windows.Forms.Clipboard]::GetImage().Save("${destPath}", [System.Drawing.Imaging.ImageFormat]::Png)`,
+        ],
+        { timeout: 5000 },
+      );
+    } else {
+      const tool = detectLinuxClipboardTool();
+      if (tool === "wl-paste") {
+        const imgData = execFileSync("wl-paste", ["--no-newline", "--type", "image/png"], {
+          timeout: 5000,
+        });
+        writeFileSync(destPath, imgData);
+      } else if (tool === "xclip") {
+        const imgData = execFileSync(
+          "xclip",
+          ["-selection", "clipboard", "-t", "image/png", "-o"],
+          { timeout: 5000 },
+        );
+        writeFileSync(destPath, imgData);
+      } else {
+        return null;
+      }
+    }
+
+    // Verify file exists and has content (prevents empty-file false positives)
+    try {
+      const stat = statSync(destPath);
+      if (stat.size === 0) return null;
+    } catch {
+      return null;
+    }
+
+    return destPath;
+  } catch {
+    return null;
+  }
+}
+
+// ── Read clipboard text ───────────────────────────────────────────────────
+
+export async function readClipboardText(): Promise<string | null> {
+  try {
+    if (process.platform === "darwin") {
+      return execFileSync("pbpaste", { encoding: "utf8", timeout: 2000 });
+    }
+    if (process.platform === "win32") {
+      return execFileSync("powershell", ["-NoProfile", "-Command", "Get-Clipboard"], {
+        encoding: "utf8",
+        timeout: 2000,
+      });
+    }
+    const tool = detectLinuxClipboardTool();
+    if (tool === "wl-paste") {
+      return execFileSync("wl-paste", ["--no-newline"], { encoding: "utf8", timeout: 2000 });
+    }
+    if (tool === "xclip") {
+      return execFileSync("xclip", ["-selection", "clipboard", "-o"], {
+        encoding: "utf8",
+        timeout: 2000,
+      });
+    }
+  } catch {
+    // ignore
+  }
+  return null;
+}

package/src/lib/command-utils.ts

@@ -0,0 +1,93 @@
+/**
+ * Extracts the command type from a terminal command string
+ * Returns more specific types for common commands with subcommands
+ * Examples:
+ *   "pwd" -> "pwd"
+ *   "cd /home" -> "cd"
+ *   "npm install" -> "npm install"
+ *   "npm run build" -> "npm run"
+ *   "git status" -> "git status"
+ *   "git commit -m" -> "git commit"
+ *   "docker ps" -> "docker ps"
+ *   "ls -la" -> "ls"
+ */
+export const getCommandType = (command: string): string | null => {
+  if (!command || typeof command !== "string") {
+    return null;
+  }
+
+  // Trim the command and extract the first word
+  const trimmedCommand = command.trim();
+  if (!trimmedCommand) {
+    return null;
+  }
+
+  // Split by whitespace and get parts
+  let parts = trimmedCommand.split(/\s+/);
+
+  // Remove leading 'sudo' if present
+  if (parts[0] === "sudo" && parts.length > 1) {
+    parts = parts.slice(1);
+  }
+
+  const baseCommand = parts[0];
+  const subCommand = parts.length > 1 ? parts[1] : null;
+
+  // Define commands that should include their subcommand for more specific matching
+  // Format: { command: [list of subcommands to be specific about] }
+  const specificSubcommands: Record<string, string[]> = {
+    npm: ["install", "run", "start", "test", "build", "publish", "update", "uninstall", "ci"],
+    yarn: ["install", "add", "remove", "run", "start", "test", "build", "publish"],
+    pnpm: ["install", "add", "remove", "run", "start", "test", "build"],
+    git: [
+      "clone",
+      "pull",
+      "push",
+      "commit",
+      "add",
+      "status",
+      "checkout",
+      "branch",
+      "merge",
+      "rebase",
+      "fetch",
+      "diff",
+      "log",
+      "stash",
+    ],
+    docker: [
+      "build",
+      "run",
+      "ps",
+      "stop",
+      "start",
+      "pull",
+      "push",
+      "images",
+      "rm",
+      "exec",
+      "logs",
+      "compose",
+    ],
+    kubectl: ["get", "apply", "delete", "describe", "logs", "exec", "create", "scale"],
+    cargo: ["build", "run", "test", "check", "clean", "install", "update", "publish"],
+    pip: ["install", "uninstall", "list", "show", "freeze", "search"],
+    brew: ["install", "uninstall", "update", "upgrade", "list", "search", "info"],
+    apt: ["install", "remove", "update", "upgrade", "search", "show"],
+    "apt-get": ["install", "remove", "update", "upgrade", "purge"],
+    yum: ["install", "remove", "update", "search", "info"],
+    systemctl: ["start", "stop", "restart", "enable", "disable", "status"],
+    make: ["build", "clean", "install", "test"],
+  };
+
+  // Check if this command should have a specific subcommand
+  if (subCommand && specificSubcommands[baseCommand]) {
+    const validSubcommands = specificSubcommands[baseCommand];
+    if (validSubcommands.includes(subCommand)) {
+      return `${baseCommand} ${subCommand}`;
+    }
+  }
+
+  // For all other cases, return just the base command
+  return baseCommand;
+};

package/src/lib/commands.ts

@@ -0,0 +1,270 @@
+export enum Command {
+  Stop = "/stop",
+  Quit = "/quit",
+  Exit = "/exit",
+  Q = "/q",
+  Bye = "/bye",
+  Clear = "/clear",
+  New = "/new",
+  Suggest = "/",
+  Help = "/help",
+  Sidebar = "/sidebar",
+  Login = "/login",
+  Logout = "/logout",
+  Mcp = "/mcp",
+}
+
+export interface CommandInfo {
+  command: Command;
+  description: string;
+  usage: string;
+}
+
+export const COMMAND_INFO: CommandInfo[] = [
+  {
+    command: Command.Stop,
+    description: "Stop the current streaming response",
+    usage: "/stop",
+  },
+  {
+    command: Command.Quit,
+    description: "Exit the application",
+    usage: "/exit",
+  },
+  {
+    command: Command.Clear,
+    description: "Clear conversation history and free up context",
+    usage: "/clear",
+  },
+  {
+    command: Command.New,
+    description: "Start a new conversation",
+    usage: "/new",
+  },
+  {
+    command: Command.Suggest,
+    description: "Show available commands and hints",
+    usage: "/",
+  },
+  {
+    command: Command.Help,
+    description: "Show commands and functionalities",
+    usage: "/help",
+  },
+  {
+    command: Command.Sidebar,
+    description: "Toggle sidebar visibility",
+    usage: "/sidebar",
+  },
+  {
+    command: Command.Login,
+    description: "Log in to AbacusAI with email (device code flow)",
+    usage: "/login <email>",
+  },
+  {
+    command: Command.Logout,
+    description: "Log out of AbacusAI",
+    usage: "/logout",
+  },
+  {
+    command: Command.Mcp,
+    description: "Manage MCP servers",
+    usage: "/mcp [command] [options]",
+  },
+];
+
+export const getCommandInfo = (command: Command): CommandInfo | undefined => {
+  return COMMAND_INFO.find((info) => info.command === command);
+};
+
+export const getAllCommands = (): Command[] => {
+  return Object.values(Command);
+};
+
+export const isValidCommand = (input: string): boolean => {
+  return Object.values(Command).includes(input as Command);
+};
+
+export const formatCommandHelp = (): string => {
+  const maxUsageLength = Math.max(...COMMAND_INFO.map((info) => info.usage.length));
+
+  return [
+    "Abacus.AI CLI",
+    "",
+    "Abacus.AI CLI has read access to files in the current directory and can run commands and edit files with your permission.",
+    "",
+    "Use npx -y @abacus-ai/cli@latest to run latest version of abacusai interactive mode directly from your terminal",
+    "",
+    "Usage Modes:",
+    "• REPL: abacusai (interactive session)",
+    '• Non-interactive: abacusai -p "question"',
+    "",
+    "Run abacusai --help for all command line options",
+    "",
+    "For first time users, use /login to authenticate to Abacus.AI CLI",
+    "",
+    "Common Tasks:",
+    "• Ask questions about your codebase > How does agent.py work?",
+    "• Edit files > Update code.ts to...",
+    "• Fix errors > cargo build",
+    "• Run commands > /help",
+    "• Run bash commands > wc",
+    "",
+    "Interactive Mode Commands:",
+    "",
+    ...COMMAND_INFO.map((info) => `  ${info.usage.padEnd(maxUsageLength + 2)} ${info.description}`),
+    "",
+    "Type any command and press Enter to execute.",
+  ].join("\n");
+};
+
+export const getCommandSuggestions = (input: string): Command[] => {
+  return Object.values(Command).filter((cmd) => cmd.toLowerCase().includes(input.toLowerCase()));
+};
+
+export const getCommandWithDescription = (command: Command): string => {
+  const info = getCommandInfo(command);
+  return info ? `${command} - ${info.description}` : command;
+};
+
+// MCP subcommands
+export enum McpSubcommand {
+  Add = "add",
+  Remove = "remove",
+  List = "list",
+  Get = "get",
+  AddJson = "add-json",
+  Help = "help",
+}
+
+export interface McpCommandInfo {
+  subcommand: McpSubcommand;
+  description: string;
+  usage: string;
+}
+
+export const MCP_COMMAND_INFO: McpCommandInfo[] = [
+  {
+    subcommand: McpSubcommand.Add,
+    description: "Add a server",
+    usage: "/mcp add <name> <commandOrUrl> [args...]",
+  },
+  {
+    subcommand: McpSubcommand.Remove,
+    description: "Remove an MCP server",
+    usage: "/mcp remove <name>",
+  },
+  {
+    subcommand: McpSubcommand.List,
+    description: "List configured MCP servers",
+    usage: "/mcp list",
+  },
+  {
+    subcommand: McpSubcommand.Get,
+    description: "Get details about an MCP server",
+    usage: "/mcp get <name>",
+  },
+  {
+    subcommand: McpSubcommand.AddJson,
+    description: "Add an MCP server (stdio or SSE) with a JSON string",
+    usage: "/mcp add-json <name> <json>",
+  },
+  {
+    subcommand: McpSubcommand.Help,
+    description: "Display help for MCP commands",
+    usage: "/mcp help [command]",
+  },
+];
+
+export const getMcpCommandInfo = (subcommand: McpSubcommand): McpCommandInfo | undefined => {
+  return MCP_COMMAND_INFO.find((info) => info.subcommand === subcommand);
+};
+
+export const getAllMcpSubcommands = (): McpSubcommand[] => {
+  return Object.values(McpSubcommand);
+};
+
+export const isValidMcpSubcommand = (input: string): boolean => {
+  return Object.values(McpSubcommand).includes(input as McpSubcommand);
+};
+
+export const formatMcpCommandHelp = (): string => {
+  const maxUsageLength = Math.max(...MCP_COMMAND_INFO.map((info) => info.usage.length));
+
+  return [
+    "📡 MCP (Model Context Protocol) Commands:",
+    "",
+    ...MCP_COMMAND_INFO.map(
+      (info) => `  ${info.usage.padEnd(maxUsageLength + 2)} ${info.description}`,
+    ),
+    "",
+    "💡 TUI Features:",
+    "  - Full MCP server management from command line",
+    "  - All commands work independently in TUI",
+    "  - Direct file-based configuration access",
+    "",
+  ].join("\n");
+};
+
+export const parseMcpCommand = (input: string): { subcommand?: McpSubcommand; args: string[] } => {
+  const trimmed = input.trim();
+  if (!trimmed.startsWith("/mcp")) {
+    return { args: [] };
+  }
+
+  // Parse arguments respecting quoted strings
+  const args: string[] = [];
+  let current = "";
+  let inQuotes = false;
+  let quoteChar = "";
+  let i = 4; // Skip '/mcp'
+
+  // Skip whitespace after /mcp
+  while (i < trimmed.length && /\s/.test(trimmed[i])) {
+    i++;
+  }
+
+  while (i < trimmed.length) {
+    const char = trimmed[i];
+
+    if (!inQuotes && /\s/.test(char)) {
+      // End of current argument
+      if (current) {
+        args.push(current);
+        current = "";
+      }
+      // Skip whitespace
+      while (i < trimmed.length && /\s/.test(trimmed[i])) {
+        i++;
+      }
+      continue;
+    }
+    if (!inQuotes && (char === '"' || char === "'")) {
+      // Start of quoted string
+      inQuotes = true;
+      quoteChar = char;
+    } else if (inQuotes && char === quoteChar) {
+      // End of quoted string
+      inQuotes = false;
+      quoteChar = "";
+    } else {
+      // Regular character
+      current += char;
+    }
+
+    i++;
+  }
+
+  // Add final argument if any
+  if (current) {
+    args.push(current);
+  }
+
+  const subcommandStr = args[0];
+  const subcommand = isValidMcpSubcommand(subcommandStr)
+    ? (subcommandStr as McpSubcommand)
+    : undefined;
+  const commandArgs = args.slice(1);
+
+  return { subcommand, args: commandArgs };
+};

package/src/lib/constants.ts

@@ -0,0 +1,3 @@
+// Maximum number of recent conversations to display in the sidebar and related components
+export const MAX_RECENT_CONVERSATIONS = 25;
+export const TOOL_CALL_LIMIT = Number.MAX_SAFE_INTEGER; // Disabling tool call limit for CLI TODO (raj): Consider adding it back and separating the permissions flow