@j0hanz/code-assistant 0.9.0

package/dist/tools/generate-diff.js

@@ -0,0 +1,140 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { z } from 'zod';
+import { cleanDiff, computeDiffStatsFromFiles, DIFF_RESOURCE_URI, isEmptyDiff, NOISY_EXCLUDE_PATHSPECS, parseDiffFiles, storeDiff, } from '../lib/diff.js';
+import { wrapToolHandler } from '../lib/tools.js';
+import { createErrorToolResponse, createToolResponse } from '../lib/tools.js';
+import { DefaultOutputSchema } from '../schemas/outputs.js';
+const GIT_TIMEOUT_MS = 30_000;
+const GIT_MAX_BUFFER = 10 * 1024 * 1024; // 10 MB
+const MAX_GIT_ROOT_CACHE_SIZE = 50;
+const execFileAsync = promisify(execFile);
+const gitRootByCwd = new Map();
+async function findGitRoot(cwd = process.cwd()) {
+    const cached = gitRootByCwd.get(cwd);
+    if (cached) {
+        return cached;
+    }
+    const { stdout } = await execFileAsync('git', ['rev-parse', '--show-toplevel'], {
+        cwd,
+        encoding: 'utf8',
+    });
+    const gitRoot = stdout.trim();
+    cacheGitRoot(cwd, gitRoot);
+    return gitRoot;
+}
+function cacheGitRoot(cwd, gitRoot) {
+    if (gitRootByCwd.size >= MAX_GIT_ROOT_CACHE_SIZE) {
+        gitRootByCwd.clear();
+    }
+    gitRootByCwd.set(cwd, gitRoot);
+}
+function buildGitArgs(mode) {
+    const args = ['diff', '--no-color', '--no-ext-diff'];
+    if (mode === 'staged') {
+        args.push('--cached');
+    }
+    // '--' separates flags from pathspecs. Everything after it is a
+    // pathspec, never interpreted as a flag — prevents flag injection.
+    args.push('--', ...NOISY_EXCLUDE_PATHSPECS);
+    return args;
+}
+function describeModeHint(mode) {
+    return mode === 'staged'
+        ? 'staged with git add'
+        : 'modified but not yet staged (git add)';
+}
+function classifyGitError(err) {
+    if (err.code === 'ENOENT') {
+        return { retryable: false, kind: 'validation' };
+    }
+    if (err.killed === true) {
+        return { retryable: false, kind: 'timeout' };
+    }
+    if (typeof err.code === 'number') {
+        const stderr = err.stderr?.toLowerCase() ?? '';
+        if (stderr.includes('not a git repository') ||
+            stderr.includes('not a git repo')) {
+            return { retryable: false, kind: 'validation' };
+        }
+    }
+    return { retryable: false, kind: 'internal' };
+}
+function formatGitFailureMessage(err) {
+    if (typeof err.code === 'number') {
+        const stderr = err.stderr?.trim() ?? 'unknown error';
+        return `git exited with code ${String(err.code)}: ${stderr}. Ensure the working directory is a git repository.`;
+    }
+    return `Failed to run git: ${err.message}. Ensure git is installed and the working directory is a git repository.`;
+}
+async function runGitDiff(mode) {
+    const gitRoot = await findGitRoot();
+    const args = buildGitArgs(mode);
+    const { stdout } = await execFileAsync('git', args, {
+        cwd: gitRoot,
+        encoding: 'utf8',
+        maxBuffer: GIT_MAX_BUFFER,
+        timeout: GIT_TIMEOUT_MS,
+    });
+    return cleanDiff(stdout);
+}
+function buildGitErrorResponse(error) {
+    const err = error;
+    return createErrorToolResponse('E_GENERATE_DIFF', formatGitFailureMessage(err), undefined, classifyGitError(err));
+}
+async function generateDiffToolResponse(mode) {
+    try {
+        const diff = await runGitDiff(mode);
+        if (isEmptyDiff(diff)) {
+            return createNoChangesResponse(mode);
+        }
+        return createSuccessResponse(diff, mode);
+    }
+    catch (error) {
+        return buildGitErrorResponse(error);
+    }
+}
+function createNoChangesResponse(mode) {
+    return createErrorToolResponse('E_NO_CHANGES', `No ${mode} changes found in the current branch. Make sure you have changes that are ${describeModeHint(mode)}.`, undefined, { retryable: false, kind: 'validation' });
+}
+function createSuccessResponse(diff, mode) {
+    const parsedFiles = parseDiffFiles(diff);
+    const stats = computeDiffStatsFromFiles(parsedFiles);
+    const generatedAt = new Date().toISOString();
+    storeDiff({ diff, parsedFiles, stats, generatedAt, mode });
+    const summary = `Diff cached: ${stats.files} files (+${stats.added}, -${stats.deleted})`;
+    return createToolResponse({
+        ok: true,
+        result: {
+            diffRef: DIFF_RESOURCE_URI,
+            stats,
+            generatedAt,
+            mode,
+            message: summary,
+        },
+    }, summary);
+}
+export function registerGenerateDiffTool(server) {
+    server.registerTool('generate_diff', {
+        title: 'Generate Diff',
+        description: 'Generate a diff of the current branch working changes and cache it for all review tools. You MUST call this tool before calling any other review tool. Use "unstaged" for working-tree changes not yet staged, or "staged" for changes already added with git add.',
+        inputSchema: z.strictObject({
+            mode: z
+                .enum(['unstaged', 'staged'])
+                .describe('"unstaged": working-tree changes not yet staged. "staged": changes added to the index with git add.'),
+        }),
+        outputSchema: DefaultOutputSchema,
+        annotations: {
+            readOnlyHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+            destructiveHint: false,
+        },
+    }, wrapToolHandler({
+        toolName: 'generate_diff',
+        progressContext: (input) => input.mode,
+    }, async (input) => {
+        const { mode } = input;
+        return generateDiffToolResponse(mode);
+    }));
+}

