@teambit/cli-mcp-server 0.0.16 → 0.0.18

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

@@ -116,6 +116,13 @@ function _setupCmd() {
   };
   return data;
 }
+function _rulesCmd() {
+  const data = require("./rules-cmd");
+  _rulesCmd = function () {
+    return data;
+  };
+  return data;
+}
 function _setupUtils() {
   const data = require("./setup-utils");
   _setupUtils = function () {
@@ -349,35 +356,24 @@ class CliMcpServerMain {
   async runMcpServer(options) {
     this.logger.debug(`[MCP-DEBUG] Starting MCP server with options: ${JSON.stringify(options)}. CWD: ${process.cwd()}`);
     const commands = this.cli.commands;
-    const extended = Boolean(options.extended);
     this.bitBin = options.bitBin || this.bitBin;
 
     // Tools to always exclude
     const alwaysExcludeTools = new Set(['login', 'logout', 'completion', 'mcp-server', 'start', 'run-action', 'watch', 'run', 'resume-export', 'server', 'serve-preview']);
 
     // Parse command strings from flag options
-    let includeOnlySet;
-    if (options.includeOnly) {
-      includeOnlySet = new Set(options.includeOnly.split(',').map(cmd => cmd.trim()));
-      this.logger.debug(`[MCP-DEBUG] Including only commands: ${Array.from(includeOnlySet).join(', ')}`);
-    }
     let additionalCommandsSet;
     if (options.includeAdditional) {
       additionalCommandsSet = new Set(options.includeAdditional.split(',').map(cmd => cmd.trim()));
       this.logger.debug(`[MCP-DEBUG] Including additional commands: ${Array.from(additionalCommandsSet).join(', ')}`);
     }
-    let userExcludeSet;
-    if (options.exclude) {
-      userExcludeSet = new Set(options.exclude.split(',').map(cmd => cmd.trim()));
-      this.logger.debug(`[MCP-DEBUG] Excluding commands: ${Array.from(userExcludeSet).join(', ')}`);
-    }
     const server = new (_mcp().McpServer)({
       name: 'bit-cli-mcp',
       version: '0.0.1'
     });
 
     // Set of tools for consumer projects (non-Bit workspaces)
-    const consumerProjectTools = new Set(['schema', 'show']);
+    const consumerProjectTools = new Set();
     const consumerProject = Boolean(options.consumerProject);
 
     // Store consumer project mode globally in the class
@@ -385,21 +381,14 @@ 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(', ')} + remote-search (always available)`);
+      this.logger.debug(`[MCP-DEBUG] Running MCP server in consumer project mode (for non-Bit workspaces) with tools: bit_remote_search, bit_remote_component_details`);
       if (options.includeAdditional) {
         this.logger.debug(`[MCP-DEBUG] Additional tools enabled in consumer project mode: ${options.includeAdditional}`);
       }
-      if (extended) {
-        this.logger.warn('[MCP-DEBUG] Warning: --consumer-project and --extended flags were both provided. The --extended flag will be ignored.');
-      }
     }
     const filterOptions = {
       additionalCommandsSet,
-      userExcludeSet,
       alwaysExcludeTools,
-      extended: consumerProject ? false : extended,
-      // Ignore extended when consumerProject is true
-      includeOnlySet,
       consumerProject,
       consumerProjectTools
     };
@@ -418,41 +407,30 @@ class CliMcpServerMain {
     // Always register remote-search tool
     this.registerRemoteSearchTool(server);
 
-    // Register the bit_workspace_info tool
-    this.registerWorkspaceInfoTool(server);
+    // In consumer project mode, only register bit_remote_search and bit_remote_component_details
+    // All other tools should not be available in consumer project mode
+    if (consumerProject) {
+      // Register the new combined remote component details tool
+      this.registerRemoteComponentDetailsTool(server);
+    } else {
+      // Register the bit_workspace_info tool
+      this.registerWorkspaceInfoTool(server);
 
-    // Register the bit_component_details tool
-    this.registerComponentDetailsTool(server);
+      // Register the bit_component_details tool
+      this.registerComponentDetailsTool(server);
 
-    // Register command discovery and help tools
-    this.registerCommandsListTool(server);
-    this.registerCommandHelpTool(server);
-    this.registerQueryTool(server);
-    this.registerExecuteTool(server);
+      // Register command discovery and help tools
+      this.registerCommandsListTool(server);
+      this.registerCommandHelpTool(server);
+      this.registerQueryTool(server);
+      this.registerExecuteTool(server);
+    }
     await server.connect(new (_stdio().StdioServerTransport)());
   }
   shouldIncludeCommand(cmdName, options) {
     // Always exclude certain commands
     if (options.alwaysExcludeTools.has(cmdName)) return false;
 
-    // User-specified exclude takes precedence
-    if (options.userExcludeSet?.has(cmdName)) {
-      this.logger.debug(`[MCP-DEBUG] Excluding command due to --exclude flag: ${cmdName}`);
-      return false;
-    }
-
-    // If includeOnly is specified, only include those specific commands
-    if (options.includeOnlySet) {
-      const shouldInclude = options.includeOnlySet.has(cmdName);
-      if (shouldInclude) {
-        this.logger.debug(`[MCP-DEBUG] Including command due to --include-only flag: ${cmdName}`);
-      }
-      return shouldInclude;
-    }
-
-    // Extended mode includes all commands except excluded ones
-    if (options.extended) return true;
-
     // Consumer project mode: only include consumer project tools + any additional specified
     if (options.consumerProject) {
       const shouldInclude = options.consumerProjectTools.has(cmdName) || (options.additionalCommandsSet?.has(cmdName) ?? false);
@@ -656,6 +634,47 @@ class CliMcpServerMain {
       };
     });
   }
+  registerRemoteComponentDetailsTool(server) {
+    const toolName = 'bit_remote_component_details';
+    const description = 'Get detailed information about a remote component including basic info and its public API schema. Combines the functionality of show and schema commands for remote components.';
+    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: true)')
+    };
+    server.tool(toolName, description, schema, async params => {
+      try {
+        const {
+          componentName,
+          includeSchema = true,
+          cwd
+        } = params;
+
+        // Get basic component information using show command via direct execution
+        const showArgs = ['show', componentName, '--remote', '--legacy'];
+        const showResult = await this.runBit(showArgs, cwd);
+        const result = {
+          componentInfo: showResult.content[0].text
+        };
+
+        // Get schema information if requested
+        if (includeSchema) {
+          try {
+            const schemaArgs = ['schema', componentName, '--remote'];
+            const schemaResult = await this.runBit(schemaArgs, cwd);
+            result.schema = schemaResult.content[0].text;
+          } catch (schemaError) {
+            this.logger.warn(`[MCP-DEBUG] Failed to get schema for ${componentName}: ${schemaError.message}`);
+            result.schemaError = `Failed to retrieve schema: ${schemaError.message}`;
+          }
+        }
+        return this.formatAsCallToolResult(result);
+      } catch (error) {
+        this.logger.error(`[MCP-DEBUG] Error in bit_remote_component_details tool: ${error.message}`);
+        return this.formatErrorAsCallToolResult(error, 'getting remote component details');
+      }
+    });
+  }
   registerWorkspaceInfoTool(server) {
     const toolName = 'bit_workspace_info';
     const description = 'Get comprehensive workspace information including status, components list, apps, templates, dependency graph, and workspace dependencies';
@@ -986,7 +1005,11 @@ class CliMcpServerMain {
     const cmd = `${this.bitBin} ${args.join(' ')}`;
     try {
       const cmdOutput = _child_process().default.execSync(cmd, {
-        cwd
+        cwd,
+        env: _objectSpread(_objectSpread({}, process.env), {}, {
+          BIT_DISABLE_SPINNER: '1'
+        }),
+        stdio: 'pipe'
       });
       this.logger.debug(`[MCP-DEBUG] result. stdout: ${cmdOutput}`);
       return {
@@ -1120,11 +1143,32 @@ class CliMcpServerMain {
       await _setupUtils().McpSetupUtils.setupWindsurf(setupOptions);
     }
   }
+  async writeRulesFile(editor, options, workspaceDir) {
+    const supportedEditors = ['vscode', 'cursor'];
+    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 rulesOptions = _objectSpread({}, options);
+    if (workspaceDir) {
+      rulesOptions.workspaceDir = workspaceDir;
+    }
+    if (editorLower === 'vscode') {
+      await _setupUtils().McpSetupUtils.writeVSCodeRules(rulesOptions);
+    } else if (editorLower === 'cursor') {
+      await _setupUtils().McpSetupUtils.writeCursorRules(rulesOptions);
+    }
+  }
+  async getRulesContent(consumerProject = false) {
+    return _setupUtils().McpSetupUtils.getDefaultRulesContent(consumerProject);
+  }
   static async provider([cli, loggerMain]) {
     const logger = loggerMain.createLogger(_cliMcpServer().CliMcpServerAspect.id);
     const mcpServer = new CliMcpServerMain(cli, logger);
     const mcpServerCmd = new (_mcpServer().McpServerCmd)(mcpServer);
-    mcpServerCmd.commands = [new (_mcpServer().McpStartCmd)(mcpServer), new (_setupCmd().McpSetupCmd)(mcpServer)];
+    mcpServerCmd.commands = [new (_mcpServer().McpStartCmd)(mcpServer), new (_setupCmd().McpSetupCmd)(mcpServer), new (_rulesCmd().McpRulesCmd)(mcpServer)];
     cli.register(mcpServerCmd);
     return mcpServer;
   }