@j0hanz/code-review-analyst-mcp 0.1.0

package/dist/schemas/outputs.js

@@ -0,0 +1,132 @@
+import { z } from 'zod';
+const OUTPUT_LIMITS = {
+    reviewFinding: {
+        fileMax: 260,
+        lineMin: 1,
+        lineMax: 1_000_000,
+        title: { min: 3, max: 160 },
+        text: { min: 10, max: 2_000 },
+    },
+    reviewDiffResult: {
+        summary: { min: 10, max: 2_000 },
+        findingsMax: 30,
+        testsNeeded: { minItems: 0, maxItems: 12, itemMin: 5, itemMax: 300 },
+    },
+    riskScoreResult: {
+        score: { min: 0, max: 100 },
+        rationale: { minItems: 1, maxItems: 10, itemMin: 8, itemMax: 500 },
+    },
+    patchSuggestionResult: {
+        summary: { min: 10, max: 1_000 },
+        patch: { min: 10, max: 60_000 },
+        checklist: { minItems: 1, maxItems: 12, itemMin: 6, itemMax: 300 },
+    },
+};
+export const DefaultOutputSchema = z.strictObject({
+    ok: z.boolean().describe('Whether the tool completed successfully.'),
+    result: z.unknown().optional().describe('Successful result payload.'),
+    error: z
+        .strictObject({
+        code: z.string().describe('Stable error code for callers.'),
+        message: z.string().describe('Human readable error details.'),
+    })
+        .optional()
+        .describe('Error payload when ok is false.'),
+});
+export const ReviewFindingSchema = z.strictObject({
+    severity: z
+        .enum(['low', 'medium', 'high', 'critical'])
+        .describe('Severity for this issue.'),
+    file: z
+        .string()
+        .min(1)
+        .max(OUTPUT_LIMITS.reviewFinding.fileMax)
+        .describe('File path for the finding.'),
+    line: z
+        .number()
+        .int()
+        .min(OUTPUT_LIMITS.reviewFinding.lineMin)
+        .max(OUTPUT_LIMITS.reviewFinding.lineMax)
+        .nullable()
+        .describe('1-based line number when known, otherwise null.'),
+    title: z
+        .string()
+        .min(OUTPUT_LIMITS.reviewFinding.title.min)
+        .max(OUTPUT_LIMITS.reviewFinding.title.max)
+        .describe('Short finding title.'),
+    explanation: z
+        .string()
+        .min(OUTPUT_LIMITS.reviewFinding.text.min)
+        .max(OUTPUT_LIMITS.reviewFinding.text.max)
+        .describe('Why this issue matters.'),
+    recommendation: z
+        .string()
+        .min(OUTPUT_LIMITS.reviewFinding.text.min)
+        .max(OUTPUT_LIMITS.reviewFinding.text.max)
+        .describe('Concrete fix recommendation.'),
+});
+export const ReviewDiffResultSchema = z.strictObject({
+    summary: z
+        .string()
+        .min(OUTPUT_LIMITS.reviewDiffResult.summary.min)
+        .max(OUTPUT_LIMITS.reviewDiffResult.summary.max)
+        .describe('Short review summary.'),
+    overallRisk: z
+        .enum(['low', 'medium', 'high'])
+        .describe('Overall risk for merging this diff.'),
+    findings: z
+        .array(ReviewFindingSchema.describe('Single code review finding.'))
+        .min(0)
+        .max(OUTPUT_LIMITS.reviewDiffResult.findingsMax)
+        .describe('Ordered list of findings, highest severity first.'),
+    testsNeeded: z
+        .array(z
+        .string()
+        .min(OUTPUT_LIMITS.reviewDiffResult.testsNeeded.itemMin)
+        .max(OUTPUT_LIMITS.reviewDiffResult.testsNeeded.itemMax)
+        .describe('Test recommendation to reduce risk.'))
+        .min(OUTPUT_LIMITS.reviewDiffResult.testsNeeded.minItems)
+        .max(OUTPUT_LIMITS.reviewDiffResult.testsNeeded.maxItems)
+        .describe('Targeted tests to add before merge.'),
+});
+export const RiskScoreResultSchema = z.strictObject({
+    score: z
+        .number()
+        .int()
+        .min(OUTPUT_LIMITS.riskScoreResult.score.min)
+        .max(OUTPUT_LIMITS.riskScoreResult.score.max)
+        .describe('Deployment risk score, where 100 is highest risk.'),
+    bucket: z
+        .enum(['low', 'medium', 'high', 'critical'])
+        .describe('Risk bucket derived from score and criticality.'),
+    rationale: z
+        .array(z
+        .string()
+        .min(OUTPUT_LIMITS.riskScoreResult.rationale.itemMin)
+        .max(OUTPUT_LIMITS.riskScoreResult.rationale.itemMax)
+        .describe('Reason that influenced the final score.'))
+        .min(OUTPUT_LIMITS.riskScoreResult.rationale.minItems)
+        .max(OUTPUT_LIMITS.riskScoreResult.rationale.maxItems)
+        .describe('Evidence-based explanation for the score.'),
+});
+export const PatchSuggestionResultSchema = z.strictObject({
+    summary: z
+        .string()
+        .min(OUTPUT_LIMITS.patchSuggestionResult.summary.min)
+        .max(OUTPUT_LIMITS.patchSuggestionResult.summary.max)
+        .describe('Short patch strategy summary.'),
+    patch: z
+        .string()
+        .min(OUTPUT_LIMITS.patchSuggestionResult.patch.min)
+        .max(OUTPUT_LIMITS.patchSuggestionResult.patch.max)
+        .describe('Unified diff patch text.'),
+    validationChecklist: z
+        .array(z
+        .string()
+        .min(OUTPUT_LIMITS.patchSuggestionResult.checklist.itemMin)
+        .max(OUTPUT_LIMITS.patchSuggestionResult.checklist.itemMax)
+        .describe('Validation step after applying patch.'))
+        .min(OUTPUT_LIMITS.patchSuggestionResult.checklist.minItems)
+        .max(OUTPUT_LIMITS.patchSuggestionResult.checklist.maxItems)
+        .describe('Post-change validation actions.'),
+});

