@j0hanz/code-review-analyst-mcp 1.2.1 → 1.4.0

package/dist/index.js

@@ -6,6 +6,11 @@ import { createServer } from './server.js';
 const SHUTDOWN_SIGNALS = ['SIGINT', 'SIGTERM'];
 const ARG_OPTION_MODEL = 'model';
 const ARG_OPTION_MAX_DIFF_CHARS = 'max-diff-chars';
+const PROCESS_ARGS_START_INDEX = 2;
+const CLI_ENV_MAPPINGS = [
+    { option: ARG_OPTION_MODEL, envVar: 'GEMINI_MODEL' },
+    { option: ARG_OPTION_MAX_DIFF_CHARS, envVar: 'MAX_DIFF_CHARS' },
+];
 const CLI_OPTIONS = {
     [ARG_OPTION_MODEL]: {
         type: 'string',
@@ -20,14 +25,18 @@ function setStringEnv(name, value) {
         process.env[name] = value;
     }
 }
+function applyCliEnvironmentOverrides(values) {
+    for (const mapping of CLI_ENV_MAPPINGS) {
+        setStringEnv(mapping.envVar, values[mapping.option]);
+    }
+}
 function parseCommandLineArgs() {
     const { values } = parseArgs({
-        args: process.argv.slice(2),
+        args: process.argv.slice(PROCESS_ARGS_START_INDEX),
         options: CLI_OPTIONS,
         strict: false,
     });
-    setStringEnv('GEMINI_MODEL', values[ARG_OPTION_MODEL]);
-    setStringEnv('MAX_DIFF_CHARS', values[ARG_OPTION_MAX_DIFF_CHARS]);
+    applyCliEnvironmentOverrides(values);
 }
 let shuttingDown = false;
 async function shutdown(server) {

package/dist/lib/context-budget.d.ts

@@ -3,6 +3,6 @@ interface FileContent {
     content: string;
 }
 export declare function resetMaxContextCharsCacheForTesting(): void;
-export declare function computeContextSize(diff: string, files?: FileContent[]): number;
-export declare function validateContextBudget(diff: string, files?: FileContent[]): ReturnType<typeof createErrorToolResponse> | undefined;
+export declare function computeContextSize(diff: string, files?: readonly FileContent[]): number;
+export declare function validateContextBudget(diff: string, files?: readonly FileContent[]): ReturnType<typeof createErrorToolResponse> | undefined;
 export {};

package/dist/lib/context-budget.js

@@ -4,6 +4,16 @@ const DEFAULT_MAX_CONTEXT_CHARS = 500_000;
 const MAX_CONTEXT_CHARS_ENV_VAR = 'MAX_CONTEXT_CHARS';
 const BUDGET_ERROR_META = { retryable: false, kind: 'budget' };
 const contextCharsConfig = createCachedEnvInt(MAX_CONTEXT_CHARS_ENV_VAR, DEFAULT_MAX_CONTEXT_CHARS);
+function computeFilesSize(files) {
+    let fileSize = 0;
+    for (const file of files) {
+        fileSize += file.content.length;
+    }
+    return fileSize;
+}
+function createContextBudgetMessage(size, max) {
+    return `Combined context size ${size} chars exceeds limit of ${max} chars.`;
+}
 export function resetMaxContextCharsCacheForTesting() {
     contextCharsConfig.reset();
 }
@@ -14,17 +24,13 @@ export function computeContextSize(diff, files) {
     if (!files || files.length === 0) {
         return diff.length;
     }
-    let fileSize = 0;
-    for (const file of files) {
-        fileSize += file.content.length;
-    }
-    return diff.length + fileSize;
+    return diff.length + computeFilesSize(files);
 }
 export function validateContextBudget(diff, files) {
     const size = computeContextSize(diff, files);
     const max = getMaxContextChars();
     if (size > max) {
-        return createErrorToolResponse('E_INPUT_TOO_LARGE', `Combined context size ${size} chars exceeds limit of ${max} chars.`, { providedChars: size, maxChars: max }, BUDGET_ERROR_META);
+        return createErrorToolResponse('E_INPUT_TOO_LARGE', createContextBudgetMessage(size, max), { providedChars: size, maxChars: max }, BUDGET_ERROR_META);
     }
     return undefined;
 }

package/dist/lib/diff-budget.js

@@ -11,7 +11,8 @@ export function resetMaxDiffCharsCacheForTesting() {
     diffCharsConfig.reset();
 }
 export function exceedsDiffBudget(diff) {
-    return diff.length > getMaxDiffChars();
+    const maxChars = getMaxDiffChars();
+    return getDiffLength(diff) > maxChars;
 }
 function formatDiffBudgetError(diffLength, maxChars) {
     return `diff exceeds max allowed size (${numberFormatter.format(diffLength)} chars > ${numberFormatter.format(maxChars)} chars)`;
@@ -20,8 +21,11 @@ export function getDiffBudgetError(diffLength, maxChars = getMaxDiffChars()) {
     return formatDiffBudgetError(diffLength, maxChars);
 }
 const BUDGET_ERROR_META = { retryable: false, kind: 'budget' };
+function getDiffLength(diff) {
+    return diff.length;
+}
 export function validateDiffBudget(diff) {
-    const providedChars = diff.length;
+    const providedChars = getDiffLength(diff);
     const maxChars = getMaxDiffChars();
     if (providedChars <= maxChars) {
         return undefined;

package/dist/lib/diff-cleaner.d.ts

@@ -0,0 +1,12 @@
+export declare const NOISY_EXCLUDE_PATHSPECS: readonly [":(exclude)package-lock.json", ":(exclude)yarn.lock", ":(exclude)pnpm-lock.yaml", ":(exclude)bun.lockb", ":(exclude)*.lock", ":(exclude)dist/", ":(exclude)build/", ":(exclude)out/", ":(exclude).next/", ":(exclude)coverage/", ":(exclude)*.min.js", ":(exclude)*.min.css", ":(exclude)*.map"];
+/**
+ * Split raw unified diff into per-file sections and strip:
+ * - Binary file sections ("Binary files a/... and b/... differ")
+ * - GIT binary patch sections
+ * - Mode-only sections (permission changes with no content hunks)
+ *
+ * Does NOT modify content lines (+ / - / space) to preserve verbatim
+ * accuracy required by suggest_search_replace.
+ */
+export declare function cleanDiff(raw: string): string;
+export declare function isEmptyDiff(diff: string): boolean;

package/dist/lib/diff-cleaner.js

@@ -0,0 +1,51 @@
+export const NOISY_EXCLUDE_PATHSPECS = [
+    ':(exclude)package-lock.json',
+    ':(exclude)yarn.lock',
+    ':(exclude)pnpm-lock.yaml',
+    ':(exclude)bun.lockb',
+    ':(exclude)*.lock',
+    ':(exclude)dist/',
+    ':(exclude)build/',
+    ':(exclude)out/',
+    ':(exclude).next/',
+    ':(exclude)coverage/',
+    ':(exclude)*.min.js',
+    ':(exclude)*.min.css',
+    ':(exclude)*.map',
+];
+// Regex patterns to identify noisy diff file sections.
+const BINARY_FILE_LINE = /^Binary files .+ differ$/m;
+const GIT_BINARY_PATCH = /^GIT binary patch/m;
+const HAS_HUNK = /^@@/m;
+const HAS_OLD_MODE = /^old mode /m;
+/**
+ * Split raw unified diff into per-file sections and strip:
+ * - Binary file sections ("Binary files a/... and b/... differ")
+ * - GIT binary patch sections
+ * - Mode-only sections (permission changes with no content hunks)
+ *
+ * Does NOT modify content lines (+ / - / space) to preserve verbatim
+ * accuracy required by suggest_search_replace.
+ */
+export function cleanDiff(raw) {
+    if (!raw)
+        return '';
+    // Split on the start of each "diff --git" header, keeping the header.
+    const sections = raw.split(/(?=^diff --git )/m);
+    const cleaned = sections.filter((section) => {
+        if (!section.trim())
+            return false;
+        if (BINARY_FILE_LINE.test(section))
+            return false;
+        if (GIT_BINARY_PATCH.test(section))
+            return false;
+        // Drop mode-only sections that have no actual content hunks.
+        if (HAS_OLD_MODE.test(section) && !HAS_HUNK.test(section))
+            return false;
+        return true;
+    });
+    return cleaned.join('').trim();
+}
+export function isEmptyDiff(diff) {
+    return diff.trim().length === 0;
+}

package/dist/lib/diff-parser.js

@@ -12,7 +12,6 @@ export function parseDiffFiles(diff) {
     return parseDiff(diff);
 }
 function cleanPath(path) {
-    // Common git diff prefixes
     if (path.startsWith('a/') || path.startsWith('b/')) {
         return path.slice(2);
     }
@@ -33,28 +32,40 @@ function sortPaths(paths) {
     }
     return Array.from(paths).sort(PATH_SORTER);
 }
-export function computeDiffStatsAndSummaryFromFiles(files) {
-    if (files.length === 0) {
-        return {
-            stats: EMPTY_STATS,
-            summary: NO_FILES_CHANGED,
-        };
-    }
+function buildDiffComputation(files) {
     let added = 0;
     let deleted = 0;
+    const paths = new Set();
     const summaries = new Array(files.length);
     let index = 0;
     for (const file of files) {
         added += file.additions;
         deleted += file.deletions;
         const path = resolveChangedPath(file);
+        if (path) {
+            paths.add(path);
+        }
         summaries[index] =
             `${path ?? UNKNOWN_PATH} (+${file.additions} -${file.deletions})`;
         index += 1;
     }
+    return { added, deleted, paths, summaries };
+}
+function buildStats(filesCount, added, deleted) {
+    return { files: filesCount, added, deleted };
+}
+export function computeDiffStatsAndSummaryFromFiles(files) {
+    if (files.length === 0) {
+        return {
+            stats: EMPTY_STATS,
+            summary: NO_FILES_CHANGED,
+        };
+    }
+    const computed = buildDiffComputation(files);
+    const stats = buildStats(files.length, computed.added, computed.deleted);
     return {
-        stats: { files: files.length, added, deleted },
-        summary: `${summaries.join(', ')} [${files.length} files, +${added} -${deleted}]`,
+        stats,
+        summary: `${computed.summaries.join(', ')} [${stats.files} files, +${stats.added} -${stats.deleted}]`,
     };
 }
 export function computeDiffStatsAndPathsFromFiles(files) {
@@ -64,45 +75,29 @@ export function computeDiffStatsAndPathsFromFiles(files) {
             paths: EMPTY_PATHS,
         };
     }
-    let added = 0;
-    let deleted = 0;
-    const paths = new Set();
-    for (const file of files) {
-        added += file.additions;
-        deleted += file.deletions;
-        const path = resolveChangedPath(file);
-        if (path) {
-            paths.add(path);
-        }
-    }
+    const computed = buildDiffComputation(files);
     return {
-        stats: { files: files.length, added, deleted },
-        paths: sortPaths(paths),
+        stats: buildStats(files.length, computed.added, computed.deleted),
+        paths: sortPaths(computed.paths),
     };
 }
 /** Extract all unique changed file paths (renamed: returns new path). */
 export function extractChangedPathsFromFiles(files) {
-    const paths = new Set();
-    for (const file of files) {
-        const path = resolveChangedPath(file);
-        if (path) {
-            paths.add(path);
-        }
+    if (files.length === 0) {
+        return EMPTY_PATHS;
     }
-    return sortPaths(paths);
+    return sortPaths(buildDiffComputation(files).paths);
 }
 /** Extract all unique changed file paths (renamed: returns new path). */
 export function extractChangedPaths(diff) {
     return extractChangedPathsFromFiles(parseDiffFiles(diff));
 }
 export function computeDiffStatsFromFiles(files) {
-    let added = 0;
-    let deleted = 0;
-    for (const file of files) {
-        added += file.additions;
-        deleted += file.deletions;
+    if (files.length === 0) {
+        return EMPTY_STATS;
     }
-    return { files: files.length, added, deleted };
+    const computed = buildDiffComputation(files);
+    return buildStats(files.length, computed.added, computed.deleted);
 }
 /** Count changed files, added lines, and deleted lines. */
 export function computeDiffStats(diff) {

package/dist/lib/diff-store.d.ts

@@ -0,0 +1,22 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { createErrorToolResponse } from './tool-response.js';
+export declare const DIFF_RESOURCE_URI = "diff://current";
+export interface DiffStats {
+    files: number;
+    added: number;
+    deleted: number;
+}
+export interface DiffSlot {
+    diff: string;
+    stats: DiffStats;
+    generatedAt: string;
+    mode: string;
+}
+/** Call once during server setup so the store can emit resource-updated notifications. */
+export declare function initDiffStore(server: McpServer): void;
+export declare function storeDiff(data: DiffSlot): void;
+export declare function getDiff(): DiffSlot | undefined;
+export declare function hasDiff(): boolean;
+/** Test-only: directly set or clear the diff slot without emitting resource-updated. */
+export declare function setDiffForTesting(data: DiffSlot | undefined): void;
+export declare function createNoDiffError(): ReturnType<typeof createErrorToolResponse>;

package/dist/lib/diff-store.js

@@ -0,0 +1,28 @@
+import { createErrorToolResponse } from './tool-response.js';
+export const DIFF_RESOURCE_URI = 'diff://current';
+let slot;
+let sendResourceUpdated;
+/** Call once during server setup so the store can emit resource-updated notifications. */
+export function initDiffStore(server) {
+    const inner = server.server;
+    sendResourceUpdated = inner.sendResourceUpdated.bind(inner);
+}
+export function storeDiff(data) {
+    slot = data;
+    void sendResourceUpdated?.({ uri: DIFF_RESOURCE_URI }).catch(() => {
+        // Notification is best-effort; never block the tool response.
+    });
+}
+export function getDiff() {
+    return slot;
+}
+export function hasDiff() {
+    return slot !== undefined;
+}
+/** Test-only: directly set or clear the diff slot without emitting resource-updated. */
+export function setDiffForTesting(data) {
+    slot = data;
+}
+export function createNoDiffError() {
+    return createErrorToolResponse('E_NO_DIFF', 'No diff cached. You must call the generate_diff tool before using any review tool. Run generate_diff with mode="unstaged" or mode="staged" to capture the current branch changes, then retry this tool.', undefined, { retryable: false, kind: 'validation' });
+}

package/dist/lib/env-config.d.ts

@@ -2,4 +2,5 @@ export interface CachedEnvInt {
     get(): number;
     reset(): void;
 }
+/** Creates a cached integer value from an environment variable, with a default fallback. */
 export declare function createCachedEnvInt(envVar: string, defaultValue: number): CachedEnvInt;

package/dist/lib/env-config.js

@@ -1,11 +1,18 @@
 function parsePositiveInteger(value) {
+    if (value.length === 0) {
+        return undefined;
+    }
     const parsed = Number.parseInt(value, 10);
     if (Number.isNaN(parsed) || parsed <= 0) {
         return undefined;
     }
     return parsed;
 }
-/// Creates a cached integer value from an environment variable, with a default fallback.
+function resolveEnvInt(envVar, defaultValue) {
+    const envValue = process.env[envVar] ?? '';
+    return parsePositiveInteger(envValue) ?? defaultValue;
+}
+/** Creates a cached integer value from an environment variable, with a default fallback. */
 export function createCachedEnvInt(envVar, defaultValue) {
     let cached;
     return {
@@ -13,8 +20,7 @@ export function createCachedEnvInt(envVar, defaultValue) {
             if (cached !== undefined) {
                 return cached;
             }
-            const envValue = process.env[envVar] ?? '';
-            cached = parsePositiveInteger(envValue) ?? defaultValue;
+            cached = resolveEnvInt(envVar, defaultValue);
             return cached;
         },
         reset() {

package/dist/lib/errors.d.ts

@@ -1,2 +1,3 @@
+/** Matches transient upstream provider failures that are typically safe to retry. */
 export declare const RETRYABLE_UPSTREAM_ERROR_PATTERN: RegExp;
 export declare function getErrorMessage(error: unknown): string;

package/dist/lib/errors.js

@@ -1,11 +1,11 @@
 import { inspect } from 'node:util';
-/// Guides for using specific tools in code review analysis.
+/** Matches transient upstream provider failures that are typically safe to retry. */
 export const RETRYABLE_UPSTREAM_ERROR_PATTERN = /(429|500|502|503|504|rate.?limit|quota|overload|unavailable|gateway|timeout|timed.out|connection|reset|econn|enotfound|temporary|transient|invalid.json)/i;
-function isString(value) {
-    return typeof value === 'string';
+function isObjectRecord(value) {
+    return typeof value === 'object' && value !== null;
 }
 function hasStringProperty(value, key) {
-    if (typeof value !== 'object' || value === null || !(key in value)) {
+    if (!isObjectRecord(value) || !(key in value)) {
         return false;
     }
     const record = value;
@@ -15,7 +15,7 @@ export function getErrorMessage(error) {
     if (hasStringProperty(error, 'message')) {
         return error.message;
     }
-    if (isString(error)) {
+    if (typeof error === 'string') {
         return error;
     }
     return inspect(error, { depth: 3, breakLength: 120 });

package/dist/lib/gemini-schema.js

@@ -39,8 +39,9 @@ function stripConstraintValue(value) {
 export function stripJsonSchemaConstraints(schema) {
     const result = {};
     for (const [key, value] of Object.entries(schema)) {
-        if (CONSTRAINT_KEYS.has(key))
+        if (CONSTRAINT_KEYS.has(key)) {
             continue;
+        }
         // Relax integer → number so Gemini is not forced into integer-only
         // output; the stricter result schema still validates integrality.
         if (key === 'type' && value === INTEGER_JSON_TYPE) {