@abacus-ai/cli 1.106.25007 → 2.0.0-canary.0

package/src/components/composer/commands/default-commands.tsx

@@ -0,0 +1,615 @@
+import type { McpManager } from "@codellm/agent";
+
+import { product } from "@codellm/product";
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+
+import packageJson from "@/package.json" with { type: "json" };
+
+import { McpCommandHandler } from "../../../lib/mcpCommandHandler.js";
+import { AgentStatus } from "../../../providers/agent.js";
+import { setupTerminal } from "../../../terminal/setup.js";
+import themesData from "../../../theme/themes.json" with { type: "json" };
+import { ComposerMode } from "../types.js";
+import { commandRegistry } from "./registry.js";
+import { CommandDefinition } from "./types.js";
+
+interface ThemeDefinition {
+  name: string;
+  displayName: string;
+  colors: Record<string, string>;
+}
+
+interface ThemesRegistry {
+  version: string;
+  default: string;
+  themes: ThemeDefinition[];
+}
+
+const themesRegistry: ThemesRegistry = themesData as ThemesRegistry;
+
+function formatCommandHelp(): string {
+  const commands = commandRegistry.getAll();
+  const lines: string[] = [];
+  const maxUsageLength = Math.max(
+    0,
+    ...commands.map((cmd) => {
+      if (cmd.subcommands && cmd.subcommands.length > 0) {
+        return Math.max(0, ...cmd.subcommands.map((sub) => sub.usage?.length || 0));
+      }
+      return cmd.usage?.length || 0;
+    }),
+  );
+
+  lines.push(
+    "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:",
+    "",
+  );
+
+  for (const cmd of commands) {
+    if (cmd.subcommands && cmd.subcommands.length > 0) {
+      for (const sub of cmd.subcommands) {
+        lines.push(`  ${(sub.usage || "").padEnd(maxUsageLength + 2)} ${sub.description || ""}`);
+      }
+    } else {
+      lines.push(`  ${(cmd.usage || "").padEnd(maxUsageLength + 2)} ${cmd.description || ""}`);
+    }
+  }
+
+  lines.push("", "Type any command and press Enter to execute.");
+
+  return lines.join("\n");
+}
+
+interface ModelInfo {
+  label: string;
+  value: string;
+  model: any;
+}
+
+export function registerDefaultCommands(handlers: {
+  onExit?: () => void;
+  onNewChat?: () => void;
+  onClearChat?: () => void;
+  onModelChange?: (model: string) => void;
+  onResumeChat?: (title: string) => void;
+  onStop?: () => void;
+  onHelp?: () => void;
+  onLogin?: (emailOrApiKey?: string) => void;
+  onLogout?: () => void;
+  getModels?: () => Promise<ModelInfo[]> | ModelInfo[];
+  getChatTitles?: () => Promise<string[]> | string[];
+  addNotification?: (
+    message: string,
+    severity?: "info" | "warning" | "error",
+    temp?: boolean,
+  ) => void;
+  mcp?: McpManager;
+  addAllowedDirectory?: (dirPath: string) => void;
+  refreshMcpTools?: (skipReload?: boolean, showNotification?: boolean) => Promise<void>;
+  getAgentStatus?: () => string;
+  getUserInfo?: () => Promise<void>;
+  setTheme?: (themeName: string) => void;
+  checkEnvAuth?: () => { isEnvAuth: boolean; shouldHide: boolean };
+}): void {
+  const mcpHandler = handlers.mcp ? new McpCommandHandler(handlers.mcp) : undefined;
+
+  const addNotification = (
+    message: string,
+    severity: "info" | "error" | "warning" = "info",
+    temp?: boolean,
+  ) => {
+    handlers.addNotification?.(message, severity, temp);
+  };
+
+  const commands: CommandDefinition[] = [
+    {
+      id: "version",
+      description: "Show CLI version",
+      usage: "/version",
+      execute: () => {
+        addNotification(`Abacus.AI CLI version ${packageJson.version}`, "info");
+      },
+    },
+    {
+      id: "exit",
+      description: "Exit the application",
+      usage: "/exit",
+      alias: { [ComposerMode.Prompt]: ["exit", "quit"] },
+      execute: () => {
+        handlers.onExit?.();
+      },
+    },
+    {
+      id: "new",
+      description: "Start a new conversation",
+      usage: "/new",
+      execute: () => {
+        handlers.onNewChat?.();
+      },
+    },
+    {
+      id: "clear",
+      description: "Clear the output display while keeping the current conversation",
+      usage: "/clear",
+      alias: { [ComposerMode.Prompt]: ["cls", "clear"] },
+      execute: () => {
+        handlers.onClearChat?.();
+      },
+    },
+    {
+      id: "stop",
+      description: "Stop the current streaming response and any running bash tools",
+      usage: "/stop",
+      execute: async () => {
+        const agentStatus = handlers.getAgentStatus?.();
+        const isAgentActive =
+          agentStatus === AgentStatus.Submitted ||
+          agentStatus === AgentStatus.Streaming ||
+          agentStatus === AgentStatus.ExecutingTool ||
+          agentStatus === AgentStatus.WaitingForToolPermission;
+
+        handlers.onStop?.();
+        if (isAgentActive) {
+          addNotification("Agent stopped successfully", "info");
+        } else {
+          addNotification("No active agent process to stop", "warning");
+        }
+      },
+    },
+    {
+      id: "help",
+      description: "Show commands and functionalities",
+      usage: "/help",
+      alias: { [ComposerMode.Prompt]: ["help"] },
+      execute: () => {
+        if (handlers.onHelp) {
+          handlers.onHelp();
+        } else {
+          addNotification(formatCommandHelp(), "info");
+        }
+      },
+    },
+    {
+      id: "model",
+      description: "Switch to a different model",
+      usage: "/model <model_name>",
+      requiresArgument: true,
+      completionProvider: async (query: string) => {
+        if (!handlers.getModels) {
+          return [];
+        }
+
+        const models = await handlers.getModels();
+
+        if (!models || models.length === 0) {
+          return [];
+        }
+
+        const lowerQuery = query.trim().toLowerCase();
+
+        if (!lowerQuery) {
+          return models.map((m) => m.label);
+        }
+
+        return models
+          .filter(
+            (m) =>
+              m.label.toLowerCase().includes(lowerQuery) ||
+              m.value.toLowerCase().includes(lowerQuery),
+          )
+          .map((m) => m.label);
+      },
+      execute: async (args: string[]) => {
+        const modelName = args.join(" ").trim();
+        if (!modelName) {
+          addNotification("Please specify a model name", "error");
+          return;
+        }
+
+        if (!handlers.getModels) {
+          addNotification("Models not available", "error");
+          return;
+        }
+
+        const models = await handlers.getModels();
+        const matchedModel = models.find((m) => m.label === modelName);
+
+        if (matchedModel) {
+          handlers.onModelChange?.(matchedModel.value);
+        } else {
+          addNotification(`Model "${modelName}" not found`, "error");
+        }
+      },
+    },
+    {
+      id: "resume",
+      description: "Resume a previous chat conversation",
+      usage: "/resume <chat_title>",
+      requiresArgument: true,
+      completionProvider: async (query: string) => {
+        if (!handlers.getChatTitles) {
+          return [];
+        }
+        const titles = await handlers.getChatTitles();
+        const lowerQuery = query.toLowerCase();
+        return titles.filter((title) => title.toLowerCase().includes(lowerQuery));
+      },
+      execute: (args: string[]) => {
+        const title = args.join(" ").trim();
+        if (!title) {
+          return;
+        }
+        handlers.onResumeChat?.(title);
+      },
+    },
+    {
+      id: "login",
+      description: "Log in to Abacus.AI CLI with email or API key",
+      usage: "/login <email|api_key>",
+      execute: async (args: string[]) => {
+        // Check if user is authenticated via environment variables first
+        if (handlers.checkEnvAuth) {
+          const { isEnvAuth } = handlers.checkEnvAuth();
+          if (isEnvAuth) {
+            addNotification(
+              `You are logged in via environment variables. Remove ${product.envPrefix}API_KEY to logout.`,
+              "warning",
+            );
+            return;
+          }
+        }
+
+        const argument = args.filter(Boolean).join(" ").trim();
+
+        if (!argument) {
+          addNotification(
+            "This command requires an argument. Usage: /login <email> or /login <api_key>\n\n" +
+              "Get your API key from: https://abacus.ai/app/abacusai-cli",
+            "warning",
+          );
+          // Throw error to prevent clearing the input buffer so user can add the argument
+          throw new Error("Missing required argument");
+        }
+
+        handlers.onLogin?.(argument);
+      },
+    },
+    {
+      id: "logout",
+      description: "Log out of Abacus.AI CLI",
+      usage: "/logout",
+      execute: async () => {
+        // Check if user is authenticated via environment variables
+        if (handlers.checkEnvAuth) {
+          const { isEnvAuth } = handlers.checkEnvAuth();
+          if (isEnvAuth) {
+            addNotification(
+              `You are logged in via environment variables. Remove ${product.envPrefix}API_KEY to logout.`,
+              "warning",
+            );
+            return;
+          }
+        }
+
+        try {
+          handlers.onLogout?.();
+          addNotification("Logged out successfully", "info");
+        } catch (error) {
+          const errorMessage = `Logout failed: ${error instanceof Error ? error.message : "Unknown error occurred"}`;
+          addNotification(errorMessage, "error");
+        }
+      },
+    },
+    {
+      id: "status",
+      description: "Show current user status",
+      usage: "/status",
+      execute: async () => {
+        try {
+          await handlers.getUserInfo?.();
+        } catch (error) {
+          const errorMessage = `Failed to get status: ${error instanceof Error ? error.message : "Unknown error occurred"}`;
+          addNotification(errorMessage, "error");
+        }
+      },
+    },
+    {
+      id: "usage",
+      description: "Show total credits consumed in current session",
+      usage: "/usage",
+      execute: async () => {
+        addNotification("Usage information not available in this version", "info");
+      },
+    },
+    {
+      id: "terminal-setup",
+      description: "Automatically configure terminal for Shift+Enter newlines",
+      usage: "/terminal-setup",
+      execute: async () => {
+        try {
+          addNotification("Setting up terminal keybindings...", "info");
+
+          const result = await setupTerminal();
+
+          if (result.success) {
+            let message = result.message;
+            if (result.backupPath) {
+              message += `\n\nBackup created: ${result.backupPath}`;
+            }
+            if (result.requiresRestart) {
+              message += "\n\nPlease restart your terminal for changes to take effect.";
+            }
+            addNotification(message, "info");
+          } else {
+            addNotification(result.message, "warning");
+          }
+        } catch (error) {
+          addNotification(
+            `Terminal setup failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+            "error",
+          );
+        }
+      },
+    },
+    {
+      id: "theme",
+      description: "Switch between color themes",
+      usage: "/theme [theme_name]",
+      completionProvider: async (query: string) => {
+        try {
+          const themes = themesRegistry.themes;
+          const themeNames = themes.map((t) => t.displayName);
+
+          if (!query.trim()) {
+            return themeNames;
+          }
+
+          const lowerQuery = query.toLowerCase();
+          return themeNames.filter((name) => name.toLowerCase().includes(lowerQuery));
+        } catch {
+          return [];
+        }
+      },
+      execute: async (args: string[]) => {
+        const themeName = args.join(" ").trim();
+
+        if (!themeName) {
+          // Don't show notification - completion provider already shows themes
+          return;
+        }
+
+        try {
+          const themes = themesRegistry.themes;
+
+          const matchedTheme = themes.find(
+            (t) =>
+              t.displayName.toLowerCase() === themeName.toLowerCase() ||
+              t.name.toLowerCase() === themeName.toLowerCase(),
+          );
+
+          if (matchedTheme) {
+            // Switch theme via handler
+            if (handlers.setTheme) {
+              handlers.setTheme(matchedTheme.name);
+              addNotification(`${matchedTheme.displayName} applied`, "info");
+            } else {
+              addNotification("Theme switching not available", "error");
+            }
+          } else {
+            addNotification(`Theme "${themeName}" not found`, "error");
+          }
+        } catch (error) {
+          addNotification(
+            `Failed to switch theme: ${error instanceof Error ? error.message : "Unknown error"}`,
+            "error",
+          );
+        }
+      },
+    },
+    {
+      id: "mcp",
+      description: "MCP server management",
+      usage: "/mcp <subcommand>",
+      subcommands: [
+        {
+          id: "list",
+          description: "List configured MCP servers",
+          usage: "/mcp list",
+          execute: async () => {
+            if (!mcpHandler) {
+              addNotification("MCP service not available", "error");
+              return;
+            }
+            try {
+              const result = await mcpHandler.listServers();
+              addNotification(result, "info");
+            } catch (error) {
+              const errorMessage = `Failed to list MCP servers: ${error instanceof Error ? error.message : "Unknown error occurred"}`;
+              addNotification(errorMessage, "error");
+            }
+          },
+        },
+        {
+          id: "add",
+          description: "Add an MCP server",
+          usage: "/mcp add <name> <commandOrUrl> [args...]",
+          requiresArgument: true,
+          execute: async (args: string[]) => {
+            if (!mcpHandler) {
+              addNotification("MCP service not available", "error");
+              return;
+            }
+            if (args.length < 2) {
+              addNotification("Usage: /mcp add <name> <commandOrUrl> [args...]", "error");
+              addNotification("[TIP] Use /mcp add-json for JSON configuration", "info");
+              return;
+            }
+            const [name, commandOrUrl, ...extraArgs] = args;
+            if (commandOrUrl.trim().startsWith("{")) {
+              addNotification(
+                "Invalid: JSON detected. Use /mcp add-json for JSON configuration",
+                "error",
+              );
+              return;
+            }
+            try {
+              await mcpHandler.addServer(name, commandOrUrl, extraArgs);
+              addNotification(`Added MCP server '${name}'`, "info");
+            } catch (error) {
+              const errorMessage = `Failed to add MCP server: ${error instanceof Error ? error.message : "Unknown error occurred"}`;
+              addNotification(errorMessage, "error");
+            }
+          },
+        },
+        {
+          id: "add-json",
+          description: "Add an MCP server with JSON configuration",
+          usage: "/mcp add-json <name> <json>",
+          requiresArgument: true,
+          execute: async (args: string[]) => {
+            if (!mcpHandler) {
+              addNotification("MCP service not available", "error");
+              return;
+            }
+            if (args.length !== 2) {
+              addNotification("Usage: /mcp add-json <name> <json>", "error");
+              addNotification(
+                'Example: /mcp add-json github \'{"command":"npx","args":["-y","@modelcontextprotocol/server-github"],"env":{"GITHUB_PERSONAL_ACCESS_TOKEN":"your_token"}}\'',
+                "info",
+              );
+              return;
+            }
+            try {
+              const [name, jsonConfig] = args;
+              await mcpHandler.addServerFromJson(name, jsonConfig);
+              addNotification(`Added MCP server '${name}' from JSON`, "info");
+            } catch (error) {
+              const errorMessage = `Failed to add MCP server: ${error instanceof Error ? error.message : "Unknown error occurred"}`;
+              addNotification(errorMessage, "error");
+            }
+          },
+        },
+        {
+          id: "remove",
+          description: "Remove an MCP server",
+          usage: "/mcp remove <name>",
+          requiresArgument: true,
+          execute: async (args: string[]) => {
+            if (!mcpHandler) {
+              addNotification("MCP service not available", "error");
+              return;
+            }
+            if (args.length !== 1) {
+              addNotification("Usage: /mcp remove <name>", "error");
+              return;
+            }
+            try {
+              await mcpHandler.removeServer(args[0]);
+              addNotification(`Removed MCP server '${args[0]}'`, "info");
+            } catch (error) {
+              const errorMessage = `Failed to remove MCP server: ${error instanceof Error ? error.message : "Unknown error occurred"}`;
+              addNotification(errorMessage, "error");
+            }
+          },
+        },
+        {
+          id: "get",
+          description: "Get details about an MCP server",
+          usage: "/mcp get <name>",
+          requiresArgument: true,
+          execute: async (args: string[]) => {
+            if (!mcpHandler) {
+              addNotification("MCP service not available", "error");
+              return;
+            }
+            if (args.length !== 1) {
+              addNotification("Usage: /mcp get <name>", "error");
+              return;
+            }
+            try {
+              const result = await mcpHandler.getServer(args[0]);
+              if (result) {
+                addNotification(result, "info");
+              } else {
+                addNotification(`Server '${args[0]}' not found`, "error");
+              }
+            } catch (error) {
+              const errorMessage = `Failed to get MCP server: ${error instanceof Error ? error.message : "Unknown error occurred"}`;
+              addNotification(errorMessage, "error");
+            }
+          },
+        },
+      ],
+    },
+    {
+      id: "add-dir",
+      description: "Add a directory to the agent's allowed access paths for this session",
+      usage: "/add-dir <path>",
+      requiresArgument: true,
+      execute: async (args: string[]) => {
+        const rawPath = args.join(" ").trim();
+        if (!rawPath) {
+          addNotification("Usage: /add-dir <path>", "error");
+          return;
+        }
+        if (!handlers.addAllowedDirectory) {
+          addNotification("Cannot add directory: session not available", "error");
+          return;
+        }
+        try {
+          const expanded = rawPath.replace(/^~/, homedir());
+          const absolute = resolve(expanded);
+          handlers.addAllowedDirectory(absolute);
+          addNotification(`Added '${absolute}' to allowed directories`, "info");
+        } catch (error) {
+          addNotification(
+            `Failed to add directory: ${error instanceof Error ? error.message : "Unknown error"}`,
+            "error",
+          );
+        }
+      },
+    },
+  ];
+
+  commandRegistry.clear();
+
+  // Filter commands based on environment auth status
+  const registerCommands = async () => {
+    let commandsToRegister = commands;
+
+    if (handlers.checkEnvAuth) {
+      const { shouldHide } = handlers.checkEnvAuth();
+      if (shouldHide) {
+        // Hide login and logout commands when in no-auth mode with valid env auth
+        commandsToRegister = commands.filter((cmd) => cmd.id !== "login" && cmd.id !== "logout");
+      }
+    }
+
+    commandsToRegister.forEach((cmd) => commandRegistry.register(cmd));
+  };
+
+  // Register commands asynchronously
+  void registerCommands();
+}

package/src/components/composer/commands/handler.tsx

@@ -0,0 +1,59 @@
+import { useCallback } from "react";
+
+import { ModeRenderProps } from "../modes/types.js";
+import { CommandPicker } from "./picker.js";
+import { commandRegistry } from "./registry.js";
+
+export function useCommandHandler(clearBuffer: () => void) {
+  const executeCommand = useCallback(
+    async (value: string) => {
+      const trimmed = value.trim();
+
+      if (!trimmed.startsWith("/")) {
+        return;
+      }
+
+      const match = commandRegistry.match(trimmed);
+      if (!match || match.needsSubcommand) {
+        return;
+      }
+
+      const executor = match.subcommand || match.command;
+      if (executor.completionProvider && executor.requiresArgument) {
+        clearBuffer();
+        return;
+      }
+
+      try {
+        if (await commandRegistry.execute(match)) {
+          clearBuffer();
+        }
+      } catch {
+        // If command throws an error, don't clear buffer
+        // This allows commands to show validation errors without losing user input
+      }
+    },
+    [clearBuffer],
+  );
+
+  const CommandRenderer = useCallback(({ prompt, onExit, availableHeight }: ModeRenderProps) => {
+    return (
+      <CommandPicker
+        prompt={prompt}
+        onAccept={onExit}
+        onCancel={onExit}
+        availableHeight={availableHeight}
+      />
+    );
+  }, []);
+
+  const shouldPreventDefault = useCallback((key: string) => {
+    return ["up", "down", "escape", "tab"].includes(key);
+  }, []);
+
+  return {
+    executeCommand,
+    renderer: CommandRenderer,
+    shouldPreventDefault,
+  };
+}