create_ide_configs

Generate IDE configurations for Cursor, VS Code, and IntelliJ to set up development environments with custom rules and debugging options.

Instructions

Create IDE-specific configurations for Cursor, VS Code, and IntelliJ

Input Schema

TableJSON Schema

Name	Required	Description
`projectPath`	Yes	Path to the project directory
`analysisId`	No	Analysis ID from analyze_codebase_deeply
`ide`	Yes	Which IDE configurations to create
`autoLoadContext`	No	Enable automatic context loading
`customRules`	No	Custom rules to add
`includeDebugConfigs`	No	Include debugging configurations

Implementation Reference

src/tools/workspace/create-ide-configs.ts:21-66 (handler)

The primary handler function that orchestrates creation of IDE-specific configurations (Cursor, VSCode, IntelliJ) based on prior codebase analysis. Delegates to IDE-specific helper functions.

export async function createIDEConfigs(
  config: IDEConfigConfig
): Promise<IDEConfigResult> {
  const result: IDEConfigResult = {
    success: false,
    filesCreated: [],
    message: '',
    recommendations: [],
  };

  try {
    // Check if analysis has been completed
    const analysisId = config.analysisId || global.latestAnalysisId;
    if (!analysisId || !global.codebaseAnalysis?.[analysisId]) {
      throw new Error('Codebase analysis must be completed first. Run analyze_codebase_deeply tool.');
    }

    const analysis: DeepAnalysisResult = global.codebaseAnalysis[analysisId];
    const ides = config.ide === 'all' ? ['cursor', 'vscode', 'intellij'] : [config.ide];
    
    for (const ide of ides) {
      switch (ide) {
        case 'cursor':
          await createCursorConfig(config, analysis, result);
          break;
        case 'vscode':
          await createVSCodeConfig(config, analysis, result);
          break;
        case 'intellij':
          await createIntelliJConfig(config, analysis, result);
          break;
      }
    }
    
    // Add general recommendations
    result.recommendations = generateIDERecommendations(analysis, config);
    
    result.success = true;
    result.message = `Created IDE configurations for ${ides.join(', ')}. ${config.autoLoadContext ? 'Auto-loading enabled.' : 'Manual loading required.'}`;
  } catch (error) {
    result.success = false;
    result.message = `Failed to create IDE configs: ${error}`;
  }

  return result;
}

src/tools/tool-definitions.ts:309-343 (schema)

Input schema definition for the create_ide_configs tool, defining parameters like projectPath, analysisId, ide choice, and options.

  name: 'create_ide_configs',
  description: 'Create IDE-specific configurations for Cursor, VS Code, and IntelliJ',
  inputSchema: {
    type: 'object',
    properties: {
      projectPath: {
        type: 'string',
        description: 'Path to the project directory',
      },
      analysisId: {
        type: 'string',
        description: 'Analysis ID from analyze_codebase_deeply',
      },
      ide: {
        type: 'string',
        enum: ['cursor', 'vscode', 'intellij', 'all'],
        description: 'Which IDE configurations to create',
      },
      autoLoadContext: {
        type: 'boolean',
        description: 'Enable automatic context loading',
      },
      customRules: {
        type: 'array',
        items: { type: 'string' },
        description: 'Custom rules to add',
      },
      includeDebugConfigs: {
        type: 'boolean',
        description: 'Include debugging configurations',
      },
    },
    required: ['projectPath', 'ide'],
  },
},

src/tools/index.ts:273-292 (registration)

Registration and execution handler in the MCP CallToolRequest switch statement. Validates params with Zod and calls the createIDEConfigs function.

case 'create_ide_configs': {
  const params = z.object({
    projectPath: z.string(),
    analysisId: z.string().optional(),
    ide: z.enum(['cursor', 'vscode', 'intellij', 'all']),
    autoLoadContext: z.boolean().optional(),
    customRules: z.array(z.string()).optional(),
    includeDebugConfigs: z.boolean().optional(),
  }).parse(args);
  
  const result = await createIDEConfigs(params);
  return {
    content: [
      {
        type: 'text',
        text: JSON.stringify(result, null, 2),
      },
    ],
  };
}

src/minimal-server.ts:158-172 (registration)

Inline tool registration in the minimal server implementation for standalone use.

{
  name: 'create_ide_configs',
  description: 'Create IDE-specific configurations for Cursor, VS Code, and IntelliJ',
  inputSchema: {
    type: 'object',
    properties: {
      projectPath: { type: 'string' },
      analysisId: { type: 'string' },
      ide: { type: 'string', enum: ['cursor', 'vscode', 'intellij', 'all'] },
      autoLoadContext: { type: 'boolean' },
      customRules: { type: 'array', items: { type: 'string' } },
      includeDebugConfigs: { type: 'boolean' },
    },
    required: ['projectPath', 'ide'],
  },

src/tools/workspace/complete-setup-workflow.ts:115-115 (helper)
Usage of createIDEConfigs within the complete_setup_workflow tool as a supporting step.
```
const ideResult = await createIDEConfigs({
```

AI Agent Template MCP Server