DeepSource MCP Server

/** * @fileoverview Tool registration module for DeepSource MCP tools * * This module handles the registration of all DeepSource tools with the * MCP server. It centralizes tool registration logic and provides a * clean interface for registering tools. * * @packageDocumentation */ import { ToolRegistry, ToolDefinition } from './tool-registry.js'; import { toolSchemas } from './tool-definitions.js'; import { handleProjects, handleDeepsourceQualityMetrics, handleDeepsourceUpdateMetricThreshold, handleDeepsourceUpdateMetricSetting, handleDeepsourceComplianceReport, handleDeepsourceProjectIssues, handleDeepsourceProjectRuns, handleDeepsourceRun, handleDeepsourceRecentRunIssues, handleDeepsourceDependencyVulnerabilities, } from '../handlers/index.js'; import { DeepsourceRunParams } from '../handlers/run.js'; import { DeepsourceRecentRunIssuesParams } from '../handlers/recent-run-issues.js'; import { DeepsourceDependencyVulnerabilitiesParams } from '../handlers/dependency-vulnerabilities.js'; import { MetricKey } from '../types/metrics.js'; import { AnalyzerShortcode } from '../types/branded.js'; import { MetricShortcode } from '../models/metrics.js'; import { ReportType } from '../types/report-types.js'; import { createLogger } from '../utils/logging/logger.js'; const logger = createLogger('ToolRegistration'); /** * Handler mapping for tool schemas */ const TOOL_HANDLERS: Record<string, (params: unknown) => Promise<unknown>> = { projects: async (params: unknown) => { logger.info('=== PROJECTS HANDLER START ==='); logger.info('Projects handler called with params:', { params, type: typeof params }); try { // Params currently unused but may be used for future filtering const result = await handleProjects(); logger.info('=== PROJECTS HANDLER SUCCESS ===', { result }); return result; } catch (error) { logger.error('=== PROJECTS HANDLER ERROR ===', { error, message: error instanceof Error ? error.message : String(error), stack: error instanceof Error ? error.stack : undefined, }); throw error; } }, quality_metrics: async (params: unknown) => { const typedParams = params as Record<string, unknown>; const metricsParams: { projectKey: string; shortcodeIn?: MetricShortcode[] } = { projectKey: typedParams.projectKey as string, }; const shortcodeIn = typedParams.shortcodeIn as MetricShortcode[] | undefined; if (shortcodeIn) { metricsParams.shortcodeIn = shortcodeIn; } return handleDeepsourceQualityMetrics(metricsParams); }, update_metric_threshold: async (params: unknown) => { const typedParams = params as Record<string, unknown>; const thresholdParams: { projectKey: string; repositoryId: string; metricShortcode: MetricShortcode; metricKey: MetricKey; thresholdValue?: number | null; } = { projectKey: typedParams.projectKey as string, repositoryId: typedParams.repositoryId as string, metricShortcode: typedParams.metricShortcode as MetricShortcode, metricKey: typedParams.metricKey as MetricKey, }; const thresholdValue = typedParams.thresholdValue as number | null | undefined; if (thresholdValue !== undefined) { thresholdParams.thresholdValue = thresholdValue; } return handleDeepsourceUpdateMetricThreshold(thresholdParams); }, update_metric_setting: async (params: unknown) => { const typedParams = params as Record<string, unknown>; return handleDeepsourceUpdateMetricSetting({ projectKey: typedParams.projectKey as string, repositoryId: typedParams.repositoryId as string, metricShortcode: typedParams.metricShortcode as MetricShortcode, isReported: typedParams.isReported as boolean, isThresholdEnforced: typedParams.isThresholdEnforced as boolean, }); }, compliance_report: async (params: unknown) => { const typedParams = params as Record<string, unknown>; return handleDeepsourceComplianceReport({ projectKey: typedParams.projectKey as string, reportType: typedParams.reportType as ReportType, }); }, project_issues: async (params: unknown) => { const typedParams = params as Record<string, unknown>; const issuesParams: { projectKey: string; path?: string; analyzerIn?: string[]; tags?: string[]; first?: number; last?: number; after?: string; before?: string; } = { projectKey: typedParams.projectKey as string, }; if (typeof typedParams.path === 'string') { issuesParams.path = typedParams.path; } if (Array.isArray(typedParams.analyzerIn)) { issuesParams.analyzerIn = typedParams.analyzerIn as string[]; } if (Array.isArray(typedParams.tags)) { issuesParams.tags = typedParams.tags as string[]; } if (typeof typedParams.first === 'number') { issuesParams.first = typedParams.first; } if (typeof typedParams.last === 'number') { issuesParams.last = typedParams.last; } if (typeof typedParams.after === 'string') { issuesParams.after = typedParams.after; } if (typeof typedParams.before === 'string') { issuesParams.before = typedParams.before; } return handleDeepsourceProjectIssues(issuesParams); }, runs: async (params: unknown) => { const typedParams = params as Record<string, unknown>; const runsParams: { projectKey: string; analyzerIn: AnalyzerShortcode[]; first?: number; last?: number; after?: string; before?: string; } = { projectKey: typedParams.projectKey as string, analyzerIn: typedParams.analyzerIn as AnalyzerShortcode[], }; if (typeof typedParams.first === 'number') { runsParams.first = typedParams.first; } if (typeof typedParams.last === 'number') { runsParams.last = typedParams.last; } if (typeof typedParams.after === 'string') { runsParams.after = typedParams.after; } if (typeof typedParams.before === 'string') { runsParams.before = typedParams.before; } return handleDeepsourceProjectRuns(runsParams); }, run: async (params: unknown) => { const typedParams = params as Record<string, unknown>; const runParams: DeepsourceRunParams = { projectKey: typedParams.projectKey as string, runIdentifier: typedParams.runIdentifier as string, }; if (typeof typedParams.isCommitOid === 'boolean') { runParams.isCommitOid = typedParams.isCommitOid; } return handleDeepsourceRun(runParams); }, recent_run_issues: async (params: unknown) => { const typedParams = params as Record<string, unknown>; const recentRunParams: DeepsourceRecentRunIssuesParams = { projectKey: typedParams.projectKey as string, branchName: typedParams.branchName as string, }; if (typeof typedParams.first === 'number') { recentRunParams.first = typedParams.first; } if (typeof typedParams.last === 'number') { recentRunParams.last = typedParams.last; } if (typeof typedParams.after === 'string') { recentRunParams.after = typedParams.after; } if (typeof typedParams.before === 'string') { recentRunParams.before = typedParams.before; } return handleDeepsourceRecentRunIssues(recentRunParams); }, dependency_vulnerabilities: async (params: unknown) => { const typedParams = params as Record<string, unknown>; const vulnParams: DeepsourceDependencyVulnerabilitiesParams = { projectKey: typedParams.projectKey as string, }; if (typeof typedParams.first === 'number') { vulnParams.first = typedParams.first; } if (typeof typedParams.last === 'number') { vulnParams.last = typedParams.last; } if (typeof typedParams.after === 'string') { vulnParams.after = typedParams.after; } if (typeof typedParams.before === 'string') { vulnParams.before = typedParams.before; } return handleDeepsourceDependencyVulnerabilities(vulnParams); }, }; /** * Creates a tool definition from a schema and handler * * @param schema - The tool schema * @param handler - The tool handler function * @returns The tool definition */ function createToolDefinition( schema: { name: string; description: string; inputSchema?: unknown; outputSchema?: unknown; }, handler: (_params: unknown) => Promise<unknown> ): ToolDefinition { logger.debug(`Creating tool definition for ${schema.name}`, { hasInputSchema: Boolean(schema.inputSchema), inputSchemaType: typeof schema.inputSchema, inputSchema: schema.inputSchema, }); return { name: schema.name, description: schema.description, inputSchema: schema.inputSchema, outputSchema: schema.outputSchema, handler, } as ToolDefinition; } /** * Registers all DeepSource tools with the tool registry * * @param registry - The tool registry to register tools with */ export function registerDeepSourceTools(registry: ToolRegistry): void { logger.info('=== REGISTER DEEPSOURCE TOOLS START ==='); logger.info('Registering DeepSource tools', { toolSchemasType: typeof toolSchemas, toolSchemasIsArray: Array.isArray(toolSchemas), toolSchemasLength: Array.isArray(toolSchemas) ? toolSchemas.length : 'not an array', toolSchemaNames: Array.isArray(toolSchemas) ? toolSchemas.map((s) => s.name) : 'not an array', }); const toolDefinitions: ToolDefinition[] = []; // Create tool definitions from schemas and handlers for (const schema of toolSchemas) { logger.debug(`Processing schema: ${schema.name}`); const handler = TOOL_HANDLERS[schema.name]; if (!handler) { logger.warn(`No handler found for tool: ${schema.name}`); continue; } logger.debug(`Creating tool definition for: ${schema.name}`); const toolDef = createToolDefinition(schema, handler); toolDefinitions.push(toolDef); logger.debug(`Successfully created tool definition for: ${schema.name}`); } logger.info(`Prepared ${toolDefinitions.length} tool definitions for registration`); // Register all tools registry.registerTools(toolDefinitions); logger.info('=== REGISTER DEEPSOURCE TOOLS COMPLETE ===', { registeredCount: toolDefinitions.length, registeredTools: toolDefinitions.map((t) => t.name), }); } /** * Tool categories for organization */ export enum ToolCategory { PROJECT_MANAGEMENT = 'project_management', CODE_QUALITY = 'code_quality', SECURITY = 'security', ANALYSIS = 'analysis', DEPENDENCIES = 'dependencies', } /** * Tool metadata for categorization and filtering */ export interface ToolMetadata { category: ToolCategory; tags: string[]; requiresAuth: boolean; supportsFiltering: boolean; supportsPagination: boolean; } /** * Metadata for all DeepSource tools */ export const TOOL_METADATA: Record<string, ToolMetadata> = { projects: { category: ToolCategory.PROJECT_MANAGEMENT, tags: ['projects', 'list', 'discovery'], requiresAuth: true, supportsFiltering: false, supportsPagination: false, }, quality_metrics: { category: ToolCategory.CODE_QUALITY, tags: ['metrics', 'quality', 'code', 'statistics'], requiresAuth: true, supportsFiltering: true, supportsPagination: false, }, update_metric_threshold: { category: ToolCategory.CODE_QUALITY, tags: ['metrics', 'quality', 'threshold', 'update', 'mutation'], requiresAuth: true, supportsFiltering: false, supportsPagination: false, }, update_metric_setting: { category: ToolCategory.CODE_QUALITY, tags: ['metrics', 'quality', 'settings', 'update', 'mutation'], requiresAuth: true, supportsFiltering: false, supportsPagination: false, }, compliance_report: { category: ToolCategory.SECURITY, tags: ['compliance', 'security', 'report', 'owasp', 'sans'], requiresAuth: true, supportsFiltering: false, supportsPagination: false, }, project_issues: { category: ToolCategory.CODE_QUALITY, tags: ['issues', 'problems', 'code', 'quality', 'list'], requiresAuth: true, supportsFiltering: true, supportsPagination: true, }, runs: { category: ToolCategory.ANALYSIS, tags: ['runs', 'analysis', 'history', 'list'], requiresAuth: true, supportsFiltering: true, supportsPagination: true, }, run: { category: ToolCategory.ANALYSIS, tags: ['run', 'analysis', 'details', 'single'], requiresAuth: true, supportsFiltering: false, supportsPagination: false, }, recent_run_issues: { category: ToolCategory.ANALYSIS, tags: ['issues', 'run', 'recent', 'branch', 'analysis'], requiresAuth: true, supportsFiltering: false, supportsPagination: true, }, dependency_vulnerabilities: { category: ToolCategory.DEPENDENCIES, tags: ['dependencies', 'vulnerabilities', 'security', 'cve', 'list'], requiresAuth: true, supportsFiltering: false, supportsPagination: true, }, }; /** * Gets tools by category * * @param category - The tool category * @returns Array of tool names in the category */ export function getToolsByCategory(category: ToolCategory): string[] { return Object.entries(TOOL_METADATA) .filter(([, metadata]) => metadata.category === category) .map(([name]) => name); } /** * Gets tools by tag * * @param tag - The tag to filter by * @returns Array of tool names with the tag */ export function getToolsByTag(tag: string): string[] { return Object.entries(TOOL_METADATA) .filter(([, metadata]) => metadata.tags.includes(tag)) .map(([name]) => name); } /** * Gets paginated tools * * @returns Array of tool names that support pagination */ export function getPaginatedTools(): string[] { return Object.entries(TOOL_METADATA) .filter(([, metadata]) => metadata.supportsPagination) .map(([name]) => name); }