deepsource-mcp-server
Version:
Model Context Protocol server for DeepSource
254 lines • 11.6 kB
JavaScript
/**
* @fileoverview Run handler for the DeepSource MCP server
* This module provides MCP tool handlers for fetching a specific DeepSource analysis run.
*/
import { DeepSourceClient, } from '../deepsource.js';
import { createLogger } from '../utils/logging/logger.js';
import { createBaseHandlerFactory, wrapInApiResponse, createDefaultHandlerDeps, } from './base/handler.factory.js';
import { RepositoryFactory } from '../infrastructure/factories/repository.factory.js';
import { asProjectKey, asRunId, asCommitOid } from '../types/branded.js';
// Logger for the run handler
const logger = createLogger('RunHandler');
/**
* Creates a run handler with injected dependencies using domain aggregates
* @param deps - The dependencies for the handler
* @returns The configured handler function
*/
export function createRunHandlerWithRepo(deps) {
return async function handleRun(params) {
try {
const { projectKey, runIdentifier, isCommitOid = false } = params;
const projectKeyBranded = asProjectKey(projectKey);
deps.logger.info('Fetching run from repository', {
projectKey,
runIdentifier,
identifierType: isCommitOid ? 'commitOid' : 'runUid',
});
let domainRun;
if (isCommitOid) {
// Search by commit OID
const commitOidBranded = asCommitOid(runIdentifier);
domainRun = await deps.analysisRunRepository.findByCommit(projectKeyBranded, commitOidBranded);
}
else {
// Search by run ID (assuming runIdentifier is the runId)
const runIdBranded = asRunId(runIdentifier);
domainRun = await deps.analysisRunRepository.findByRunId(runIdBranded);
}
if (!domainRun) {
deps.logger.error('Run not found', {
projectKey,
runIdentifier,
identifierType: isCommitOid ? 'commitOid' : 'runUid',
});
throw new Error(`Run with ${isCommitOid ? 'commitOid' : 'runUid'} "${runIdentifier}" not found`);
}
deps.logger.info('Successfully fetched run', {
runId: domainRun.runId,
commitOid: domainRun.commitInfo.oid,
branchName: domainRun.commitInfo.branch,
status: domainRun.status,
});
const runData = {
run: {
id: domainRun.runId,
runUid: domainRun.runId, // Domain aggregate uses runId as the unique identifier
commitOid: domainRun.commitInfo.oid,
branchName: domainRun.commitInfo.branch,
baseOid: domainRun.commitInfo.baseOid,
status: domainRun.status,
createdAt: domainRun.timestamps.createdAt,
updatedAt: domainRun.timestamps.startedAt || domainRun.timestamps.createdAt,
finishedAt: domainRun.timestamps.finishedAt,
summary: {
occurrencesIntroduced: domainRun.summary.totalIntroduced.count,
occurrencesResolved: domainRun.summary.totalResolved.count,
occurrencesSuppressed: domainRun.summary.totalSuppressed.count,
occurrenceDistributionByAnalyzer: domainRun.summary.byAnalyzer.map((dist) => ({
analyzerShortcode: dist.analyzerShortcode,
introduced: dist.introduced.count,
})),
occurrenceDistributionByCategory: domainRun.summary.byCategory.map((dist) => ({
category: dist.category,
introduced: dist.introduced.count,
})),
},
repository: {
name: 'Repository', // Domain aggregate doesn't store repository name directly
id: domainRun.repositoryId,
},
},
// Provide helpful guidance and related information
analysis: {
status_info: getStatusInfo(domainRun.status),
issue_summary: `This run introduced ${domainRun.summary.totalIntroduced.count} issues, resolved ${domainRun.summary.totalResolved.count} issues, and suppressed ${domainRun.summary.totalSuppressed.count} issues.`,
analyzers_used: domainRun.summary.byAnalyzer?.map((a) => a.analyzerShortcode) || [],
issue_categories: domainRun.summary.byCategory?.map((c) => c.category) || [],
},
related_tools: {
issues: 'Use the project_issues tool to get all issues in the project',
runs: 'Use the runs tool to list all runs for the project',
recent_issues: 'Use the recent_run_issues tool to get issues from the most recent run on a branch',
},
};
return {
content: [
{
type: 'text',
text: JSON.stringify(runData),
},
],
};
}
catch (error) {
deps.logger.error('Error in handleRun', {
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',
text: JSON.stringify({
error: errorMessage,
details: 'Failed to retrieve run',
}),
},
],
};
}
};
}
/**
* Creates a run handler with injected dependencies
* @param deps - The dependencies for the handler
* @returns The configured handler factory
*/
export const createRunHandler = createBaseHandlerFactory('run', async (deps, { projectKey, runIdentifier, isCommitOid = false }) => {
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 run', {
projectKey,
runIdentifier,
identifierType: isCommitOid ? 'commitOid' : 'runUid',
});
const run = await client.getRun(runIdentifier);
if (!run) {
deps.logger.error('Run not found', {
projectKey,
runIdentifier,
identifierType: isCommitOid ? 'commitOid' : 'runUid',
});
throw new Error(`Run with ${isCommitOid ? 'commitOid' : 'runUid'} "${runIdentifier}" not found in project "${projectKey}"`);
}
deps.logger.info('Successfully fetched run', {
runUid: run.runUid,
commitOid: run.commitOid,
branchName: run.branchName,
status: run.status,
});
const runData = {
run: {
id: run.id,
runUid: run.runUid,
commitOid: run.commitOid,
branchName: run.branchName,
baseOid: run.baseOid,
status: run.status,
createdAt: run.createdAt,
updatedAt: run.updatedAt,
finishedAt: run.finishedAt,
summary: {
occurrencesIntroduced: run.summary.occurrencesIntroduced,
occurrencesResolved: run.summary.occurrencesResolved,
occurrencesSuppressed: run.summary.occurrencesSuppressed,
occurrenceDistributionByAnalyzer: run.summary.occurrenceDistributionByAnalyzer,
occurrenceDistributionByCategory: run.summary.occurrenceDistributionByCategory,
},
repository: {
name: run.repository.name,
id: run.repository.id,
},
},
// Provide helpful guidance and related information
analysis: {
status_info: getStatusInfo(run.status),
issue_summary: `This run introduced ${run.summary.occurrencesIntroduced} issues, resolved ${run.summary.occurrencesResolved} issues, and suppressed ${run.summary.occurrencesSuppressed} issues.`,
analyzers_used: run.summary.occurrenceDistributionByAnalyzer?.map((a) => a.analyzerShortcode) || [],
issue_categories: run.summary.occurrenceDistributionByCategory?.map((c) => c.category) || [],
},
related_tools: {
issues: 'Use the project_issues tool to get all issues in the project',
runs: 'Use the runs tool to list all runs for the project',
recent_issues: 'Use the recent_run_issues tool to get issues from the most recent run on a branch',
},
};
return wrapInApiResponse(runData);
});
/**
* Fetches and returns information about a specific analysis run using domain aggregates
* @param params - Parameters for fetching the run, including project key and run identifier
* @returns A response containing the run data
* @throws Error if the DEEPSOURCE_API_KEY environment variable is not set
* @public
*/
export async function handleDeepsourceRun(params) {
const baseDeps = createDefaultHandlerDeps({ logger });
const apiKey = baseDeps.getApiKey();
const repositoryFactory = new RepositoryFactory({ apiKey });
const analysisRunRepository = repositoryFactory.createAnalysisRunRepository();
const deps = {
analysisRunRepository,
logger,
};
const handler = createRunHandlerWithRepo(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 run error');
}
}
return result;
}
/**
* Helper function to get human-readable status information
* @param status The run status
* @returns Information about the status
* @private
*/
function getStatusInfo(status) {
switch (status) {
case 'PENDING':
return 'The run is currently queued and waiting to be processed.';
case 'SUCCESS':
return 'The run completed successfully with all analyzers.';
case 'FAILURE':
return 'The run failed due to an error during analysis.';
case 'TIMEOUT':
return 'The run exceeded the maximum allowed time and was terminated.';
case 'CANCEL':
return 'The run was manually cancelled.';
case 'READY':
return 'The run is ready to be processed but not yet started.';
case 'SKIPPED':
return 'The run was skipped, possibly due to no code changes detected.';
default:
return `Unknown status: ${status}`;
}
}
//# sourceMappingURL=run.js.map