package/dist/tools/generate-review-summary.d.ts

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

package/dist/tools/generate-review-summary.js

@@ -0,0 +1,71 @@
+import { formatLanguageSegment } from '../lib/format.js';
+import { getDiffContextSnapshot } from '../lib/tools.js';
+import { buildStructuredToolExecutionOptions, registerStructuredToolTask, requireToolContract, } from '../lib/tools.js';
+import { GenerateReviewSummaryInputSchema } from '../schemas/inputs.js';
+import { ReviewSummaryResultSchema } from '../schemas/outputs.js';
+const ReviewSummaryModelSchema = ReviewSummaryResultSchema.omit({
+    stats: true,
+});
+const TOOL_CONTRACT = requireToolContract('generate_review_summary');
+const SYSTEM_INSTRUCTION = `
+<role>
+Senior Code Reviewer.
+You are a pragmatic engineer focused on stability and maintainability.
+</role>
+
+<task>
+Summarize the pull request based on the diff:
+- Assess overall risk (low/medium/high).
+- Highlight key logic/behavior changes.
+- Recommend action: merge, squash, or block.
+</task>
+
+<constraints>
+- Focus on logic and behavior; ignore style, formatting, and typos.
+- Be concise and actionable.
+- Return valid JSON matching the schema.
+</constraints>
+`;
+export function registerGenerateReviewSummaryTool(server) {
+    registerStructuredToolTask(server, {
+        name: 'generate_review_summary',
+        title: 'Generate Review Summary',
+        description: 'Summarize diff and risk level. Prerequisite: generate_diff. Auto-infer repo/language.',
+        inputSchema: GenerateReviewSummaryInputSchema,
+        fullInputSchema: GenerateReviewSummaryInputSchema,
+        resultSchema: ReviewSummaryModelSchema,
+        errorCode: 'E_REVIEW_SUMMARY',
+        ...buildStructuredToolExecutionOptions(TOOL_CONTRACT),
+        requiresDiff: true,
+        progressContext: (input) => input.repository,
+        formatOutcome: (result) => `risk: ${result.overallRisk}`,
+        transformResult: (_input, result, ctx) => {
+            const { stats } = getDiffContextSnapshot(ctx);
+            return {
+                ...result,
+                stats: {
+                    filesChanged: stats.files,
+                    linesAdded: stats.added,
+                    linesRemoved: stats.deleted,
+                },
+            };
+        },
+        formatOutput: (result) => `${result.summary}\nRecommendation: ${result.recommendation}`,
+        buildPrompt: (input, ctx) => {
+            const { diff, stats } = getDiffContextSnapshot(ctx);
+            const languageSegment = formatLanguageSegment(input.language);
+            return {
+                systemInstruction: SYSTEM_INSTRUCTION,
+                prompt: `
+Repository: ${input.repository}${languageSegment}
+Stats: ${stats.files} files, +${stats.added}, -${stats.deleted}
+
+Diff:
+${diff}
+
+Based on the diff and stats above, summarize the PR and provide a merge recommendation.
+`,
+            };
+        },
+    });
+}

package/dist/tools/generate-test-plan.d.ts

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

package/dist/tools/generate-test-plan.js

