@teambit/cli-mcp-server 0.0.0-00149e000ea14bbdcb0391c0d576b4a2b40f8cde

package/dist/cli-mcp-server.spec.js

@@ -0,0 +1,740 @@
+"use strict";
+
+function _chai() {
+  const data = require("chai");
+  _chai = function () {
+    return data;
+  };
+  return data;
+}
+function _index() {
+  const data = require("@modelcontextprotocol/sdk/client/index.js");
+  _index = function () {
+    return data;
+  };
+  return data;
+}
+function _stdio() {
+  const data = require("@modelcontextprotocol/sdk/client/stdio.js");
+  _stdio = function () {
+    return data;
+  };
+  return data;
+}
+function _workspaceTesting() {
+  const data = require("@teambit/workspace.testing.mock-workspace");
+  _workspaceTesting = function () {
+    return data;
+  };
+  return data;
+}
+function _componentTesting() {
+  const data = require("@teambit/component.testing.mock-components");
+  _componentTesting = function () {
+    return data;
+  };
+  return data;
+}
+function _harmonyTesting() {
+  const data = require("@teambit/harmony.testing.load-aspect");
+  _harmonyTesting = function () {
+    return data;
+  };
+  return data;
+}
+function _fsExtra() {
+  const data = _interopRequireDefault(require("fs-extra"));
+  _fsExtra = 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 _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/* eslint-disable import/extensions */
+/* eslint-disable import/no-unresolved */
+
+/** Parse JSON from an MCP tool response, providing a clear error when the server returned a non-JSON error string. */
+function parseToolJson(result) {
+  const text = result.content[0].text;
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new Error(`Expected JSON response from MCP tool but got: ${text.slice(0, 200)}`);
+  }
+}
+describe.skip('CliMcpServer Integration Tests', function () {
+  this.timeout(30000); // Increased timeout for MCP server operations
+
+  let workspaceData;
+  let mcpClient;
+  let workspacePath;
+  before(async () => {
+    // Set up mock workspace with components
+    workspaceData = (0, _workspaceTesting().mockWorkspace)();
+    workspacePath = workspaceData.workspacePath;
+    await (0, _componentTesting().mockComponents)(workspacePath);
+  });
+  after(async () => {
+    await (0, _workspaceTesting().destroyWorkspace)(workspaceData);
+  });
+  beforeEach(async () => {
+    // Create MCP client and connect directly to the MCP server command
+    const transport = new (_stdio().StdioClientTransport)({
+      command: 'bit',
+      args: ['mcp-server', 'start'],
+      cwd: workspacePath
+    });
+    mcpClient = new (_index().Client)({
+      name: 'test-client',
+      version: '1.0.0'
+    }, {
+      capabilities: {}
+    });
+    await mcpClient.connect(transport);
+  });
+  afterEach(async () => {
+    // Clean up MCP client
+    if (mcpClient) {
+      await mcpClient.close();
+    }
+  });
+  describe('MCP Server Protocol', () => {
+    it('should list available tools', async () => {
+      const response = await mcpClient.listTools();
+      (0, _chai().expect)(response.tools).to.be.an('array');
+      (0, _chai().expect)(response.tools.length).to.be.greaterThan(0);
+
+      // Check for essential MCP tools
+      const toolNames = response.tools.map(tool => tool.name);
+      (0, _chai().expect)(toolNames).to.include('bit_workspace_info');
+      (0, _chai().expect)(toolNames).to.include('bit_component_details');
+      (0, _chai().expect)(toolNames).to.include('bit_commands_list');
+      (0, _chai().expect)(toolNames).to.include('bit_query');
+      (0, _chai().expect)(toolNames).to.include('bit_execute');
+    });
+  });
+  describe('Consumer Project Mode', () => {
+    let consumerProjectClient;
+    beforeEach(async () => {
+      // Create MCP client for consumer project mode
+      const transport = new (_stdio().StdioClientTransport)({
+        command: 'bit',
+        args: ['mcp-server', 'start', '--consumer-project'],
+        cwd: workspacePath
+      });
+      consumerProjectClient = new (_index().Client)({
+        name: 'test-consumer-client',
+        version: '1.0.0'
+      }, {
+        capabilities: {}
+      });
+      await consumerProjectClient.connect(transport);
+    });
+    afterEach(async () => {
+      if (consumerProjectClient) {
+        await consumerProjectClient.close();
+      }
+    });
+    it('should only enable bit_remote_search and bit_remote_component_details tools', async () => {
+      const response = await consumerProjectClient.listTools();
+      (0, _chai().expect)(response.tools).to.be.an('array');
+      const toolNames = response.tools.map(tool => tool.name);
+
+      // Should include only these two tools
+      (0, _chai().expect)(toolNames).to.include('bit_remote_search');
+      (0, _chai().expect)(toolNames).to.include('bit_remote_component_details');
+
+      // Should NOT include these tools that are available in regular mode
+      (0, _chai().expect)(toolNames).to.not.include('bit_workspace_info');
+      (0, _chai().expect)(toolNames).to.not.include('bit_component_details');
+      (0, _chai().expect)(toolNames).to.not.include('bit_commands_list');
+      (0, _chai().expect)(toolNames).to.not.include('bit_command_help');
+      (0, _chai().expect)(toolNames).to.not.include('bit_query');
+      (0, _chai().expect)(toolNames).to.not.include('bit_execute');
+
+      // Should NOT include the old separate tools
+      (0, _chai().expect)(toolNames).to.not.include('bit_show');
+      (0, _chai().expect)(toolNames).to.not.include('bit_schema');
+
+      // Should have exactly 2 tools
+      (0, _chai().expect)(toolNames).to.have.lengthOf(2);
+    });
+    it('should work with bit_remote_search tool', async () => {
+      const result = await consumerProjectClient.callTool({
+        name: 'bit_remote_search',
+        arguments: {
+          queries: ['button'],
+          cwd: workspacePath
+        }
+      });
+      (0, _chai().expect)(result).to.have.property('content');
+      (0, _chai().expect)(result.content).to.be.an('array');
+      (0, _chai().expect)(result.content[0]).to.have.property('type', 'text');
+    });
+  });
+  describe('bit_workspace_info tool', () => {
+    it('should get workspace information', async () => {
+      const result = await mcpClient.callTool({
+        name: 'bit_workspace_info',
+        arguments: {
+          cwd: workspacePath,
+          includeStatus: true,
+          includeList: true
+        }
+      });
+      (0, _chai().expect)(result).to.have.property('content');
+      (0, _chai().expect)(result.content).to.be.an('array');
+      (0, _chai().expect)(result.content[0]).to.have.property('type', 'text');
+      const content = parseToolJson(result);
+      (0, _chai().expect)(content).to.have.property('status');
+      (0, _chai().expect)(content).to.have.property('list');
+    });
+    it('should handle workspace info without optional parameters', async () => {
+      const result = await mcpClient.callTool({
+        name: 'bit_workspace_info',
+        arguments: {
+          cwd: workspacePath
+        }
+      });
+      (0, _chai().expect)(result).to.have.property('content');
+      (0, _chai().expect)(result.content).to.be.an('array');
+      (0, _chai().expect)(result.content[0]).to.have.property('type', 'text');
+      const content = parseToolJson(result);
+      (0, _chai().expect)(content).to.have.property('status');
+    });
+  });
+  describe('bit_component_details tool', () => {
+    it('should get component details for multiple components', async () => {
+      const componentIds = ['comp1', 'comp2'];
+      const result = await mcpClient.callTool({
+        name: 'bit_component_details',
+        arguments: {
+          cwd: workspacePath,
+          componentIds,
+          includeSchema: false
+        }
+      });
+      (0, _chai().expect)(result).to.have.property('content');
+      (0, _chai().expect)(result.content).to.be.an('array');
+      (0, _chai().expect)(result.content[0]).to.have.property('type', 'text');
+      const content = parseToolJson(result);
+      (0, _chai().expect)(content).to.have.property('summary');
+      (0, _chai().expect)(content).to.have.property('components');
+      (0, _chai().expect)(content.summary).to.have.property('requested', 2);
+      (0, _chai().expect)(content.summary).to.have.property('successful');
+      (0, _chai().expect)(content.components).to.be.an('object');
+    });
+    it('should get component details with schema', async function () {
+      this.retries(2); // schema extraction is heavier and may hit transient socket hang-ups in CI
+      const componentIds = ['comp1'];
+      const result = await mcpClient.callTool({
+        name: 'bit_component_details',
+        arguments: {
+          cwd: workspacePath,
+          componentIds,
+          includeSchema: true
+        }
+      });
+      (0, _chai().expect)(result).to.have.property('content');
+      (0, _chai().expect)(result.content).to.be.an('array');
+      (0, _chai().expect)(result.content[0]).to.have.property('type', 'text');
+      const content = parseToolJson(result);
+      (0, _chai().expect)(content).to.have.property('summary');
+      (0, _chai().expect)(content).to.have.property('components');
+      (0, _chai().expect)(content.summary.includeSchema).to.be.true;
+      if (content.summary.successful > 0) {
+        const firstComponent = Object.values(content.components)[0];
+        (0, _chai().expect)(firstComponent).to.have.property('publicAPI');
+      }
+    });
+    it('should handle non-existent component gracefully', async () => {
+      const result = await mcpClient.callTool({
+        name: 'bit_component_details',
+        arguments: {
+          cwd: workspacePath,
+          componentIds: ['non-existent/component']
+        }
+      });
+      (0, _chai().expect)(result).to.have.property('content');
+      (0, _chai().expect)(result.content).to.be.an('array');
+      (0, _chai().expect)(result.content[0]).to.have.property('type', 'text');
+      const responseText = result.content[0].text;
+
+      // Try to parse as JSON first
+      try {
+        const content = JSON.parse(responseText);
+        // Should have summary with failed components
+        (0, _chai().expect)(content).to.have.property('summary');
+        (0, _chai().expect)(content.summary).to.have.property('failed');
+        (0, _chai().expect)(content.summary.failed).to.be.greaterThan(0);
+      } catch {
+        // If not JSON, should be an error message string
+        (0, _chai().expect)(responseText).to.be.a('string');
+        (0, _chai().expect)(responseText).to.include('Failed to get details for any components');
+      }
+    });
+    it('should reject requests with more than 5 components', async () => {
+      const tooManyComponents = ['comp1', 'comp2', 'comp3', 'comp4', 'comp5', 'comp6'];
+      const result = await mcpClient.callTool({
+        name: 'bit_component_details',
+        arguments: {
+          cwd: workspacePath,
+          componentIds: tooManyComponents
+        }
+      });
+      (0, _chai().expect)(result).to.have.property('content');
+      (0, _chai().expect)(result.content).to.be.an('array');
+      (0, _chai().expect)(result.content[0]).to.have.property('type', 'text');
+      const content = result.content[0].text;
+      (0, _chai().expect)(content).to.include('Too many components requested');
+      (0, _chai().expect)(content).to.include('Maximum allowed is 5');
+    });
+    it('should require componentIds parameter', async () => {
+      const result = await mcpClient.callTool({
+        name: 'bit_component_details',
+        arguments: {
+          cwd: workspacePath
+          // Missing componentIds parameter
+        }
+      });
+
+      // With new SDK (1.22+), validation errors are returned in result with isError flag
+      (0, _chai().expect)(result).to.have.property('isError', true);
+      (0, _chai().expect)(result.content).to.be.an('array');
+      (0, _chai().expect)(result.content[0]).to.have.property('type', 'text');
+      const errorText = result.content[0].text;
+      (0, _chai().expect)(errorText).to.include('componentIds');
+      (0, _chai().expect)(errorText).to.include('Required');
+    });
+  });
+  describe('bit_commands_list tool', () => {
+    it('should get basic commands list', async () => {
+      const result = await mcpClient.callTool({
+        name: 'bit_commands_list',
+        arguments: {}
+      });
+      (0, _chai().expect)(result).to.have.property('content');
+      (0, _chai().expect)(result.content).to.be.an('array');
+      (0, _chai().expect)(result.content[0]).to.have.property('type', 'text');
+      const content = parseToolJson(result);
+      (0, _chai().expect)(content).to.have.property('commands');
+      (0, _chai().expect)(content.commands).to.be.an('array');
+      (0, _chai().expect)(content.commands.length).to.be.greaterThan(0);
+
+      // Check command structure
+      const firstCommand = content.commands[0];
+      (0, _chai().expect)(firstCommand).to.have.property('name');
+      (0, _chai().expect)(firstCommand).to.have.property('description');
+    });
+    it('should get commands info with extended description', async () => {
+      const result = await mcpClient.callTool({
+        name: 'bit_commands_list',
+        arguments: {
+          extendedDescription: true,
+          internal: false
+        }
+      });
+      (0, _chai().expect)(result).to.have.property('content');
+      (0, _chai().expect)(result.content).to.be.an('array');
+      (0, _chai().expect)(result.content[0]).to.have.property('type', 'text');
+      const content = parseToolJson(result);
+      (0, _chai().expect)(content).to.have.property('commands');
+      (0, _chai().expect)(content.commands).to.be.an('array');
+      (0, _chai().expect)(content.commands.length).to.be.greaterThan(0);
+    });
+  });
+  describe('bit_command_help tool', () => {
+    it('should get help for a main command', async () => {
+      const result = await mcpClient.callTool({
+        name: 'bit_command_help',
+        arguments: {
+          command: 'status'
+        }
+      });
+      (0, _chai().expect)(result).to.have.property('content');
+      (0, _chai().expect)(result.content).to.be.an('array');
+      (0, _chai().expect)(result.content[0]).to.have.property('type', 'text');
+      const content = parseToolJson(result);
+      (0, _chai().expect)(content).to.have.property('name', 'status');
+      (0, _chai().expect)(content).to.have.property('description');
+      (0, _chai().expect)(content).to.have.property('options');
+    });
+    it('should get help for lane switch subcommand (private command)', async () => {
+      const result = await mcpClient.callTool({
+        name: 'bit_command_help',
+        arguments: {
+          command: 'lane',
+          subcommand: 'switch'
+        }
+      });
+      (0, _chai().expect)(result).to.have.property('content');
+      (0, _chai().expect)(result.content).to.be.an('array');
+      (0, _chai().expect)(result.content[0]).to.have.property('type', 'text');
+      const content = parseToolJson(result);
+      (0, _chai().expect)(content).to.have.property('name', 'lane switch');
+      (0, _chai().expect)(content).to.have.property('description');
+      (0, _chai().expect)(content.description).to.include('switch to the specified lane');
+      (0, _chai().expect)(content).to.have.property('arguments');
+      (0, _chai().expect)(content.arguments).to.be.an('array');
+      (0, _chai().expect)(content.arguments[0]).to.have.property('name', 'lane');
+      (0, _chai().expect)(content.arguments[0]).to.have.property('description');
+    });
+    it('should get help for a subcommand that exists', async () => {
+      const result = await mcpClient.callTool({
+        name: 'bit_command_help',
+        arguments: {
+          command: 'lane',
+          subcommand: 'show'
+        }
+      });
+      (0, _chai().expect)(result).to.have.property('content');
+      (0, _chai().expect)(result.content).to.be.an('array');
+      (0, _chai().expect)(result.content[0]).to.have.property('type', 'text');
+      const content = parseToolJson(result);
+      (0, _chai().expect)(content).to.have.property('name', 'lane show');
+      (0, _chai().expect)(content).to.have.property('description');
+    });
+    it('should return error for non-existent command', async () => {
+      const result = await mcpClient.callTool({
+        name: 'bit_command_help',
+        arguments: {
+          command: 'nonexistent'
+        }
+      });
+      (0, _chai().expect)(result).to.have.property('content');
+      (0, _chai().expect)(result.content).to.be.an('array');
+      (0, _chai().expect)(result.content[0]).to.have.property('type', 'text');
+      const content = result.content[0].text;
+      (0, _chai().expect)(content).to.include('Command not found: nonexistent');
+    });
+    it('should return error for non-existent subcommand', async () => {
+      const result = await mcpClient.callTool({
+        name: 'bit_command_help',
+        arguments: {
+          command: 'lane',
+          subcommand: 'nonexistent'
+        }
+      });
+      (0, _chai().expect)(result).to.have.property('content');
+      (0, _chai().expect)(result.content).to.be.an('array');
+      (0, _chai().expect)(result.content[0]).to.have.property('type', 'text');
+      const content = result.content[0].text;
+      (0, _chai().expect)(content).to.include('Command not found: lane nonexistent');
+    });
+  });
+  describe('bit_query tool', () => {
+    it('should execute read-only commands', async () => {
+      const result = await mcpClient.callTool({
+        name: 'bit_query',
+        arguments: {
+          cwd: workspacePath,
+          command: 'status'
+        }
+      });
+      (0, _chai().expect)(result).to.have.property('content');
+      (0, _chai().expect)(result.content).to.be.an('array');
+      (0, _chai().expect)(result.content[0]).to.have.property('type', 'text');
+
+      // Should return command output
+      const content = result.content[0].text;
+      (0, _chai().expect)(content).to.be.a('string');
+    });
+    it('should handle commands with arguments and flags', async () => {
+      const result = await mcpClient.callTool({
+        name: 'bit_query',
+        arguments: {
+          cwd: workspacePath,
+          command: 'list',
+          args: [],
+          flags: {
+            json: true
+          }
+        }
+      });
+      (0, _chai().expect)(result).to.have.property('content');
+      (0, _chai().expect)(result.content).to.be.an('array');
+      (0, _chai().expect)(result.content[0]).to.have.property('type', 'text');
+      const content = result.content[0].text;
+      (0, _chai().expect)(content).to.be.a('string');
+    });
+  });
+  describe('Error Handling', () => {
+    it('should handle invalid tool calls gracefully', async () => {
+      try {
+        await mcpClient.callTool({
+          name: 'non_existent_tool',
+          arguments: {}
+        });
+        _chai().expect.fail('Should have thrown an error for non-existent tool');
+      } catch (error) {
+        (0, _chai().expect)(error).to.exist;
+      }
+    });
+    it('should handle invalid workspace directory', async () => {
+      const result = await mcpClient.callTool({
+        name: 'bit_workspace_info',
+        arguments: {
+          cwd: '/non/existent/path'
+        }
+      });
+      (0, _chai().expect)(result).to.have.property('content');
+      (0, _chai().expect)(result.content).to.be.an('array');
+      (0, _chai().expect)(result.content[0]).to.have.property('type', 'text');
+
+      // Should return error information
+      const content = result.content[0].text;
+      (0, _chai().expect)(content).to.be.a('string');
+    });
+  });
+});
+describe.skip('CliMcpServer Direct Aspect Tests', function () {
+  this.timeout(30000);
+  let workspaceData;
+  let mcpServer;
+  let workspacePath;
+  before(async () => {
+    // Set up mock workspace with components
+    workspaceData = (0, _workspaceTesting().mockWorkspace)();
+    workspacePath = workspaceData.workspacePath;
+    await (0, _componentTesting().mockComponents)(workspacePath);
+
+    // Load the aspect directly
+    mcpServer = await (0, _harmonyTesting().loadAspect)(_cliMcpServer().CliMcpServerAspect, workspacePath);
+  });
+  after(async () => {
+    await (0, _workspaceTesting().destroyWorkspace)(workspaceData);
+  });
+  describe('Setup Editor Methods', () => {
+    let setupWorkspaceData;
+    let setupWorkspacePath;
+    let setupMcpServer;
+    beforeEach(async () => {
+      // Create a separate mock workspace for setup testing
+      setupWorkspaceData = (0, _workspaceTesting().mockWorkspace)();
+      setupWorkspacePath = setupWorkspaceData.workspacePath;
+      await (0, _componentTesting().mockComponents)(setupWorkspacePath);
+
+      // Load the aspect for this workspace
+      setupMcpServer = await (0, _harmonyTesting().loadAspect)(_cliMcpServer().CliMcpServerAspect, setupWorkspacePath);
+    });
+    afterEach(async () => {
+      // Clean up the setup workspace
+      if (setupWorkspaceData) {
+        await (0, _workspaceTesting().destroyWorkspace)(setupWorkspaceData);
+      }
+    });
+    it('should handle unsupported editor gracefully', async () => {
+      try {
+        await mcpServer.setupEditor('unsupported-editor', {
+          isGlobal: false
+        });
+        _chai().expect.fail('Should have thrown an error for unsupported editor');
+      } catch (error) {
+        (0, _chai().expect)(error).to.exist;
+        (0, _chai().expect)(error.message).to.include('Editor "unsupported-editor" is not supported yet');
+        (0, _chai().expect)(error.message).to.include('Currently supported: vscode, cursor, windsurf, roo, cline');
+      }
+    });
+    it('should setup VS Code integration directly', async () => {
+      await setupMcpServer.setupEditor('vscode', {
+        isGlobal: false
+      }, setupWorkspacePath);
+
+      // Verify that the mcp.json file was created in the workspace directory
+      const vscodeMcpPath = _path().default.join(setupWorkspacePath, '.vscode', 'mcp.json');
+      const mcpExists = await _fsExtra().default.pathExists(vscodeMcpPath);
+      (0, _chai().expect)(mcpExists).to.be.true;
+
+      // Verify the content of the mcp.json file
+      const mcpConfig = await _fsExtra().default.readJson(vscodeMcpPath);
+      (0, _chai().expect)(mcpConfig).to.have.property('servers');
+      (0, _chai().expect)(mcpConfig.servers).to.have.property('bit-cli');
+      (0, _chai().expect)(mcpConfig.servers['bit-cli']).to.deep.equal({
+        type: 'stdio',
+        command: 'bit',
+        args: ['mcp-server', 'start']
+      });
+    });
+    it('should setup VS Code integration with consumer project options', async () => {
+      await setupMcpServer.setupEditor('vscode', {
+        consumerProject: true,
+        includeAdditional: 'status,list',
+        isGlobal: false
+      }, setupWorkspacePath);
+      const vscodeMcpPath = _path().default.join(setupWorkspacePath, '.vscode', 'mcp.json');
+      const mcpConfig = await _fsExtra().default.readJson(vscodeMcpPath);
+      (0, _chai().expect)(mcpConfig.servers['bit-cli'].args).to.include('--consumer-project');
+      (0, _chai().expect)(mcpConfig.servers['bit-cli'].args).to.include('--include-additional');
+      (0, _chai().expect)(mcpConfig.servers['bit-cli'].args).to.include('status,list');
+    });
+    it('should setup Cursor integration directly', async () => {
+      await setupMcpServer.setupEditor('cursor', {
+        isGlobal: false
+      }, setupWorkspacePath);
+
+      // Verify that the mcp.json file was created in the workspace directory
+      const cursorConfigPath = _path().default.join(setupWorkspacePath, '.cursor', 'mcp.json');
+      const configExists = await _fsExtra().default.pathExists(cursorConfigPath);
+      (0, _chai().expect)(configExists).to.be.true;
+
+      // Verify the content of the config file
+      const config = await _fsExtra().default.readJson(cursorConfigPath);
+      (0, _chai().expect)(config).to.have.property('mcpServers');
+      (0, _chai().expect)(config.mcpServers).to.have.property('bit');
+      (0, _chai().expect)(config.mcpServers.bit).to.deep.equal({
+        type: 'stdio',
+        command: 'bit',
+        args: ['mcp-server', 'start']
+      });
+    });
+    it('should setup Windsurf integration directly', async () => {
+      await setupMcpServer.setupEditor('windsurf', {
+        isGlobal: false
+      }, setupWorkspacePath);
+
+      // Verify that the mcp.json file was created in the workspace directory
+      const windsurfConfigPath = _path().default.join(setupWorkspacePath, '.windsurf', 'mcp.json');
+      const configExists = await _fsExtra().default.pathExists(windsurfConfigPath);
+      (0, _chai().expect)(configExists).to.be.true;
+
+      // Verify the content of the config file
+      const config = await _fsExtra().default.readJson(windsurfConfigPath);
+      (0, _chai().expect)(config).to.have.property('mcpServers');
+      (0, _chai().expect)(config.mcpServers).to.have.property('bit');
+      (0, _chai().expect)(config.mcpServers.bit).to.deep.equal({
+        type: 'stdio',
+        command: 'bit',
+        args: ['mcp-server', 'start']
+      });
+    });
+    it('should setup Roo Code integration directly', async () => {
+      await setupMcpServer.setupEditor('roo', {
+        isGlobal: false
+      }, setupWorkspacePath);
+
+      // Verify that the mcp.json file was created in the workspace directory
+      const rooConfigPath = _path().default.join(setupWorkspacePath, '.roo', 'mcp.json');
+      const configExists = await _fsExtra().default.pathExists(rooConfigPath);
+      (0, _chai().expect)(configExists).to.be.true;
+
+      // Verify the content of the config file
+      const config = await _fsExtra().default.readJson(rooConfigPath);
+      (0, _chai().expect)(config).to.have.property('mcpServers');
+      (0, _chai().expect)(config.mcpServers).to.have.property('bit');
+      (0, _chai().expect)(config.mcpServers.bit).to.deep.equal({
+        type: 'stdio',
+        command: 'bit',
+        args: ['mcp-server', 'start']
+      });
+    });
+    it('should throw error when trying to setup Roo Code globally', async () => {
+      try {
+        await setupMcpServer.setupEditor('roo', {
+          isGlobal: true
+        }, setupWorkspacePath);
+        _chai().expect.fail('Should have thrown an error for global Roo Code setup');
+      } catch (error) {
+        (0, _chai().expect)(error).to.exist;
+        (0, _chai().expect)(error.message).to.include('Roo Code global configuration is not supported');
+        (0, _chai().expect)(error.message).to.include('VS Code internal storage that cannot be accessed');
+      }
+    });
+    it('should merge with existing VS Code mcp.json config', async () => {
+      // First, create existing MCP config
+      const vscodeMcpPath = _path().default.join(setupWorkspacePath, '.vscode', 'mcp.json');
+      await _fsExtra().default.ensureDir(_path().default.dirname(vscodeMcpPath));
+      await _fsExtra().default.writeJson(vscodeMcpPath, {
+        servers: {
+          'existing-server': {
+            type: 'stdio',
+            command: 'some-other-command',
+            args: ['start']
+          }
+        }
+      });
+
+      // Run setup
+      await setupMcpServer.setupEditor('vscode', {
+        isGlobal: false
+      }, setupWorkspacePath);
+
+      // Verify that existing MCP config is preserved and Bit config is added
+      const mcpConfig = await _fsExtra().default.readJson(vscodeMcpPath);
+      (0, _chai().expect)(mcpConfig.servers).to.have.property('existing-server');
+      (0, _chai().expect)(mcpConfig.servers['existing-server']).to.deep.equal({
+        type: 'stdio',
+        command: 'some-other-command',
+        args: ['start']
+      });
+      (0, _chai().expect)(mcpConfig.servers).to.have.property('bit-cli');
+      (0, _chai().expect)(mcpConfig.servers['bit-cli']).to.deep.equal({
+        type: 'stdio',
+        command: 'bit',
+        args: ['mcp-server', 'start']
+      });
+    });
+  });
+  describe('Rules Methods', () => {
+    it('should get rules content without error', async () => {
+      // This test reproduces the bug where bit-rules-template.md was not found
+      const rulesContent = await mcpServer.getRulesContent(false);
+      (0, _chai().expect)(rulesContent).to.be.a('string');
+      (0, _chai().expect)(rulesContent).to.contain('# Bit MCP Agent Instructions');
+      (0, _chai().expect)(rulesContent).to.contain('Core Objectives');
+    });
+    it('should get consumer project rules content without error', async () => {
+      const rulesContent = await mcpServer.getRulesContent(true);
+      (0, _chai().expect)(rulesContent).to.be.a('string');
+      (0, _chai().expect)(rulesContent).to.contain('## How to Install and Use Bit Components');
+      (0, _chai().expect)(rulesContent).to.contain('Bit Components are reusable pieces of code');
+    });
+    it('should write rules file for VS Code without error', async () => {
+      await mcpServer.writeRulesFile('vscode', {
+        isGlobal: false,
+        consumerProject: false
+      }, workspacePath);
+
+      // Check that the rules file was created
+      const rulesPath = _path().default.join(workspacePath, '.github', 'instructions', 'bit.instructions.md');
+      const rulesExists = await _fsExtra().default.pathExists(rulesPath);
+      (0, _chai().expect)(rulesExists).to.be.true;
+
+      // Check content
+      const rulesContent = await _fsExtra().default.readFile(rulesPath, 'utf8');
+      (0, _chai().expect)(rulesContent).to.contain('# Bit MCP Agent Instructions');
+      (0, _chai().expect)(rulesContent).to.contain('Core Objectives');
+    });
+    it('should write consumer project rules file without error', async () => {
+      await mcpServer.writeRulesFile('vscode', {
+        isGlobal: false,
+        consumerProject: true
+      }, workspacePath);
+
+      // Check that the rules file was created
+      const rulesPath = _path().default.join(workspacePath, '.github', 'instructions', 'bit.instructions.md');
+      const rulesExists = await _fsExtra().default.pathExists(rulesPath);
+      (0, _chai().expect)(rulesExists).to.be.true;
+
+      // Check content is different for consumer project
+      const rulesContent = await _fsExtra().default.readFile(rulesPath, 'utf8');
+      (0, _chai().expect)(rulesContent).to.contain('## How to Install and Use Bit Components');
+      (0, _chai().expect)(rulesContent).to.contain('Bit Components are reusable pieces of code');
+    });
+  });
+});
+
+//# sourceMappingURL=cli-mcp-server.spec.js.map