@teambit/cli-mcp-server 0.0.0-07691cc41fb4080a5f5b744e505ccc83cda772a8

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

@@ -0,0 +1,1250 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.CliMcpServerMain = void 0;
+function _cli() {
+  const data = require("@teambit/cli");
+  _cli = function () {
+    return data;
+  };
+  return data;
+}
+function _child_process() {
+  const data = _interopRequireDefault(require("child_process"));
+  _child_process = function () {
+    return data;
+  };
+  return data;
+}
+function _stripAnsi() {
+  const data = _interopRequireDefault(require("strip-ansi"));
+  _stripAnsi = function () {
+    return data;
+  };
+  return data;
+}
+function _fsExtra() {
+  const data = _interopRequireDefault(require("fs-extra"));
+  _fsExtra = function () {
+    return data;
+  };
+  return data;
+}
+function _commentJson() {
+  const data = require("comment-json");
+  _commentJson = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _cliMcpServer() {
+  const data = require("./cli-mcp-server.aspect");
+  _cliMcpServer = function () {
+    return data;
+  };
+  return data;
+}
+function _mcpServer() {
+  const data = require("./mcp-server.cmd");
+  _mcpServer = function () {
+    return data;
+  };
+  return data;
+}
+function _mcp() {
+  const data = require("@modelcontextprotocol/sdk/server/mcp.js");
+  _mcp = function () {
+    return data;
+  };
+  return data;
+}
+function _stdio() {
+  const data = require("@modelcontextprotocol/sdk/server/stdio.js");
+  _stdio = function () {
+    return data;
+  };
+  return data;
+}
+function _zod() {
+  const data = require("zod");
+  _zod = function () {
+    return data;
+  };
+  return data;
+}
+function _logger() {
+  const data = require("@teambit/logger");
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
+function _scope() {
+  const data = require("@teambit/scope.network");
+  _scope = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy() {
+  const data = require("@teambit/legacy.constants");
+  _legacy = function () {
+    return data;
+  };
+  return data;
+}
+function _nodeFetch() {
+  const data = _interopRequireDefault(require("node-fetch"));
+  _nodeFetch = function () {
+    return data;
+  };
+  return data;
+}
+function _setupCmd() {
+  const data = require("./setup-cmd");
+  _setupCmd = function () {
+    return data;
+  };
+  return data;
+}
+function _rulesCmd() {
+  const data = require("./rules-cmd");
+  _rulesCmd = 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; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } /* eslint-disable import/extensions */ /* eslint-disable import/no-unresolved */
+class CliMcpServerMain {
+  constructor(cli, logger) {
+    this.cli = cli;
+    this.logger = logger;
+    _defineProperty(this, "bitBin", 'bit');
+    _defineProperty(this, "_http", void 0);
+    _defineProperty(this, "isConsumerProjectMode", false);
+    _defineProperty(this, "serverPort", void 0);
+    _defineProperty(this, "serverUrl", void 0);
+    _defineProperty(this, "serverProcess", null);
+    // Whitelist of commands that are considered read-only/query operations
+    _defineProperty(this, "readOnlyCommands", new Set(['status', 'list', 'info', 'show', 'schema', 'artifacts', 'diff', 'log', 'graph', 'deps get', 'deps blame', 'why', 'config get', 'envs list', 'envs get', 'remote list', 'templates', 'cat-component', 'cat-lane', 'cat-object', 'cat-scope', 'lane show', 'lane list', 'lane diff', 'lane history', 'lane history-diff', 'test', 'help', 'version']));
+    // Validate the default bitBin on construction
+    this.bitBin = this.validateBitBin(this.bitBin);
+  }
+  async getHttp() {
+    if (!this._http) {
+      this._http = await _scope().Http.connect(_legacy().SYMPHONY_GRAPHQL, _legacy().CENTRAL_BIT_HUB_NAME);
+    }
+    return this._http;
+  }
+  async getBitServerPort(cwd, skipValidatePortFlag = false) {
+    try {
+      const args = ['cli-server-port'];
+      if (skipValidatePortFlag) {
+        args.push(String(skipValidatePortFlag));
+      }
+      const result = _child_process().default.spawnSync(this.bitBin, args, {
+        cwd,
+        env: _objectSpread(_objectSpread({}, process.env), {}, {
+          BIT_CLI_SERVER: 'true'
+        }),
+        encoding: 'utf8'
+      });
+      if (result.error) {
+        throw result.error;
+      }
+      if (result.status !== 0) {
+        throw new Error(`Command failed with status ${result.status}: ${result.stderr}`);
+      }
+      const existingPort = result.stdout.trim();
+      if (!existingPort) return undefined;
+      return parseInt(existingPort, 10);
+    } catch (err) {
+      this.logger.error(`[MCP-DEBUG] error getting existing port from bit server at ${cwd}. err: ${err.message}`);
+      return undefined;
+    }
+  }
+
+  /**
+   * Start a new bit-server process
+   */
+  async startBitServer(cwd) {
+    this.logger.debug('[MCP-DEBUG] Starting new bit-server process');
+    return new Promise((resolve, reject) => {
+      try {
+        const serverProcess = _child_process().default.spawn(this.bitBin, ['server'], {
+          cwd,
+          stdio: ['pipe', 'pipe', 'pipe'],
+          detached: false
+        });
+        this.serverProcess = serverProcess;
+        let serverStarted = false;
+        let outputBuffer = '';
+        const timeout = setTimeout(() => {
+          if (!serverStarted) {
+            this.logger.error('[MCP-DEBUG] Timeout waiting for bit-server to start');
+            serverProcess.kill();
+            resolve(null);
+          }
+        }, 30000); // 30 second timeout
+
+        serverProcess.stdout?.on('data', data => {
+          const output = data.toString();
+          outputBuffer += output;
+          this.logger.debug(`[MCP-DEBUG] bit-server stdout: ${output}`);
+          if (output.includes('listening on port')) {
+            clearTimeout(timeout);
+            if (!serverStarted) {
+              serverStarted = true;
+              // Extract the port from the output
+              const portMatch = output.match(/listening on port (\d+)/);
+              if (portMatch && portMatch[1]) {
+                const port = parseInt(portMatch[1], 10);
+                this.logger.debug(`[MCP-DEBUG] bit-server started on port ${port}`);
+                this.serverPort = port;
+                this.serverUrl = `http://localhost:${port}/api`;
+                resolve(port);
+              }
+            }
+          }
+        });
+        serverProcess.stderr?.on('data', data => {
+          const error = data.toString();
+          outputBuffer += error;
+          this.logger.debug(`[MCP-DEBUG] bit-server stderr: ${error}`);
+        });
+        serverProcess.on('error', err => {
+          clearTimeout(timeout);
+          this.logger.error(`[MCP-DEBUG] Failed to start bit-server: ${err.message}`);
+          reject(err);
+        });
+        serverProcess.on('exit', (code, signal) => {
+          clearTimeout(timeout);
+          if (!serverStarted) {
+            this.logger.error(`[MCP-DEBUG] bit-server exited with code ${code}, signal ${signal}`);
+            this.logger.debug(`[MCP-DEBUG] bit-server output: ${outputBuffer}`);
+            resolve(null);
+          }
+        });
+        const killServerProcess = () => {
+          if (this.serverProcess && !this.serverProcess.killed) {
+            this.logger.debug('[MCP-DEBUG] Killing bit-server process');
+            this.serverProcess.kill();
+          }
+        };
+
+        // Handle process cleanup
+        process.on('exit', () => {
+          killServerProcess();
+        });
+        process.on('SIGINT', () => {
+          killServerProcess();
+          process.exit();
+        });
+        process.on('SIGTERM', () => {
+          killServerProcess();
+          process.exit();
+        });
+      } catch (err) {
+        this.logger.error(`[MCP-DEBUG] Error spawning bit-server: ${err.message}`);
+        reject(err);
+      }
+    });
+  }
+
+  /**
+   * 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);
+      if (this.serverPort) {
+        this.serverUrl = `http://localhost:${this.serverPort}/api`;
+      } else {
+        // No server running, try to start one
+        this.logger.debug('[MCP-DEBUG] No bit-server found, attempting to start one');
+        const startedPort = await this.startBitServer(cwd);
+        if (startedPort) {
+          this.serverPort = startedPort;
+          this.serverUrl = `http://localhost:${this.serverPort}/api`;
+        }
+      }
+    }
+    if (!this.serverUrl) {
+      throw new Error('Unable to connect to bit-server. Please ensure you are in a valid Bit workspace.');
+    }
+
+    // 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));
+        }
+      }
+      body = {
+        command: commandArray,
+        pwd: realCwd
+      };
+      url = `${this.serverUrl}/${route}`;
+    }
+    try {
+      const response = await (0, _nodeFetch().default)(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) {
+        let errorMessage = `HTTP ${response.status}: ${response.statusText}`;
+        try {
+          const errorJson = await response.json();
+          errorMessage = errorJson.message || errorJson || errorMessage;
+        } catch {
+          // Ignore JSON parse errors
+        }
+        throw new Error(errorMessage);
+      }
+      return await response.json();
+    } catch (err) {
+      if (err.code === 'ECONNREFUSED' && !isReTrying) {
+        // Server is no longer running, reset cached values and try to restart
+        this.serverPort = undefined;
+        this.serverUrl = undefined;
+        this.logger.debug('[MCP-DEBUG] Connection refused, attempting to restart bit-server');
+        return this.callBitServerAPIWithRoute(route, commandOrMethod, argsOrParams, flags, cwd, true, isIDERoute);
+      }
+      throw err;
+    }
+  }
+  async runMcpServer(options) {
+    this.logger.debug(`[MCP-DEBUG] Starting MCP server with options: ${JSON.stringify(options)}. CWD: ${process.cwd()}`);
+    const commands = this.cli.commands;
+
+    // Validate and set bitBin with security checks
+    if (options.bitBin) {
+      this.bitBin = this.validateBitBin(options.bitBin);
+    }
+    // If no bitBin provided, keep the default 'bit'
+
+    // 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 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(', ')}`);
+    }
+    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();
+    const consumerProject = Boolean(options.consumerProject);
+
+    // Store consumer project mode globally in the class
+    this.isConsumerProjectMode = consumerProject;
+
+    // Validate flags combination
+    if (consumerProject) {
+      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}`);
+      }
+    }
+    const filterOptions = {
+      additionalCommandsSet,
+      alwaysExcludeTools,
+      consumerProject,
+      consumerProjectTools
+    };
+    commands.forEach(cmd => {
+      const cmdName = (0, _cli().getCommandName)(cmd);
+      if (this.shouldIncludeCommand(cmdName, filterOptions)) {
+        this.registerToolForCommand(server, cmd);
+      }
+
+      // Process sub-commands
+      if (cmd.commands && cmd.commands.length) {
+        this.processSubCommands(server, cmd, filterOptions);
+      }
+    });
+
+    // Always register remote-search tool
+    this.registerRemoteSearchTool(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 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;
+
+    // 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);
+      if (shouldInclude) {
+        this.logger.debug(`[MCP-DEBUG] Including command in consumer project mode: ${cmdName}`);
+      }
+      return shouldInclude;
+    }
+
+    // Default mode: only include additional specified commands (no default tools anymore)
+    return options.additionalCommandsSet?.has(cmdName) ?? false;
+  }
+  buildZodSchema(config) {
+    const schema = {
+      // Add cwd parameter as mandatory to all commands
+      cwd: _zod().z.string().describe('Path to workspace')
+    };
+    config.argsData.forEach(arg => {
+      const desc = arg.description || `Positional argument: ${arg.nameRaw}`;
+      if (arg.isArray) {
+        schema[arg.nameCamelCase] = arg.required ? _zod().z.array(_zod().z.string()).describe(desc) : _zod().z.array(_zod().z.string()).optional().describe(desc);
+      } else {
+        schema[arg.nameCamelCase] = arg.required ? _zod().z.string().describe(desc) : _zod().z.string().optional().describe(desc);
+      }
+    });
+    config.flagsData.forEach(flag => {
+      const type = flag.type;
+      schema[flag.name] = type === 'string' ? _zod().z.string().optional().describe(flag.description) : _zod().z.boolean().optional().describe(flag.description);
+    });
+    return schema;
+  }
+  buildCommandArgs(config, params) {
+    // Split the command name on spaces to properly handle subcommands
+    const args = config.name.split(' ');
+
+    // Add positional arguments in order
+    config.argsData.forEach(arg => {
+      const val = params[arg.nameCamelCase];
+      if (val === undefined) return;
+      if (arg.isArray && Array.isArray(val)) {
+        val.forEach(item => args.push(item));
+      } else {
+        args.push(val);
+      }
+    });
+
+    // Add options as flags
+    config.flagsData.forEach(flag => {
+      const name = flag.name;
+      const type = flag.type;
+      const val = params[name];
+      if (val === undefined) return;
+      if (type === 'boolean' && val) {
+        args.push(`--${name}`);
+      } else if (type === 'string' && val) {
+        // Check if the string value contains spaces and quote it if necessary
+        const stringValue = String(val);
+        if (stringValue.includes(' ')) {
+          args.push(`--${name}`, `"${stringValue}"`);
+        } else {
+          args.push(`--${name}`, stringValue);
+        }
+      }
+    });
+    return args;
+  }
+  getToolName(name) {
+    // replace white spaces (\s) and dashes (-) with underscores (_)
+    return `bit_${name}`.replace(/[-\s]/g, '_');
+  }
+  registerToolForCommand(server, cmd, parentCmd) {
+    const cmdName = parentCmd ? `${(0, _cli().getCommandName)(parentCmd)} ${(0, _cli().getCommandName)(cmd)}` : (0, _cli().getCommandName)(cmd);
+    const toolName = this.getToolName(cmdName);
+
+    // Modify description for show and schema commands in consumer project mode
+    let description = `${cmd.description}${cmd.extendedDescription ? `.\n(${cmd.extendedDescription})` : ''}`;
+    if (this.isConsumerProjectMode && (cmdName === 'show' || cmdName === 'schema')) {
+      description += `\n(In consumer project mode, --remote flag is automatically added)`;
+    }
+    const config = {
+      name: cmdName,
+      description,
+      argsData: (0, _cli().getArgsData)(cmd),
+      flagsData: (0, _cli().getFlagsData)(cmd)
+    };
+    const schema = this.buildZodSchema(config);
+    server.tool(toolName, config.description, schema, async params => {
+      const argsToRun = this.buildCommandArgs(config, params);
+
+      // Special handling for consumer projects - auto-add --remote flag for show and schema commands
+      if (this.isConsumerProjectMode && (cmdName === 'show' || cmdName === 'schema')) {
+        if (!argsToRun.includes('--remote')) {
+          this.logger.debug(`[MCP-DEBUG] Auto-adding --remote flag for ${cmdName} in consumer project mode`);
+          argsToRun.push('--remote');
+        }
+        if (cmdName === 'show' && !argsToRun.includes('--legacy')) {
+          this.logger.debug(`[MCP-DEBUG] Auto-adding --legacy flag for ${cmdName} in consumer project mode`);
+          argsToRun.push('--legacy');
+        }
+      }
+      return this.runBit(argsToRun, params.cwd);
+    });
+  }
+
+  /**
+   * Read and parse workspace.jsonc file from a given directory
+   */
+  async readWorkspaceJsonc(workspaceDir) {
+    try {
+      const workspaceJsoncPath = _path().default.join(workspaceDir, 'workspace.jsonc');
+      const fileExists = await _fsExtra().default.pathExists(workspaceJsoncPath);
+      if (!fileExists) {
+        this.logger.debug(`[MCP-DEBUG] workspace.jsonc not found at ${workspaceJsoncPath}`);
+        return null;
+      }
+      const content = await _fsExtra().default.readFile(workspaceJsoncPath, 'utf-8');
+      return (0, _commentJson().parse)(content);
+    } catch (error) {
+      this.logger.debug(`[MCP-DEBUG] Failed to read workspace.jsonc: ${error}`);
+      return null;
+    }
+  }
+
+  /**
+   * Extract owner from defaultScope in workspace.jsonc
+   * If defaultScope contains a dot, split by dot and take the first part
+   */
+  extractOwnerFromWorkspace(workspaceConfig) {
+    try {
+      const workspaceSection = workspaceConfig?.['teambit.workspace/workspace'];
+      const defaultScope = workspaceSection?.defaultScope;
+      if (!defaultScope || typeof defaultScope !== 'string') {
+        return null;
+      }
+
+      // If defaultScope contains a dot, split by dot and take the first part (owner)
+      if (defaultScope.includes('.')) {
+        const parts = defaultScope.split('.');
+        return parts[0];
+      }
+
+      // If no dot, the entire defaultScope is treated as the owner
+      return defaultScope;
+    } catch (error) {
+      this.logger.debug(`[MCP-DEBUG] Failed to extract owner from workspace config: ${error}`);
+      return null;
+    }
+  }
+  registerRemoteSearchTool(server) {
+    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`;
+    const schema = {
+      queryStr: _zod().z.string().describe(`Search query string - Don't try to search with too many keywords. It will try to find components that match all keywords, which is often too restrictive. Instead, search with a single keyword or a few broad keywords`),
+      cwd: _zod().z.string().optional().describe('Path to workspace directory'),
+      owners: _zod().z.array(_zod().z.string()).optional().describe('Filter results by specific owners or organizations. AVOID using this parameter - let the system automatically extract the owner from workspace.jsonc defaultScope for better relevance. Only use when you need to override the automatic behavior or search across different owners'),
+      skipAutoOwner: _zod().z.boolean().optional().describe('Set to true to disable automatic owner extraction from workspace.jsonc. When false or omitted, the system will try to automatically extract owner from workspace defaultScope')
+    };
+    server.tool(toolName, description, schema, async params => {
+      const http = await this.getHttp();
+
+      // Determine the owners to use for the search
+      let ownersToUse = params.owners && params.owners.length > 0 ? params.owners : undefined;
+
+      // If owners not explicitly provided and skipAutoOwner is not true, try to extract from workspace.jsonc
+      if (!ownersToUse && !params.skipAutoOwner) {
+        try {
+          // Use provided cwd parameter or fall back to current working directory
+          const workspaceDir = params.cwd || process.cwd();
+          this.logger.debug(`[MCP-DEBUG] Attempting to auto-extract owner from workspace.jsonc in: ${workspaceDir}`);
+          const workspaceConfig = await this.readWorkspaceJsonc(workspaceDir);
+          if (workspaceConfig) {
+            const extractedOwner = this.extractOwnerFromWorkspace(workspaceConfig);
+            if (extractedOwner) {
+              ownersToUse = [extractedOwner];
+              this.logger.debug(`[MCP-DEBUG] Auto-extracted owner from workspace.jsonc: ${extractedOwner}`);
+            }
+          }
+        } catch (error) {
+          this.logger.debug(`[MCP-DEBUG] Failed to auto-extract owner: ${error}`);
+          // Continue without auto-extracted owner
+        }
+      } else {
+        this.logger.debug(`[MCP-DEBUG] Using provided owners for search: ${ownersToUse ? ownersToUse.join(', ') : 'none'}`);
+      }
+      const results = await http.search(params.queryStr, ownersToUse);
+      this.logger.debug(`[MCP-DEBUG] Search results: ${JSON.stringify(results)}`);
+      if (!results?.components || results.components.length === 0) {
+        return {
+          content: [{
+            type: 'text',
+            text: 'No results found'
+          }]
+        };
+      }
+      const formattedResults = {
+        type: 'text',
+        text: results.components.join('\n')
+      };
+      return {
+        content: [formattedResults]
+      };
+    });
+  }
+  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';
+    const schema = {
+      cwd: _zod().z.string().describe('Path to workspace directory'),
+      includeTemplates: _zod().z.boolean().optional().describe('Include templates list (default: false)'),
+      includeApps: _zod().z.boolean().optional().describe('Include apps list (default: false)'),
+      includeGraph: _zod().z.boolean().optional().describe('Include dependency graph (default: false)'),
+      json: _zod().z.boolean().optional().describe('Return output in JSON format - WARNING: This produces verbose output and should be used when structured data is specifically needed (default: false)')
+    };
+    server.tool(toolName, description, schema, async params => {
+      try {
+        const includeTemplates = params.includeTemplates === true; // default: false
+        const includeApps = params.includeApps === true;
+        const includeGraph = params.includeGraph === true;
+        const useJson = params.json === true;
+        const workspaceInfo = {};
+        const flags = useJson ? {
+          json: true
+        } : {};
+        const statusExecution = await this.safeBitCommandExecution('status', [], flags, params.cwd, 'get workspace status', true);
+        workspaceInfo.status = statusExecution.result;
+        const listExecution = await this.safeBitCommandExecution('list', [], flags, params.cwd, 'get components list', true);
+        workspaceInfo.list = listExecution.result;
+
+        // Get apps list if requested
+        if (includeApps) {
+          const appsExecution = await this.safeBitCommandExecution('app', ['list'], flags, params.cwd, 'get apps list', true);
+          workspaceInfo.apps = appsExecution.result;
+        }
+
+        // Get templates list if requested
+        if (includeTemplates) {
+          const templatesExecution = await this.safeBitCommandExecution('templates', [], flags, params.cwd, 'get templates list', true);
+          workspaceInfo.templates = templatesExecution.result;
+        }
+
+        // Get dependency graph if requested
+        if (includeGraph) {
+          const graphExecution = await this.safeBitCommandExecution('graph', [], {
+            json: true
+          }, params.cwd, 'get dependency graph', true);
+          workspaceInfo.graph = graphExecution.result;
+        }
+
+        // Get workspace dependencies if requested
+        try {
+          const workspaceDependencies = await this.callBitServerIDEAPI('getWorkspaceDependencies', [], params.cwd);
+          workspaceInfo.workspaceDependencies = workspaceDependencies;
+        } catch (error) {
+          this.logger.error(`[MCP-DEBUG] Error getting workspace dependencies: ${error.message}`);
+          workspaceInfo.workspaceDependencies = {
+            error: `Failed to get workspace dependencies: ${error.message}`
+          };
+        }
+
+        // Get current lane name with scope
+        try {
+          const laneId = await this.callBitServerIDEAPI('getCurrentLaneName', [true], params.cwd);
+          workspaceInfo.laneId = laneId;
+        } catch (error) {
+          this.logger.error(`[MCP-DEBUG] Error getting current lane name: ${error.message}`);
+          workspaceInfo.laneId = {
+            error: `Failed to get current lane name: ${error.message}`
+          };
+        }
+        return this.formatAsCallToolResult(workspaceInfo);
+      } catch (error) {
+        this.logger.error(`[MCP-DEBUG] Error in bit_workspace_info tool: ${error.message}`);
+        return this.formatErrorAsCallToolResult(error, 'getting workspace info');
+      }
+    });
+  }
+  registerComponentDetailsTool(server) {
+    const toolName = 'bit_component_details';
+    const description = 'Get detailed information about a specific component including basic info and optionally its public API schema';
+    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)')
+    };
+    server.tool(toolName, description, schema, async params => {
+      try {
+        const includeSchema = params.includeSchema === true;
+        const componentName = params.componentName;
+
+        // Get component details using IDE API with includeSchema parameter
+        const ideApiResult = await this.callBitServerIDEAPI('getCompDetails', [componentName, includeSchema], params.cwd);
+        return this.formatAsCallToolResult(ideApiResult);
+      } catch (error) {
+        this.logger.error(`[MCP-DEBUG] Error in bit_component_details tool: ${error.message}`);
+        return this.formatErrorAsCallToolResult(error, 'getting component details');
+      }
+    });
+  }
+  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)')
+    };
+    server.tool(toolName, description, schema, async params => {
+      try {
+        const {
+          extendedDescription = false,
+          internal = false
+        } = params;
+        const commandsInfo = [];
+        const shouldSkipCommand = cmd => {
+          return Boolean(cmd.private && !internal || cmd.description.startsWith('DEPRECATED'));
+        };
+
+        // 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: mainCmdName,
+            description: cmd.description || ''
+          };
+          if (extendedDescription && cmd.extendedDescription) {
+            commandInfo.extendedDescription = cmd.extendedDescription;
+          }
+          if (groupKey) commandInfo.group = this.cli.groups[groupKey] || groupKey;
+
+          // 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 || ''
+            }));
+          }
+          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 || '',
+            group: cmd.group ? this.cli.groups[cmd.group] || cmd.group : ''
+          };
+
+          // Add arguments information
+          const argsData = (0, _cli().getArgsData)(cmd);
+          if (argsData.length > 0) {
+            info.arguments = argsData.map(arg => ({
+              name: arg.nameRaw,
+              description: arg.description || '',
+              required: arg.required,
+              isArray: arg.isArray
+            }));
+          }
+
+          // 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) {
+            info.subcommands = cmd.commands.map(subCmd => ({
+              name: (0, _cli().getCommandName)(subCmd),
+              description: subCmd.description || ''
+            }));
+          }
+          return info;
+        };
+
+        // 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) {
+                commandInfo = buildDetailedCommandInfo(subCmd, requestedCommand);
+              }
+            }
+          } else {
+            // Looking for a main command
+            if (mainCmdName === requestedCommand) {
+              commandInfo = buildDetailedCommandInfo(cmd);
+            }
+          }
+        });
+        if (!commandInfo) {
+          const commandFullName = requestedSubcommand ? `${requestedCommand} ${requestedSubcommand}` : requestedCommand;
+          return this.formatAsCallToolResult(`Command not found: ${commandFullName}`);
+        }
+        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_command_help tool: ${error.message}`);
+        return this.formatErrorAsCallToolResult(error, 'getting command help');
+      }
+    });
+  }
+  registerQueryTool(server) {
+    const toolName = 'bit_query';
+    const description = 'Execute read-only Bit commands that safely inspect workspace and component state without making modifications. Only whitelisted query commands are allowed for safety.';
+    const schema = {
+      cwd: _zod().z.string().describe('Path to workspace directory'),
+      command: _zod().z.string().describe('The Bit command to execute (e.g., "status", "show", "list")'),
+      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 {
+          command,
+          args = [],
+          flags = {},
+          cwd
+        } = params;
+
+        // Check if command is in the read-only whitelist
+        // Support both single commands and subcommands (e.g., "lane show")
+        const fullCommand = args.length > 0 ? `${command} ${args[0]}` : command;
+        const isAllowed = this.readOnlyCommands.has(command) || this.readOnlyCommands.has(fullCommand);
+        if (!isAllowed) {
+          const allowedCommands = Array.from(this.readOnlyCommands).sort().join(', ');
+          return this.formatAsCallToolResult(`Error: Command "${command}" is not allowed in query mode. Allowed read-only commands: ${allowedCommands}`);
+        }
+
+        // Build command arguments
+        const commandArgs = [command, ...args];
+
+        // Add flags to arguments
+        Object.entries(flags).forEach(([key, value]) => {
+          if (typeof value === 'boolean' && value) {
+            commandArgs.push(`--${key}`);
+          } else if (typeof value === 'string' && value) {
+            commandArgs.push(`--${key}`);
+            commandArgs.push(value);
+          }
+        });
+        this.logger.debug(`[MCP-DEBUG] Executing query command: ${command} with args: ${JSON.stringify(commandArgs)}`);
+        const execution = await this.safeBitCommandExecution(command, args, flags, cwd, `execute query command ${command}`);
+        return this.formatAsCallToolResult(execution.result);
+      } catch (error) {
+        this.logger.error(`[MCP-DEBUG] Error in bit_query tool: ${error.message}`);
+        return this.formatErrorAsCallToolResult(error, 'executing query command');
+      }
+    });
+  }
+  registerExecuteTool(server) {
+    const toolName = 'bit_execute';
+    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., "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 {
+        let {
+          command,
+          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 execution = await this.safeBitCommandExecution(command, args, flags, cwd, `execute command ${command}`);
+        return this.formatAsCallToolResult(execution.result);
+      } catch (error) {
+        this.logger.error(`[MCP-DEBUG] Error in bit_execute tool: ${error.message}`);
+        return this.formatErrorAsCallToolResult(error, 'executing command');
+      }
+    });
+  }
+  processSubCommands(server, parentCmd, options) {
+    const parentCmdName = (0, _cli().getCommandName)(parentCmd);
+    parentCmd.commands?.forEach(subCmd => {
+      const subCmdName = (0, _cli().getCommandName)(subCmd);
+      const fullCmdName = `${parentCmdName} ${subCmdName}`;
+      if (this.shouldIncludeCommand(fullCmdName, options)) {
+        this.registerToolForCommand(server, subCmd, parentCmd);
+      }
+    });
+  }
+  async runBit(args, cwd) {
+    this.logger.debug(`[MCP-DEBUG] Running: ${this.bitBin} ${args.join(' ')} in ${cwd}`);
+    try {
+      const result = _child_process().default.spawnSync(this.bitBin, args, {
+        cwd,
+        env: _objectSpread(_objectSpread({}, process.env), {}, {
+          BIT_DISABLE_SPINNER: '1'
+        }),
+        encoding: 'utf8'
+      });
+      if (result.error) {
+        throw result.error;
+      }
+      if (result.status !== 0) {
+        const errorMessage = result.stderr || `Command failed with status ${result.status}`;
+        throw new Error(errorMessage);
+      }
+      this.logger.debug(`[MCP-DEBUG] result. stdout: ${result.stdout}`);
+      return {
+        content: [{
+          type: 'text',
+          text: result.stdout
+        }]
+      };
+    } catch (error) {
+      this.logger.error(`[MCP-DEBUG] Error executing ${this.bitBin} ${args.join(' ')}`, error);
+      return {
+        content: [{
+          type: 'text',
+          text: error.message
+        }]
+      };
+    }
+  }
+
+  /**
+   * Helper method to execute a bit-server API call with standardized error handling
+   */
+  async executeBitServerCommand(command, args = [], flags = {}, cwd, operationName) {
+    try {
+      const result = await this.callBitServerAPI(command, args, flags, cwd);
+      this.logger.debug(`[MCP-DEBUG] Successfully executed ${operationName} via bit-server`);
+      return result;
+    } catch (error) {
+      this.logger.warn(`[MCP-DEBUG] Failed to execute ${operationName} via bit-server: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Helper method to format any result as CallToolResult
+   */
+  formatAsCallToolResult(result) {
+    if (typeof result === 'string') {
+      return {
+        content: [{
+          type: 'text',
+          text: result
+        }]
+      };
+    } else if (typeof result === 'object') {
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify(result, null, 2)
+        }]
+      };
+    } else {
+      return {
+        content: [{
+          type: 'text',
+          text: String(result)
+        }]
+      };
+    }
+  }
+
+  /**
+   * Helper method to format error as CallToolResult
+   */
+  formatErrorAsCallToolResult(error, operation) {
+    return {
+      content: [{
+        type: 'text',
+        text: `Error ${operation}: ${error.message}`
+      }]
+    };
+  }
+
+  /**
+   * Helper method to safely execute a bit command with error handling
+   */
+  async safeBitCommandExecution(command, args = [], flags = {}, cwd, operationName, includeErrorInResult = false) {
+    try {
+      let result = await this.executeBitServerCommand(command, args, flags, cwd, operationName);
+
+      // Unwrap the result from data wrapper if it exists and we have a successful result
+      if (result && typeof result === 'object' && 'data' in result && result.data !== undefined) {
+        result = result.data;
+      }
+
+      // Clean up output by removing ANSI color codes when not using JSON format
+      const useJson = flags && flags.json === true;
+      if (!useJson && typeof result === 'string') {
+        result = (0, _stripAnsi().default)(result);
+      }
+      return {
+        success: true,
+        result
+      };
+    } catch (error) {
+      if (includeErrorInResult) {
+        return {
+          success: false,
+          result: {
+            error: `Failed to ${operationName}: ${error.message}`
+          },
+          error: error.message
+        };
+      } else {
+        throw error;
+      }
+    }
+  }
+  validateBitBin(bitBin) {
+    const trimmed = bitBin?.trim();
+    // Check for shell metacharacters and spaces. Protect against command injection.
+    if (!trimmed || /[;&|`$(){}[\]<>'"\\]/.test(trimmed) || /\s/.test(trimmed)) throw new Error('Invalid bitBin');
+    return trimmed;
+  }
+
+  // Setup command business logic methods
+  getEditorDisplayName(editor) {
+    return _setupUtils().McpSetupUtils.getEditorDisplayName(editor);
+  }
+
+  /**
+   * Get the path to the editor config file based on editor type and scope
+   */
+  getEditorConfigPath(editor, isGlobal, workspaceDir) {
+    const editorLower = editor.toLowerCase();
+    if (editorLower === 'vscode') {
+      // For VS Code, return appropriate config path based on global vs workspace scope
+      return isGlobal ? _setupUtils().McpSetupUtils.getVSCodeSettingsPath(isGlobal, workspaceDir) : _setupUtils().McpSetupUtils.getVSCodeMcpConfigPath(workspaceDir);
+    } else if (editorLower === 'cursor') {
+      return _setupUtils().McpSetupUtils.getCursorSettingsPath(isGlobal, workspaceDir);
+    } else if (editorLower === 'windsurf') {
+      return _setupUtils().McpSetupUtils.getWindsurfSettingsPath(isGlobal, workspaceDir);
+    } else if (editorLower === 'roo') {
+      return _setupUtils().McpSetupUtils.getRooCodeSettingsPath(isGlobal, workspaceDir);
+    } else if (editorLower === 'cline') {
+      return _setupUtils().McpSetupUtils.getClinePromptsPath(isGlobal, workspaceDir);
+    } else if (editorLower === 'claude-code') {
+      return _setupUtils().McpSetupUtils.getClaudeCodeSettingsPath(isGlobal, workspaceDir);
+    }
+    throw new Error(`Editor "${editor}" is not supported yet.`);
+  }
+  async setupEditor(editor, options, workspaceDir) {
+    const supportedEditors = ['vscode', 'cursor', 'windsurf', 'roo', 'cline', 'claude-code'];
+    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);
+    } else if (editorLower === 'roo') {
+      await _setupUtils().McpSetupUtils.setupRooCode(setupOptions);
+    } else if (editorLower === 'cline') {
+      // Cline doesn't need MCP server setup, only rules files
+      // This is a no-op but we include it for consistency
+      // Users should use the 'rules' command to set up Cline instructions
+    } else if (editorLower === 'claude-code') {
+      await _setupUtils().McpSetupUtils.setupClaudeCode(setupOptions);
+    }
+  }
+  async writeRulesFile(editor, options, workspaceDir) {
+    const supportedEditors = ['vscode', 'cursor', 'roo', 'cline', 'claude-code'];
+    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);
+    } else if (editorLower === 'roo') {
+      await _setupUtils().McpSetupUtils.writeRooCodeRules(rulesOptions);
+    } else if (editorLower === 'cline') {
+      await _setupUtils().McpSetupUtils.writeClineRules(rulesOptions);
+    } else if (editorLower === 'claude-code') {
+      await _setupUtils().McpSetupUtils.writeClaudeCodeRules(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), new (_rulesCmd().McpRulesCmd)(mcpServer)];
+    cli.register(mcpServerCmd);
+    return mcpServer;
+  }
+}
+exports.CliMcpServerMain = CliMcpServerMain;
+_defineProperty(CliMcpServerMain, "slots", []);
+_defineProperty(CliMcpServerMain, "dependencies", [_cli().CLIAspect, _logger().LoggerAspect]);
+_defineProperty(CliMcpServerMain, "runtime", _cli().MainRuntime);
+_cliMcpServer().CliMcpServerAspect.addRuntime(CliMcpServerMain);
+var _default = exports.default = CliMcpServerMain;
+
+//# sourceMappingURL=cli-mcp-server.main.runtime.js.map