@teambit/cli-mcp-server 0.0.11 → 0.0.13

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; }
@@ -213,6 +234,20 @@ class CliMcpServerMain {
    * Call bit-server API endpoint using cli-raw route
    */
   async callBitServerAPI(command, args = [], flags = {}, cwd, isReTrying = false) {
+    return this.callBitServerAPIWithRoute('cli-raw', command, args, flags, cwd, isReTrying);
+  }
+
+  /**
+   * Call bit-server API endpoint using IDE route
+   */
+  async callBitServerIDEAPI(method, args = [], cwd, isReTrying = false) {
+    return this.callBitServerAPIWithRoute('ide', method, args, {}, cwd, isReTrying, true);
+  }
+
+  /**
+   * Generic method to call bit-server API with different routes
+   */
+  async callBitServerAPIWithRoute(route, commandOrMethod, argsOrParams = [], flags = {}, cwd, isReTrying = false, isIDERoute = false) {
     if (!this.serverPort) {
       if (!cwd) throw new Error('CWD is required to call bit-server API');
       this.serverPort = await this.getBitServerPort(cwd);
@@ -232,27 +267,36 @@ class CliMcpServerMain {
       throw new Error('Unable to connect to bit-server. Please ensure you are in a valid Bit workspace.');
     }
 
-    // Build the command array: [command, ...args, ...flagsAsArgs]
-    const commandArray = [command, ...args];
+    // Resolve the real path to handle symlinks (e.g., /tmp -> /private/tmp on macOS)
+    const realCwd = _fsExtra().default.realpathSync(cwd);
+    let body;
+    let url;
+    if (isIDERoute) {
+      // For IDE route, use the method name and args directly
+      body = {
+        args: argsOrParams
+      };
+      url = `${this.serverUrl}/${route}/${commandOrMethod}`;
+    } else {
+      // For CLI route, build command array with flags
+      const commandArray = [commandOrMethod, ...argsOrParams];
 
-    // Convert flags to command line arguments
-    for (const [key, value] of Object.entries(flags)) {
-      if (value === true) {
-        commandArray.push(`--${key}`);
-      } else if (value !== false && value !== undefined) {
-        commandArray.push(`--${key}`, String(value));
+      // Convert flags to command line arguments
+      for (const [key, value] of Object.entries(flags)) {
+        if (value === true) {
+          commandArray.push(`--${key}`);
+        } else if (value !== false && value !== undefined) {
+          commandArray.push(`--${key}`, String(value));
+        }
       }
+      body = {
+        command: commandArray,
+        pwd: realCwd
+      };
+      url = `${this.serverUrl}/${route}`;
     }
-
-    // Resolve the real path to handle symlinks (e.g., /tmp -> /private/tmp on macOS)
-    const fs = require('fs');
-    const realCwd = fs.realpathSync(cwd);
-    const body = {
-      command: commandArray,
-      pwd: realCwd
-    };
     try {
-      const response = await (0, _nodeFetch().default)(`${this.serverUrl}/cli-raw`, {
+      const response = await (0, _nodeFetch().default)(url, {
         method: 'POST',
         headers: {
           'Content-Type': 'application/json'
@@ -276,7 +320,7 @@ class CliMcpServerMain {
         this.serverPort = undefined;
         this.serverUrl = undefined;
         this.logger.debug('[MCP-DEBUG] Connection refused, attempting to restart bit-server');
-        return this.callBitServerAPI(command, args, flags, cwd, true);
+        return this.callBitServerAPIWithRoute(route, commandOrMethod, argsOrParams, flags, cwd, true, isIDERoute);
       }
       throw err;
     }
@@ -365,10 +409,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)());
@@ -602,37 +645,20 @@ class CliMcpServerMain {
     const schema = {
       cwd: _zod().z.string().describe('Path to workspace directory'),
       componentName: _zod().z.string().describe('Component name or component ID to get details for'),
-      includeSchema: _zod().z.boolean().optional().describe('Include component public API schema (default: false)'),
-      remote: _zod().z.boolean().optional().describe('Get details from remote scope (default: false)')
+      includeSchema: _zod().z.boolean().optional().describe('Include component public API schema (default: false)')
     };
     server.tool(toolName, description, schema, async params => {
       try {
         const includeSchema = params.includeSchema === true;
-        const remote = params.remote === true;
         const componentName = params.componentName;
-        const componentDetails = {};
 
-        // Get basic component information using bit show
-        const showFlags = {
-          json: true
-        };
-        if (remote) {
-          showFlags.remote = true;
-        }
-        const showExecution = await this.safeBitCommandExecution('show', [componentName], showFlags, params.cwd, 'get component show info', true);
-        componentDetails.show = showExecution.result;
+        // Get component details using IDE API with includeSchema parameter
+        const ideApiResult = await this.callBitServerIDEAPI('getCompDetails', [componentName, includeSchema], params.cwd);
 
-        // Get component schema (public API) if requested
-        if (includeSchema) {
-          const schemaFlags = {
-            json: true
-          };
-          if (remote) {
-            schemaFlags.remote = true;
-          }
-          const schemaExecution = await this.safeBitCommandExecution('schema', [componentName], schemaFlags, params.cwd, 'get component schema', true);
-          componentDetails.schema = schemaExecution.result;
-        }
+        // IDE API returns the result directly, not wrapped in success/error structure
+        const componentDetails = {
+          show: ideApiResult
+        };
         return this.formatAsCallToolResult(componentDetails);
       } catch (error) {
         this.logger.error(`[MCP-DEBUG] Error in bit_component_details tool: ${error.message}`);
@@ -640,134 +666,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);
+                commandInfo = buildDetailedCommandInfo(subCmd, requestedCommand);
               }
             }
-          });
-        }
-        // 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);
-              });
+          } else {
+            // Looking for a main command
+            if (mainCmdName === requestedCommand) {
+              commandInfo = buildDetailedCommandInfo(cmd);
             }
-          });
-        }
-        // 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);
-              }
-            }
-
-            // 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);
-                }
-              });
-            }
-          });
-        }
-        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');
       }
     });
   }
@@ -821,21 +860,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);
@@ -958,10 +1006,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;
   }
 }