DeepSource MCP Server

/** * @fileoverview Recent run issues handler for the DeepSource MCP server * This module provides MCP tool handlers for fetching issues from the most recent run. */ import { DeepSourceClient } from '../deepsource.js'; import { ApiResponse } from '../models/common.js'; import { DeepSourceIssue } from '../models/issues.js'; import { createLogger, Logger } from '../utils/logging/logger.js'; import { PaginationParams } from '../utils/pagination/types.js'; import { BranchName, asProjectKey, asBranchName } from '../types/branded.js'; import { BaseHandlerDeps } from './base/handler.interface.js'; import { createBaseHandlerFactory, wrapInApiResponse, createDefaultHandlerDeps, } from './base/handler.factory.js'; import { IAnalysisRunRepository } from '../domain/aggregates/analysis-run/analysis-run.repository.js'; import { RepositoryFactory } from '../infrastructure/factories/repository.factory.js'; // Logger for the recent run issues handler const logger = createLogger('RecentRunIssuesHandler'); /** * Interface for parameters for fetching issues from the most recent run * @public */ export interface DeepsourceRecentRunIssuesParams extends PaginationParams { /** DeepSource project key to fetch issues for */ projectKey: string; /** Branch name to fetch the most recent run from */ branchName: string; } /** * Extended dependencies interface for recent run issues handler */ interface RecentRunIssuesHandlerDeps { analysisRunRepository: IAnalysisRunRepository; client: DeepSourceClient; logger: Logger; } /** * Creates a recent run issues handler with injected dependencies using domain aggregates * @param deps - The dependencies for the handler * @returns The configured handler function */ export function createRecentRunIssuesHandlerWithRepo(deps: RecentRunIssuesHandlerDeps) { return async function handleRecentRunIssues(params: DeepsourceRecentRunIssuesParams) { try { const { projectKey, branchName } = params; const projectKeyBranded = asProjectKey(projectKey); const branchNameBranded = asBranchName(branchName); deps.logger.info('Fetching recent run from repository and issues from client', { projectKey, branchName, }); // Get the most recent run using domain repository const recentRun = await deps.analysisRunRepository.findMostRecent( projectKeyBranded, branchNameBranded ); if (!recentRun) { deps.logger.error('No recent run found for branch', { projectKey, branchName }); throw new Error( `No recent analysis run found for branch "${branchName}" in project "${projectKey}"` ); } deps.logger.info('Found recent run, fetching issues via client', { runId: recentRun.runId, commitOid: recentRun.commitInfo.oid, branchName: recentRun.commitInfo.branch, }); // Get issues for this run using the client (since we don't have an issue domain aggregate yet) const result = await deps.client.getRecentRunIssues(projectKey, branchName as BranchName); // Verify we got the same run (sanity check) if (!result.run || result.run.runUid !== recentRun.runId) { deps.logger.warn('Mismatch between domain run and client run', { domainRunId: recentRun.runId, clientRunUid: result.run?.runUid || 'null', }); } deps.logger.info('Successfully fetched recent run issues', { runId: recentRun.runId, commitOid: recentRun.commitInfo.oid, issueCount: result.items.length, totalCount: result.totalCount, hasNextPage: result.pageInfo?.hasNextPage, hasPreviousPage: result.pageInfo?.hasPreviousPage, }); const recentRunData = { run: { id: recentRun.runId, runUid: recentRun.runId, // Domain aggregate uses runId as unique identifier commitOid: recentRun.commitInfo.oid, branchName: recentRun.commitInfo.branch, baseOid: recentRun.commitInfo.baseOid, status: recentRun.status, createdAt: recentRun.timestamps.createdAt, updatedAt: recentRun.timestamps.startedAt || recentRun.timestamps.createdAt, finishedAt: recentRun.timestamps.finishedAt, summary: { occurrencesIntroduced: recentRun.summary.totalIntroduced.count, occurrencesResolved: recentRun.summary.totalResolved.count, occurrencesSuppressed: recentRun.summary.totalSuppressed.count, occurrenceDistributionByAnalyzer: recentRun.summary.byAnalyzer.map((dist) => ({ analyzerShortcode: dist.analyzerShortcode, introduced: dist.introduced.count, })), occurrenceDistributionByCategory: recentRun.summary.byCategory.map((dist) => ({ category: dist.category, introduced: dist.introduced.count, })), }, repository: { name: 'Repository', // Domain aggregate doesn't store repository name directly id: recentRun.repositoryId, }, }, issues: result.items.map((issue: DeepSourceIssue) => ({ id: issue.id, title: issue.title, shortcode: issue.shortcode, category: issue.category, severity: issue.severity, status: issue.status, issue_text: issue.issue_text, file_path: issue.file_path, line_number: issue.line_number, tags: issue.tags, })), pageInfo: { hasNextPage: result.pageInfo?.hasNextPage || false, hasPreviousPage: result.pageInfo?.hasPreviousPage || false, startCursor: result.pageInfo?.startCursor || null, endCursor: result.pageInfo?.endCursor || null, }, totalCount: result.totalCount, // Provide helpful information and guidance usage_examples: { pagination: { next_page: 'For forward pagination, use first and after parameters', previous_page: 'For backward pagination, use last and before parameters', }, related_tools: { run_details: 'Use the run tool to get detailed information about a specific run', all_issues: 'Use the project_issues tool to get all issues in the project', other_runs: 'Use the runs tool to list all runs for the project', }, }, }; return { content: [ { type: 'text' as const, text: JSON.stringify(recentRunData), }, ], }; } catch (error) { deps.logger.error('Error in handleRecentRunIssues', { errorType: typeof error, errorName: error instanceof Error ? error.name : 'Unknown', errorMessage: error instanceof Error ? error.message : String(error), errorStack: error instanceof Error ? error.stack : 'No stack available', }); const errorMessage = error instanceof Error ? error.message : 'Unknown error'; deps.logger.debug('Returning error response', { errorMessage }); return { isError: true, content: [ { type: 'text' as const, text: JSON.stringify({ error: errorMessage, details: 'Failed to retrieve recent run issues', }), }, ], }; } }; } /** * Creates a recent run issues handler with injected dependencies * @param deps - The dependencies for the handler * @returns The configured handler factory */ export const createRecentRunIssuesHandler = createBaseHandlerFactory( 'recent_run_issues', async (deps: BaseHandlerDeps, { projectKey, branchName }: DeepsourceRecentRunIssuesParams) => { const apiKey = deps.getApiKey(); deps.logger.debug('API key retrieved from config', { length: apiKey.length, prefix: `${apiKey.substring(0, 5)}...`, }); const client = new DeepSourceClient(apiKey); deps.logger.info('Fetching recent run issues', { projectKey, branchName, }); const result = await client.getRecentRunIssues(projectKey, branchName as BranchName); if (!result.run) { deps.logger.error('No recent run found for branch', { projectKey, branchName }); throw new Error( `No recent analysis run found for branch "${branchName}" in project "${projectKey}"` ); } deps.logger.info('Successfully fetched recent run issues', { runUid: result.run.runUid, commitOid: result.run.commitOid, issueCount: result.items.length, totalCount: result.totalCount, hasNextPage: result.pageInfo?.hasNextPage, hasPreviousPage: result.pageInfo?.hasPreviousPage, }); const recentRunData = { run: { id: result.run.id, runUid: result.run.runUid, commitOid: result.run.commitOid, branchName: result.run.branchName, baseOid: result.run.baseOid, status: result.run.status, createdAt: result.run.createdAt, updatedAt: result.run.updatedAt, finishedAt: result.run.finishedAt, summary: { occurrencesIntroduced: result.run.summary.occurrencesIntroduced, occurrencesResolved: result.run.summary.occurrencesResolved, occurrencesSuppressed: result.run.summary.occurrencesSuppressed, occurrenceDistributionByAnalyzer: result.run.summary.occurrenceDistributionByAnalyzer, occurrenceDistributionByCategory: result.run.summary.occurrenceDistributionByCategory, }, repository: { name: result.run.repository.name, id: result.run.repository.id, }, }, issues: result.items.map((issue: DeepSourceIssue) => ({ id: issue.id, title: issue.title, shortcode: issue.shortcode, category: issue.category, severity: issue.severity, status: issue.status, issue_text: issue.issue_text, file_path: issue.file_path, line_number: issue.line_number, tags: issue.tags, })), pageInfo: { hasNextPage: result.pageInfo?.hasNextPage || false, hasPreviousPage: result.pageInfo?.hasPreviousPage || false, startCursor: result.pageInfo?.startCursor || null, endCursor: result.pageInfo?.endCursor || null, }, totalCount: result.totalCount, // Provide helpful information and guidance usage_examples: { pagination: { next_page: 'For forward pagination, use first and after parameters', previous_page: 'For backward pagination, use last and before parameters', }, related_tools: { run_details: 'Use the run tool to get detailed information about a specific run', all_issues: 'Use the project_issues tool to get all issues in the project', other_runs: 'Use the runs tool to list all runs for the project', }, }, }; return wrapInApiResponse(recentRunData); } ); /** * Fetches and returns issues from the most recent analysis run on a specific branch using domain aggregates * @param params - Parameters for fetching the issues, including project key, branch name, and pagination * @returns A response containing the issues data and run information * @throws Error if the DEEPSOURCE_API_KEY environment variable is not set * @public */ export async function handleDeepsourceRecentRunIssues( params: DeepsourceRecentRunIssuesParams ): Promise<ApiResponse> { const baseDeps = createDefaultHandlerDeps({ logger }); const apiKey = baseDeps.getApiKey(); const repositoryFactory = new RepositoryFactory({ apiKey }); const analysisRunRepository = repositoryFactory.createAnalysisRunRepository(); const client = new DeepSourceClient(apiKey); const deps: RecentRunIssuesHandlerDeps = { analysisRunRepository, client, logger, }; const handler = createRecentRunIssuesHandlerWithRepo(deps); const result = await handler(params); // If the domain handler returned an error response, throw an error for backward compatibility if (result.isError) { const firstContent = result.content[0]; if (firstContent) { const errorData = JSON.parse(firstContent.text); throw new Error(errorData.error); } else { throw new Error('Unknown recent run issues error'); } } return result; }