CircleCI MCP Server

Instructions

Implementation Reference

• src/tools/analyzeDiff/handler.ts:10-67 (handler)

  Main handler function implementing the analyze_diff tool logic: analyzes git diff against cursor rules using CircletClient and returns violations or compliance status.

  export const analyzeDiff: ToolCallback<{
    params: typeof analyzeDiffInputSchema;
  }> = async (args) => {
    const { diff, rules, speedMode, filterBy } = args.params;
    const circlet = new CircletClient();
    if (!diff) {
      return {
        content: [
          {
            type: 'text',
            text: 'No diff found. Please provide a diff to analyze.',
          },
        ],
      };
    }
  
    if (!rules) {
      return {
        content: [
          {
            type: 'text',
            text: 'No rules found. Please add rules to your repository.',
          },
        ],
      };
    }
  
    const response = await circlet.circlet.ruleReview({
      diff,
      rules,
      filterBy,
      speedMode,
    });
  
    if (!response.isRuleCompliant) {
      return {
        content: [
          {
            type: 'text',
            text: response.relatedRules.violations
              .map((violation) => {
                return `Rule: ${violation.rule}\nReason: ${violation.reason}\nConfidence Score: ${violation.confidenceScore}`;
              })
              .join('\n\n'),
          },
        ],
      };
    }
  
    return {
      content: [
        {
          type: 'text',
          text: `All rules are compliant.`,
        },
      ],
    };
  };

• src/tools/analyzeDiff/inputSchema.ts:4-23 (schema)

  Zod input schema defining parameters for analyze_diff: speedMode, filterBy, diff, rules.

  export const analyzeDiffInputSchema = z.object({
    speedMode: z
      .boolean()
      .default(false)
      .describe('The status of speed mode. Defaults to false.'),
    filterBy: z
      .nativeEnum(FilterBy)
      .default(FilterBy.none)
      .describe(`Analysis filter. Defaults to ${FilterBy.none}`),
    diff: z
      .string()
      .describe(
        'Git diff content to analyze. Defaults to staged changes, unless the user explicitly asks for unstaged changes or all changes.',
      ),
    rules: z
      .string()
      .describe(
        'Rules to use for analysis, found in the rules subdirectory of the IDE workspace settings. Combine all rules from multiple files by separating them with ---',
      ),
  });

• src/tools/analyzeDiff/tool.ts:4-21 (registration)

  Tool registration object defining name 'analyze_diff', description, and inputSchema.

  export const analyzeDiffTool = {
    name: 'analyze_diff' as const,
    description: `
    This tool is used to analyze a git diff (unstaged, staged, or all changes) against IDE rules to identify rule violations.
    By default, the tool will use the staged changes, unless the user explicitly asks for unstaged or all changes.
  
    Parameters:
    - params: An object containing:
      - speedMode: boolean - A mode that can be enabled to speed up the analysis. Default value is false.
      - filterBy: enum - "${FilterBy.violations}" | "${FilterBy.compliants}" | "${FilterBy.humanReviewRequired}" | "${FilterBy.none}" - A filter that can be applied to set the focus of the analysis. Default is ${FilterBy.none}.
      - diff: string - A git diff string.
      - rules: string - Rules to use for analysis, found in the rules subdirectory of the IDE workspace settings. Combine all rules from multiple files by separating them with ---
  
    Returns:
    - A list of rule violations found in the git diff.
    `,
    inputSchema: analyzeDiffInputSchema,
  };

• src/circleci-tools.ts:24-72 (registration)

  Registration of analyzeDiffTool in CCI_TOOLS array and analyzeDiff handler in CCI_HANDLERS object.

  import { analyzeDiffTool } from './tools/analyzeDiff/tool.js';
  import { analyzeDiff } from './tools/analyzeDiff/handler.js';
  import { runRollbackPipelineTool } from './tools/runRollbackPipeline/tool.js';
  import { runRollbackPipeline } from './tools/runRollbackPipeline/handler.js';
  
  // Define the tools with their configurations
  export const CCI_TOOLS = [
    getBuildFailureLogsTool,
    getFlakyTestLogsTool,
    getLatestPipelineStatusTool,
    getJobTestResultsTool,
    configHelperTool,
    createPromptTemplateTool,
    recommendPromptTemplateTestsTool,
    runPipelineTool,
    listFollowedProjectsTool,
    runEvaluationTestsTool,
    rerunWorkflowTool,
    analyzeDiffTool,
    runRollbackPipelineTool,
  ];
  
  // Extract the tool names as a union type
  type CCIToolName = (typeof CCI_TOOLS)[number]['name'];
  
  export type ToolHandler<T extends CCIToolName> = ToolCallback<{
    params: Extract<(typeof CCI_TOOLS)[number], { name: T }>['inputSchema'];
  }>;
  
  // Create a type for the tool handlers that directly maps each tool to its appropriate input schema
  type ToolHandlers = {
    [K in CCIToolName]: ToolHandler<K>;
  };
  
  export const CCI_HANDLERS = {
    get_build_failure_logs: getBuildFailureLogs,
    find_flaky_tests: getFlakyTestLogs,
    get_latest_pipeline_status: getLatestPipelineStatus,
    get_job_test_results: getJobTestResults,
    config_helper: configHelper,
    create_prompt_template: createPromptTemplate,
    recommend_prompt_template_tests: recommendPromptTemplateTests,
    run_pipeline: runPipeline,
    list_followed_projects: listFollowedProjects,
    run_evaluation_tests: runEvaluationTests,
    rerun_workflow: rerunWorkflow,
    analyze_diff: analyzeDiff,
    run_rollback_pipeline: runRollbackPipeline,
  } satisfies ToolHandlers;