@teambit/cli-mcp-server 0.0.12 → 0.0.14

package/dist/cli-mcp-server.main.runtime.js

@@ -18,6 +18,13 @@ function _child_process() {
   };
   return data;
 }
+function _fsExtra() {
+  const data = _interopRequireDefault(require("fs-extra"));
+  _fsExtra = function () {
+    return data;
+  };
+  return data;
+}
 function _cliMcpServer() {
   const data = require("./cli-mcp-server.aspect");
   _cliMcpServer = function () {
@@ -81,6 +88,20 @@ function _nodeFetch() {
   };
   return data;
 }
+function _setupCmd() {
+  const data = require("./setup-cmd");
+  _setupCmd = function () {
+    return data;
+  };
+  return data;
+}
+function _setupUtils() {
+  const data = require("./setup-utils");
+  _setupUtils = function () {
+    return data;
+  };
+  return data;
+}
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
@@ -247,8 +268,7 @@ class CliMcpServerMain {
     }
 
     // Resolve the real path to handle symlinks (e.g., /tmp -> /private/tmp on macOS)
-    const fs = require('fs');
-    const realCwd = fs.realpathSync(cwd);
+    const realCwd = _fsExtra().default.realpathSync(cwd);
     let body;
     let url;
     if (isIDERoute) {
@@ -310,8 +330,6 @@ class CliMcpServerMain {
     const commands = this.cli.commands;
     const extended = Boolean(options.extended);
     this.bitBin = options.bitBin || this.bitBin;
-    // Default set of tools to include
-    const defaultTools = new Set(['create', 'schema', 'remote-search']);
 
     // Tools to always exclude
     const alwaysExcludeTools = new Set(['login', 'logout', 'completion', 'mcp-server', 'start', 'run-action', 'watch', 'run', 'resume-export', 'server', 'serve-preview']);
@@ -338,7 +356,7 @@ class CliMcpServerMain {
     });
 
     // Set of tools for consumer projects (non-Bit workspaces)
-    const consumerProjectTools = new Set(['schema', 'show', 'remote-search']);
+    const consumerProjectTools = new Set(['schema', 'show']);
     const consumerProject = Boolean(options.consumerProject);
 
     // Store consumer project mode globally in the class
@@ -346,7 +364,7 @@ class CliMcpServerMain {
 
     // Validate flags combination
     if (consumerProject) {
-      this.logger.debug(`[MCP-DEBUG] Running MCP server in consumer project mode (for non-Bit workspaces) with tools: ${Array.from(consumerProjectTools).join(', ')}`);
+      this.logger.debug(`[MCP-DEBUG] Running MCP server in consumer project mode (for non-Bit workspaces) with tools: ${Array.from(consumerProjectTools).join(', ')} + remote-search (always available)`);
       if (options.includeAdditional) {
         this.logger.debug(`[MCP-DEBUG] Additional tools enabled in consumer project mode: ${options.includeAdditional}`);
       }
@@ -355,7 +373,6 @@ class CliMcpServerMain {
       }
     }
     const filterOptions = {
-      defaultTools,
       additionalCommandsSet,
       userExcludeSet,
       alwaysExcludeTools,
@@ -376,12 +393,9 @@ class CliMcpServerMain {
         this.processSubCommands(server, cmd, filterOptions);
       }
     });
-    const remoteCommands = ['remote-search'];
-    remoteCommands.forEach(cmdName => {
-      if (this.shouldIncludeCommand(cmdName, filterOptions)) {
-        this.registerToolForRemote(server, cmdName);
-      }
-    });
+
+    // Always register remote-search tool
+    this.registerRemoteSearchTool(server);
 
     // Register the bit_workspace_info tool
     this.registerWorkspaceInfoTool(server);
@@ -389,10 +403,9 @@ class CliMcpServerMain {
     // Register the bit_component_details tool
     this.registerComponentDetailsTool(server);
 
-    // Register the bit_commands_info tool
-    this.registerCommandsInfoTool(server);
-
-    // Register arbitrary command execution tools
+    // Register command discovery and help tools
+    this.registerCommandsListTool(server);
+    this.registerCommandHelpTool(server);
     this.registerQueryTool(server);
     this.registerExecuteTool(server);
     await server.connect(new (_stdio().StdioServerTransport)());
@@ -428,8 +441,8 @@ class CliMcpServerMain {
       return shouldInclude;
     }
 
-    // Default mode: include default tools + any additional specified
-    return options.defaultTools.has(cmdName) || (options.additionalCommandsSet?.has(cmdName) ?? false);
+    // Default mode: only include additional specified commands (no default tools anymore)
+    return options.additionalCommandsSet?.has(cmdName) ?? false;
   }
   buildZodSchema(config) {
     const schema = {
@@ -522,16 +535,11 @@ class CliMcpServerMain {
       return this.runBit(argsToRun, params.cwd);
     });
   }
-  registerToolForRemote(server, name) {
-    if (name === 'remote-search') {
-      this.registerRemoteSearchTool(server);
-    }
-  }
   registerRemoteSearchTool(server) {
-    const toolName = this.getToolName('remote-search');
-    const description = 'Search for components in remote scopes';
+    const toolName = 'bit_remote_search';
+    const description = 'Search for components in remote scopes. Use this tool to find existing components before creating new ones. Essential for component reuse and discovery. Returns component IDs that can be converted to package names for installation (e.g., "teambit.design/ui/button" becomes "@teambit/design.ui.button"). Use broad keywords rather than multiple specific terms for better results.';
     const schema = {
-      queryStr: _zod().z.string().describe('Search query string')
+      queryStr: _zod().z.string().describe('Search query string - use broad keywords like "button", "form", "card" rather than multiple specific terms')
     };
     server.tool(toolName, description, schema, async params => {
       const http = await this.getHttp();
@@ -647,134 +655,147 @@ class CliMcpServerMain {
       }
     });
   }
-  registerCommandsInfoTool(server) {
-    const toolName = 'bit_commands_info';
-    const description = 'Get information about Bit commands and their groups. Specify command or subcommand to get detailed info.';
+  registerCommandsListTool(server) {
+    const toolName = 'bit_commands_list';
+    const description = 'Get all available Bit commands with descriptions and groups. Use this to discover what commands are available.';
     const schema = {
       extendedDescription: _zod().z.boolean().optional().describe('Include extended descriptions for commands (default: false)'),
-      internal: _zod().z.boolean().optional().describe('Include internal/debug commands (default: false)'),
-      command: _zod().z.string().optional().describe('Get info for a specific command only'),
-      subcommand: _zod().z.string().optional().describe('Get info for subcommands of a specific main command')
+      internal: _zod().z.boolean().optional().describe('Include internal/debug commands (default: false)')
     };
     server.tool(toolName, description, schema, async params => {
       try {
         const {
           extendedDescription = false,
-          internal = false,
-          command: specificCommand,
-          subcommand: specificSubcommand
+          internal = false
         } = params;
         const commandsInfo = [];
         const shouldSkipCommand = cmd => {
           return Boolean(cmd.private && !internal || cmd.description.startsWith('DEPRECATED'));
         };
-        const buildCommandInfo = (cmd, parentName, parentGroup, detailed = false) => {
-          if (shouldSkipCommand(cmd)) return null;
-          const cmdName = parentName ? `${parentName} ${(0, _cli().getCommandName)(cmd)}` : (0, _cli().getCommandName)(cmd);
-          const groupKey = cmd.group || parentGroup;
+
+        // Build list of all commands
+        this.cli.commands.forEach(cmd => {
+          if (shouldSkipCommand(cmd)) return;
+          const mainCmdName = (0, _cli().getCommandName)(cmd);
+          const groupKey = cmd.group;
           const commandInfo = {
-            name: cmdName,
-            description: cmd.description || ''
+            name: mainCmdName,
+            description: cmd.description || '',
+            alias: cmd.alias || ''
           };
           if (extendedDescription && cmd.extendedDescription) {
             commandInfo.extendedDescription = cmd.extendedDescription;
           }
           if (groupKey) commandInfo.group = this.cli.groups[groupKey] || groupKey;
-          if (!detailed) return commandInfo;
-
-          // Add detailed information
           if (cmd.helpUrl) commandInfo.helpUrl = cmd.helpUrl;
+
+          // Add subcommands summary
+          if (cmd.commands && cmd.commands.length > 0) {
+            commandInfo.subcommands = cmd.commands.filter(subCmd => !shouldSkipCommand(subCmd)).map(subCmd => ({
+              name: (0, _cli().getCommandName)(subCmd),
+              description: subCmd.description || '',
+              alias: subCmd.alias || ''
+            }));
+          }
+          commandsInfo.push(commandInfo);
+        });
+        commandsInfo.sort((a, b) => a.name.localeCompare(b.name));
+        const result = JSON.stringify({
+          total: commandsInfo.length,
+          commands: commandsInfo
+        }, null, 2);
+        this.logger.debug(`[MCP-DEBUG] Successfully retrieved commands list. Total: ${commandsInfo.length}`);
+        return this.formatAsCallToolResult(result);
+      } catch (error) {
+        this.logger.error(`[MCP-DEBUG] Error in bit_commands_list tool: ${error.message}`);
+        return this.formatErrorAsCallToolResult(error, 'getting commands list');
+      }
+    });
+  }
+  registerCommandHelpTool(server) {
+    const toolName = 'bit_command_help';
+    const description = 'Get detailed help for a specific Bit command including syntax, arguments, flags, and usage examples. Use this to understand exactly how to use a command.';
+    const schema = {
+      command: _zod().z.string().describe('The command name to get help for (e.g., "status", "install", "create")'),
+      subcommand: _zod().z.string().optional().describe('Optional subcommand name (e.g., for "lane show", use command="lane" and subcommand="show")')
+    };
+    server.tool(toolName, description, schema, async params => {
+      try {
+        const {
+          command: requestedCommand,
+          subcommand: requestedSubcommand
+        } = params;
+        let commandInfo = null;
+        const buildDetailedCommandInfo = (cmd, parentName) => {
+          const cmdName = parentName ? `${parentName} ${(0, _cli().getCommandName)(cmd)}` : (0, _cli().getCommandName)(cmd);
+          const info = {
+            name: cmdName,
+            description: cmd.description || '',
+            extendedDescription: cmd.extendedDescription || '',
+            alias: cmd.alias || '',
+            group: cmd.group ? this.cli.groups[cmd.group] || cmd.group : '',
+            helpUrl: cmd.helpUrl || '',
+            private: cmd.private || false
+          };
+
+          // Add arguments information
           const argsData = (0, _cli().getArgsData)(cmd);
           if (argsData.length > 0) {
-            commandInfo.arguments = argsData.map(arg => ({
+            info.arguments = argsData.map(arg => ({
               name: arg.nameRaw,
               description: arg.description || '',
               required: arg.required,
               isArray: arg.isArray
             }));
           }
-          commandInfo.options = (0, _cli().getFlagsData)(cmd);
-          commandInfo.examples = cmd.examples;
+
+          // Add options/flags information
+          info.options = (0, _cli().getFlagsData)(cmd);
+
+          // Add examples if available
+          if (cmd.examples) {
+            info.examples = cmd.examples;
+          }
+
+          // Add subcommands if available (including private ones for help purposes)
           if (cmd.commands && cmd.commands.length > 0) {
-            commandInfo.subcommands = cmd.commands.filter(subCmd => !shouldSkipCommand(subCmd)).map(subCmd => ({
-              name: `${cmdName} ${(0, _cli().getCommandName)(subCmd)}`,
+            info.subcommands = cmd.commands.map(subCmd => ({
+              name: (0, _cli().getCommandName)(subCmd),
               description: subCmd.description || '',
-              alias: subCmd.alias || '',
-              private: Boolean(subCmd.private)
+              alias: subCmd.alias || ''
             }));
           }
-          return commandInfo;
+          return info;
         };
 
-        // Handle specific command + subcommand lookup
-        if (specificCommand && specificSubcommand) {
-          this.cli.commands.forEach(cmd => {
-            if ((0, _cli().getCommandName)(cmd) === specificCommand && cmd.commands) {
-              const subCmd = cmd.commands.find(sub => (0, _cli().getCommandName)(sub) === specificSubcommand);
+        // Search for the requested command
+        this.cli.commands.forEach(cmd => {
+          const mainCmdName = (0, _cli().getCommandName)(cmd);
+          if (requestedSubcommand) {
+            // Looking for a subcommand
+            if (mainCmdName === requestedCommand && cmd.commands) {
+              const subCmd = cmd.commands.find(sub => (0, _cli().getCommandName)(sub) === requestedSubcommand);
               if (subCmd) {
-                const info = buildCommandInfo(subCmd, specificCommand, cmd.group, true);
-                if (info) commandsInfo.push(info);
-              }
-            }
-          });
-        }
-        // Handle subcommand-only lookup
-        else if (specificSubcommand && !specificCommand) {
-          this.cli.commands.forEach(cmd => {
-            if ((0, _cli().getCommandName)(cmd) === specificSubcommand && cmd.commands) {
-              cmd.commands.forEach(subCmd => {
-                const info = buildCommandInfo(subCmd, specificSubcommand, cmd.group);
-                if (info) commandsInfo.push(info);
-              });
-            }
-          });
-        }
-        // Handle specific command lookup or general listing
-        else {
-          const isDetailedMode = Boolean(specificCommand);
-          this.cli.commands.forEach(cmd => {
-            const mainCmdName = (0, _cli().getCommandName)(cmd);
-
-            // Process main command
-            if (!specificCommand || mainCmdName === specificCommand) {
-              const info = buildCommandInfo(cmd, undefined, undefined, isDetailedMode);
-              if (info && (!specificCommand || info.name === specificCommand)) {
-                commandsInfo.push(info);
+                commandInfo = buildDetailedCommandInfo(subCmd, requestedCommand);
               }
             }
-
-            // Process subcommands
-            if (cmd.commands) {
-              cmd.commands.forEach(subCmd => {
-                const subCmdInfo = buildCommandInfo(subCmd, mainCmdName, cmd.group, isDetailedMode);
-                if (subCmdInfo && (!specificCommand || subCmdInfo.name === specificCommand)) {
-                  commandsInfo.push(subCmdInfo);
-                }
-              });
+          } else {
+            // Looking for a main command
+            if (mainCmdName === requestedCommand) {
+              commandInfo = buildDetailedCommandInfo(cmd);
             }
-          });
-        }
-        commandsInfo.sort((a, b) => a.name.localeCompare(b.name));
-        if (commandsInfo.length === 0) {
-          let errorMessage = 'No commands found';
-          if (specificCommand && specificSubcommand) {
-            errorMessage = `No subcommand "${specificSubcommand}" found for command: ${specificCommand}`;
-          } else if (specificCommand) {
-            errorMessage = `No command found with name: ${specificCommand}`;
-          } else if (specificSubcommand) {
-            errorMessage = `No subcommands found for command: ${specificSubcommand}`;
           }
-          return this.formatAsCallToolResult(errorMessage);
+        });
+        if (!commandInfo) {
+          const commandFullName = requestedSubcommand ? `${requestedCommand} ${requestedSubcommand}` : requestedCommand;
+          return this.formatAsCallToolResult(`Command not found: ${commandFullName}`);
         }
-        const result = JSON.stringify({
-          total: commandsInfo.length,
-          commands: commandsInfo
-        }, null, 2);
-        this.logger.debug(`[MCP-DEBUG] Successfully retrieved commands info. Total: ${commandsInfo.length}`);
+        const result = JSON.stringify(commandInfo, null, 2);
+        this.logger.debug(`[MCP-DEBUG] Successfully retrieved command help for: ${commandInfo.name}`);
         return this.formatAsCallToolResult(result);
       } catch (error) {
-        this.logger.error(`[MCP-DEBUG] Error in bit_commands_info tool: ${error.message}`);
-        return this.formatErrorAsCallToolResult(error, 'getting commands info');
+        this.logger.error(`[MCP-DEBUG] Error in bit_command_help tool: ${error.message}`);
+        return this.formatErrorAsCallToolResult(error, 'getting command help');
       }
     });
   }
@@ -828,21 +849,30 @@ class CliMcpServerMain {
   }
   registerExecuteTool(server) {
     const toolName = 'bit_execute';
-    const description = 'Execute any Bit command, including those that modify workspace or repository state. ⚠️ Use with caution as this can make permanent changes to your project. Consider using bit_query for read-only operations.';
+    const description = 'Execute Bit commands that make changes to workspace or components (not read-only).';
     const schema = {
       cwd: _zod().z.string().describe('Path to workspace directory'),
-      command: _zod().z.string().describe('The Bit command to execute (e.g., "add", "tag", "export", "remove")'),
+      command: _zod().z.string().describe('The Bit command to execute (e.g., "import", "tag", "export", "remove")'),
       args: _zod().z.array(_zod().z.string()).optional().describe('Arguments to pass to the command'),
       flags: _zod().z.record(_zod().z.union([_zod().z.string(), _zod().z.boolean()])).optional().describe('Flags to pass to the command as key-value pairs')
     };
     server.tool(toolName, description, schema, async params => {
       try {
-        const {
+        let {
           command,
-          args = [],
+          args = []
+        } = params;
+        const {
           flags = {},
           cwd
         } = params;
+
+        // Handle sub-commands: if command has multiple words, move the second word to args
+        const commandParts = command.trim().split(/\s+/);
+        if (commandParts.length > 1) {
+          command = commandParts[0];
+          args = [commandParts[1], ...args];
+        }
         this.logger.debug(`[MCP-DEBUG] Executing command: ${command} with args: ${JSON.stringify(args)} and flags: ${JSON.stringify(flags)}`);
         const result = await this.callBitServerAPI(command, args, flags, cwd);
         return this.formatAsCallToolResult(result);
@@ -965,10 +995,37 @@ class CliMcpServerMain {
       }
     }
   }
+
+  // Setup command business logic methods
+  getEditorDisplayName(editor) {
+    return _setupUtils().McpSetupUtils.getEditorDisplayName(editor);
+  }
+  async setupEditor(editor, options, workspaceDir) {
+    const supportedEditors = ['vscode', 'cursor', 'windsurf'];
+    const editorLower = editor.toLowerCase();
+    if (!supportedEditors.includes(editorLower)) {
+      throw new Error(`Editor "${editor}" is not supported yet. Currently supported: ${supportedEditors.join(', ')}`);
+    }
+
+    // Add workspaceDir to options if provided
+    const setupOptions = _objectSpread({}, options);
+    if (workspaceDir) {
+      setupOptions.workspaceDir = workspaceDir;
+    }
+    if (editorLower === 'vscode') {
+      await _setupUtils().McpSetupUtils.setupVSCode(setupOptions);
+    } else if (editorLower === 'cursor') {
+      await _setupUtils().McpSetupUtils.setupCursor(setupOptions);
+    } else if (editorLower === 'windsurf') {
+      await _setupUtils().McpSetupUtils.setupWindsurf(setupOptions);
+    }
+  }
   static async provider([cli, loggerMain]) {
     const logger = loggerMain.createLogger(_cliMcpServer().CliMcpServerAspect.id);
     const mcpServer = new CliMcpServerMain(cli, logger);
-    cli.register(new (_mcpServer().McpServerCmd)(mcpServer));
+    const mcpServerCmd = new (_mcpServer().McpServerCmd)(mcpServer);
+    mcpServerCmd.commands = [new (_mcpServer().McpStartCmd)(mcpServer), new (_setupCmd().McpSetupCmd)(mcpServer)];
+    cli.register(mcpServerCmd);
     return mcpServer;
   }
 }