@@ -0,0 +1,67 @@
+import { computeDiffStatsAndPathsFromFiles } from '../lib/diff.js';
+import { formatOptionalLines } from '../lib/format.js';
+import { getDiffContextSnapshot } from '../lib/tools.js';
+import { buildStructuredToolExecutionOptions, registerStructuredToolTask, requireToolContract, } from '../lib/tools.js';
+import { GenerateTestPlanInputSchema } from '../schemas/inputs.js';
+import { TestPlanResultSchema } from '../schemas/outputs.js';
+const SYSTEM_INSTRUCTION = `
+<role>
+QA Automation Architect.
+You are an expert in test strategy and coverage analysis.
+</role>
+
+<task>
+Generate a prioritized test plan for the provided diff:
+- Focus on negative cases, edge cases, and boundary conditions.
+- Target branch coverage and integration points.
+</task>
+
+<constraints>
+- Focus on observable behavior changes.
+- Ignore internal refactors that do not affect contract.
+- Return valid JSON matching the schema.
+</constraints>
+`;
+const TOOL_CONTRACT = requireToolContract('generate_test_plan');
+export function registerGenerateTestPlanTool(server) {
+    registerStructuredToolTask(server, {
+        name: 'generate_test_plan',
+        title: 'Generate Test Plan',
+        description: 'Generate test cases. Prerequisite: generate_diff. Auto-infer repo/language/framework.',
+        inputSchema: GenerateTestPlanInputSchema,
+        fullInputSchema: GenerateTestPlanInputSchema,
+        resultSchema: TestPlanResultSchema,
+        errorCode: 'E_GENERATE_TEST_PLAN',
+        ...buildStructuredToolExecutionOptions(TOOL_CONTRACT),
+        requiresDiff: true,
+        progressContext: (input) => input.repository,
+        formatOutcome: (result) => `${result.testCases.length} test cases`,
+        formatOutput: (result) => `${result.summary}\n${result.testCases.length} test cases.`,
+        transformResult: (input, result) => {
+            const cappedTestCases = result.testCases.slice(0, input.maxTestCases ?? result.testCases.length);
+            return { ...result, testCases: cappedTestCases };
+        },
+        buildPrompt: (input, ctx) => {
+            const { diff, parsedFiles } = getDiffContextSnapshot(ctx);
+            const { stats, paths } = computeDiffStatsAndPathsFromFiles(parsedFiles);
+            const optionalLines = formatOptionalLines([
+                { label: 'Language', value: input.language },
+                { label: 'Test Framework', value: input.testFramework },
+                { label: 'Max Test Cases', value: input.maxTestCases },
+            ]);
+            return {
+                systemInstruction: SYSTEM_INSTRUCTION,
+                prompt: `
+Repository: ${input.repository}${optionalLines}
+Stats: ${stats.files} files, +${stats.added}, -${stats.deleted}
+Changed Files: ${paths.join(', ')}
+
+Diff:
+${diff}
+
+Based on the diff and stats above, generate an actionable test plan.
+`,
+            };
+        },
+    });
+}

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,19 @@
+import { registerAnalyzeComplexityTool } from './analyze-complexity.js';
+import { registerAnalyzePrImpactTool } from './analyze-pr-impact.js';
+import { registerDetectApiBreakingTool } from './detect-api-breaking.js';
+import { registerGenerateDiffTool } from './generate-diff.js';
+import { registerGenerateReviewSummaryTool } from './generate-review-summary.js';
+import { registerGenerateTestPlanTool } from './generate-test-plan.js';
+const TOOL_REGISTRARS = [
+    registerGenerateDiffTool,
+    registerAnalyzePrImpactTool,
+    registerGenerateReviewSummaryTool,
+    registerGenerateTestPlanTool,
+    registerAnalyzeComplexityTool,
+    registerDetectApiBreakingTool,
+];
+export function registerAllTools(server) {
+    for (const registrar of TOOL_REGISTRARS) {
+        registrar(server);
+    }
+}

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@j0hanz/code-assistant",
+  "version": "0.9.0",
+  "mcpName": "io.github.j0hanz/code-assistant",
+  "description": "Gemini-powered MCP server for code 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-assistant-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "author": "j0hanz",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/j0hanz/code-assistant.git"
+  },
+  "homepage": "https://github.com/j0hanz/code-assistant#readme",
+  "scripts": {
+    "clean": "node scripts/tasks.mjs clean",
+    "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:src": "node node_modules/typescript/bin/tsc -p tsconfig.json --noEmit",
+    "type-check:tests": "node node_modules/typescript/bin/tsc -p tsconfig.test.json --noEmit",
+    "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:tests": "eslint src/__tests__",
+    "lint:fix": "eslint . --fix",
+    "test": "node scripts/tasks.mjs test",
+    "test:fast": "node --test --import tsx/esm src/__tests__/**/*.test.ts node-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.43.0",
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "parse-diff": "^0.11.1",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@trivago/prettier-plugin-sort-imports": "^6.0.2",
+    "@types/node": "^24",
+    "eslint": "^10.0.2",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-de-morgan": "^2.1.1",
+    "eslint-plugin-depend": "^1.4.0",
+    "eslint-plugin-unused-imports": "^4.4.1",
+    "knip": "^5.85.0",
+    "prettier": "^3.8.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.56.1"
+  },
+  "engines": {
+    "node": ">=24"
+  }
+}