package/dist/server.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function createServer(): McpServer;

package/dist/server.js

@@ -0,0 +1,85 @@
+import { InMemoryTaskStore } from '@modelcontextprotocol/sdk/experimental/tasks/stores/in-memory.js';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { readFileSync } from 'node:fs';
+import { findPackageJSON } from 'node:module';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { getErrorMessage } from './lib/errors.js';
+import { registerAllPrompts } from './prompts/index.js';
+import { registerAllResources } from './resources/index.js';
+import { registerAllTools } from './tools/index.js';
+function isPackageJsonMetadata(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'version' in value &&
+        typeof value.version === 'string' &&
+        value.version.trim().length > 0);
+}
+function parsePackageJson(packageJson, packageJsonPath) {
+    let parsed;
+    try {
+        parsed = JSON.parse(packageJson);
+    }
+    catch (error) {
+        throw new Error(`Invalid JSON in ${packageJsonPath}: ${getErrorMessage(error)}`);
+    }
+    if (!isPackageJsonMetadata(parsed)) {
+        throw new Error(`Invalid package.json at ${packageJsonPath}: missing or invalid version field`);
+    }
+    return parsed;
+}
+function extractVersion(packageJson, packageJsonPath) {
+    return parsePackageJson(packageJson, packageJsonPath).version;
+}
+function readPackageJson(packageJsonPath) {
+    try {
+        return readFileSync(packageJsonPath, 'utf8');
+    }
+    catch (error) {
+        throw new Error(`Unable to read ${packageJsonPath}: ${getErrorMessage(error)}`);
+    }
+}
+function loadVersion() {
+    const packageJsonPath = findPackageJSON(import.meta.url);
+    if (!packageJsonPath) {
+        throw new Error('Unable to locate package.json for code-review-analyst.');
+    }
+    return extractVersion(readPackageJson(packageJsonPath), packageJsonPath);
+}
+const SERVER_VERSION = loadVersion();
+function loadInstructions() {
+    const currentDir = dirname(fileURLToPath(import.meta.url));
+    try {
+        return readFileSync(join(currentDir, 'instructions.md'), 'utf8');
+    }
+    catch (error) {
+        process.emitWarning(`Failed to load instructions.md: ${getErrorMessage(error)}`);
+        return '(Instructions failed to load)';
+    }
+}
+const SERVER_INSTRUCTIONS = loadInstructions();
+const SERVER_TASK_STORE = new InMemoryTaskStore();
+export function createServer() {
+    const server = new McpServer({
+        name: 'code-review-analyst',
+        version: SERVER_VERSION,
+    }, {
+        instructions: SERVER_INSTRUCTIONS,
+        taskStore: SERVER_TASK_STORE,
+        capabilities: {
+            tasks: {
+                list: {},
+                cancel: {},
+                requests: {
+                    tools: {
+                        call: {},
+                    },
+                },
+            },
+        },
+    });
+    registerAllTools(server);
+    registerAllResources(server, SERVER_INSTRUCTIONS);
+    registerAllPrompts(server, SERVER_INSTRUCTIONS);
+    return server;
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerAllTools(server: McpServer): void;

package/dist/tools/index.js

@@ -0,0 +1,13 @@
+import { registerReviewDiffTool } from './review-diff.js';
+import { registerRiskScoreTool } from './risk-score.js';
+import { registerSuggestPatchTool } from './suggest-patch.js';
+const TOOL_REGISTRARS = [
+    registerReviewDiffTool,
+    registerRiskScoreTool,
+    registerSuggestPatchTool,
+];
+export function registerAllTools(server) {
+    for (const registerTool of TOOL_REGISTRARS) {
+        registerTool(server);
+    }
+}

package/dist/tools/review-diff.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerReviewDiffTool(server: McpServer): void;

package/dist/tools/review-diff.js

@@ -0,0 +1,41 @@
+import { validateDiffBudget } from '../lib/diff-budget.js';
+import { registerStructuredToolTask, } from '../lib/tool-factory.js';
+import { ReviewDiffInputSchema } from '../schemas/inputs.js';
+import { ReviewDiffResultSchema } from '../schemas/outputs.js';
+const DEFAULT_MAX_FINDINGS = 10;
+const DEFAULT_FOCUS_AREAS = 'security, correctness, regressions, performance';
+function buildReviewPrompt(input) {
+    const focus = input.focusAreas?.length
+        ? input.focusAreas.join(', ')
+        : DEFAULT_FOCUS_AREAS;
+    const maxFindings = input.maxFindings ?? DEFAULT_MAX_FINDINGS;
+    const systemInstruction = [
+        'You are a senior staff engineer performing pull request review.',
+        'Return strict JSON only with no markdown fences.',
+    ].join('\n');
+    const prompt = [
+        `Repository: ${input.repository}`,
+        `Primary language: ${input.language ?? 'not specified'}`,
+        `Focus areas: ${focus}`,
+        `Limit findings to ${maxFindings}.`,
+        'Prioritize concrete, high-confidence defects and risky behavior changes.',
+        'Include testsNeeded as short action items.',
+        '',
+        'Unified diff:',
+        input.diff,
+    ].join('\n');
+    return { systemInstruction, prompt };
+}
+export function registerReviewDiffTool(server) {
+    registerStructuredToolTask(server, {
+        name: 'review_diff',
+        title: 'Review Diff',
+        description: 'Analyze a code diff and return structured findings, risk level, and test recommendations.',
+        inputSchema: ReviewDiffInputSchema.shape,
+        fullInputSchema: ReviewDiffInputSchema,
+        resultSchema: ReviewDiffResultSchema,
+        validateInput: (input) => validateDiffBudget(input.diff),
+        errorCode: 'E_REVIEW_DIFF',
+        buildPrompt: buildReviewPrompt,
+    });
+}

package/dist/tools/risk-score.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerRiskScoreTool(server: McpServer): void;

package/dist/tools/risk-score.js

@@ -0,0 +1,33 @@
+import { validateDiffBudget } from '../lib/diff-budget.js';
+import { registerStructuredToolTask, } from '../lib/tool-factory.js';
+import { RiskScoreInputSchema } from '../schemas/inputs.js';
+import { RiskScoreResultSchema } from '../schemas/outputs.js';
+const DEFAULT_DEPLOYMENT_CRITICALITY = 'medium';
+function buildRiskPrompt(input) {
+    const systemInstruction = [
+        'You are assessing software deployment risk from a code diff.',
+        'Return strict JSON only, no markdown fences.',
+    ].join('\n');
+    const prompt = [
+        `Deployment criticality: ${input.deploymentCriticality ?? DEFAULT_DEPLOYMENT_CRITICALITY}`,
+        'Score guidance: 0 is no risk, 100 is severe risk.',
+        'Rationale must be concise, concrete, and evidence-based.',
+        '',
+        'Unified diff:',
+        input.diff,
+    ].join('\n');
+    return { systemInstruction, prompt };
+}
+export function registerRiskScoreTool(server) {
+    registerStructuredToolTask(server, {
+        name: 'risk_score',
+        title: 'Risk Score',
+        description: 'Score a diff from 0-100 and explain the key risk drivers for release decisions.',
+        inputSchema: RiskScoreInputSchema.shape,
+        fullInputSchema: RiskScoreInputSchema,
+        resultSchema: RiskScoreResultSchema,
+        validateInput: (input) => validateDiffBudget(input.diff),
+        errorCode: 'E_RISK_SCORE',
+        buildPrompt: buildRiskPrompt,
+    });
+}

package/dist/tools/suggest-patch.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerSuggestPatchTool(server: McpServer): void;

package/dist/tools/suggest-patch.js

@@ -0,0 +1,34 @@
+import { validateDiffBudget } from '../lib/diff-budget.js';
+import { registerStructuredToolTask, } from '../lib/tool-factory.js';
+import { SuggestPatchInputSchema } from '../schemas/inputs.js';
+import { PatchSuggestionResultSchema } from '../schemas/outputs.js';
+const DEFAULT_PATCH_STYLE = 'balanced';
+function buildPatchPrompt(input) {
+    const systemInstruction = [
+        'You are producing a corrective patch for a code review issue.',
+        'Return strict JSON only, no markdown fences.',
+    ].join('\n');
+    const prompt = [
+        `Patch style: ${input.patchStyle ?? DEFAULT_PATCH_STYLE}`,
+        `Finding title: ${input.findingTitle}`,
+        `Finding details: ${input.findingDetails}`,
+        'Patch output must be a valid unified diff snippet and avoid unrelated changes.',
+        '',
+        'Original unified diff:',
+        input.diff,
+    ].join('\n');
+    return { systemInstruction, prompt };
+}
+export function registerSuggestPatchTool(server) {
+    registerStructuredToolTask(server, {
+        name: 'suggest_patch',
+        title: 'Suggest Patch',
+        description: 'Generate a focused unified diff patch to address one selected review finding.',
+        inputSchema: SuggestPatchInputSchema.shape,
+        fullInputSchema: SuggestPatchInputSchema,
+        resultSchema: PatchSuggestionResultSchema,
+        validateInput: (input) => validateDiffBudget(input.diff),
+        errorCode: 'E_SUGGEST_PATCH',
+        buildPrompt: buildPatchPrompt,
+    });
+}

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@j0hanz/code-review-analyst-mcp",
+  "version": "0.1.0",
+  "mcpName": "io.github.j0hanz/code-review-analyst",
+  "description": "Gemini-powered MCP server for code review analysis.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "code-review-analyst-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "author": "j0hanz",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/j0hanz/code-review-analyst-mcp.git"
+  },
+  "homepage": "https://github.com/j0hanz/code-review-analyst-mcp#readme",
+  "engines": {
+    "node": ">=24"
+  },
+  "scripts": {
+    "clean": "node scripts/tasks.mjs clean",
+    "validate:instructions": "node scripts/tasks.mjs validate:instructions",
+    "build": "node scripts/tasks.mjs build",
+    "copy:assets": "node scripts/tasks.mjs copy:assets",
+    "prepare": "npm run build",
+    "dev": "tsc --watch --preserveWatchOutput",
+    "dev:run": "node --env-file=.env --watch dist/index.js",
+    "start": "node dist/index.js",
+    "format": "prettier --write .",
+    "type-check": "node scripts/tasks.mjs type-check",
+    "type-check:diagnostics": "tsc --noEmit --extendedDiagnostics",
+    "type-check:trace": "node -e \"require('fs').rmSync('.ts-trace',{recursive:true,force:true})\" && tsc --noEmit --generateTrace .ts-trace",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "test": "node scripts/tasks.mjs test",
+    "test:fast": "node --test --import tsx/esm src/__tests__/**/*.test.ts tests/**/*.test.ts",
+    "test:coverage": "node scripts/tasks.mjs test --coverage",
+    "knip": "knip",
+    "knip:fix": "knip --fix",
+    "inspector": "npm run build && npx -y @modelcontextprotocol/inspector node dist/index.js",
+    "prepublishOnly": "npm run lint && npm run type-check && npm run build"
+  },
+  "dependencies": {
+    "@google/genai": "^1.41.0",
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@trivago/prettier-plugin-sort-imports": "^6.0.2",
+    "@types/node": "^24",
+    "@typescript-eslint/eslint-plugin": "^8.56.0",
+    "@typescript-eslint/parser": "^8.56.0",
+    "eslint": "^9.39.2",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-de-morgan": "^2.0.0",
+    "eslint-plugin-depend": "^1.4.0",
+    "eslint-plugin-sonarjs": "^3.0.7",
+    "eslint-plugin-unused-imports": "^4.4.1",
+    "prettier": "^3.8.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.56.0"
+  }
+}