@j0hanz/code-review-analyst-mcp 1.5.3 → 1.6.1

package/dist/index.js

@@ -1,43 +1,9 @@
 #!/usr/bin/env node
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { parseArgs } from 'node:util';
+import { parseCommandLineArgs } from './lib/cli.js';
 import { getErrorMessage } from './lib/errors.js';
 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',
-        short: 'm',
-    },
-    [ARG_OPTION_MAX_DIFF_CHARS]: {
-        type: 'string',
-    },
-};
-function setStringEnv(name, value) {
-    if (typeof value === 'string') {
-        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(PROCESS_ARGS_START_INDEX),
-        options: CLI_OPTIONS,
-        strict: false,
-    });
-    applyCliEnvironmentOverrides(values);
-}
 let shuttingDown = false;
 async function shutdown(server) {
     if (shuttingDown) {

package/dist/lib/cli.d.ts

@@ -0,0 +1 @@
+export declare function parseCommandLineArgs(): void;

package/dist/lib/cli.js

@@ -0,0 +1,35 @@
+import { parseArgs } from 'node:util';
+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',
+        short: 'm',
+    },
+    [ARG_OPTION_MAX_DIFF_CHARS]: {
+        type: 'string',
+    },
+};
+function setStringEnv(name, value) {
+    if (typeof value === 'string') {
+        process.env[name] = value;
+    }
+}
+function applyCliEnvironmentOverrides(values) {
+    for (const mapping of CLI_ENV_MAPPINGS) {
+        setStringEnv(mapping.envVar, values[mapping.option]);
+    }
+}
+export function parseCommandLineArgs() {
+    const { values } = parseArgs({
+        args: process.argv.slice(PROCESS_ARGS_START_INDEX),
+        options: CLI_OPTIONS,
+        strict: false,
+    });
+    applyCliEnvironmentOverrides(values);
+}

package/dist/lib/context-budget.js

@@ -5,11 +5,11 @@ 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;
+    let total = 0;
     for (const file of files) {
-        fileSize += file.content.length;
+        total += file.content.length;
     }
-    return fileSize;
+    return total;
 }
 function createContextBudgetMessage(size, max) {
     return `Combined context size ${size} chars exceeds limit of ${max} chars.`;

package/dist/lib/diff-budget.js

@@ -12,7 +12,7 @@ export function resetMaxDiffCharsCacheForTesting() {
 }
 export function exceedsDiffBudget(diff) {
     const maxChars = getMaxDiffChars();
-    return getDiffLength(diff) > maxChars;
+    return diff.length > maxChars;
 }
 function formatDiffBudgetError(diffLength, maxChars) {
     return `diff exceeds max allowed size (${numberFormatter.format(diffLength)} chars > ${numberFormatter.format(maxChars)} chars)`;
@@ -21,14 +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 = getDiffLength(diff);
+    const providedChars = diff.length;
     const maxChars = getMaxDiffChars();
     if (providedChars <= maxChars) {
         return undefined;
     }
-    return createErrorToolResponse('E_INPUT_TOO_LARGE', formatDiffBudgetError(providedChars, maxChars), { providedChars, maxChars }, BUDGET_ERROR_META);
+    return createErrorToolResponse('E_INPUT_TOO_LARGE', getDiffBudgetError(providedChars, maxChars), { providedChars, maxChars }, BUDGET_ERROR_META);
 }

package/dist/lib/diff-cleaner.js

@@ -18,6 +18,29 @@ 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;
+function shouldKeepSection(section) {
+    if (!section.trim()) {
+        return false;
+    }
+    if (BINARY_FILE_LINE.test(section)) {
+        return false;
+    }
+    if (GIT_BINARY_PATCH.test(section)) {
+        return false;
+    }
+    if (HAS_OLD_MODE.test(section) && !HAS_HUNK.test(section)) {
+        return false;
+    }
+    return true;
+}
+function processSection(raw, start, end, sections) {
+    if (end > start) {
+        const section = raw.slice(start, end);
+        if (shouldKeepSection(section)) {
+            sections.push(section);
+        }
+    }
+}
 /**
  * Split raw unified diff into per-file sections and strip:
  * - Binary file sections ("Binary files a/... and b/... differ")
@@ -30,21 +53,23 @@ const HAS_OLD_MODE = /^old mode /m;
 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();
+    const sections = [];
+    let lastIndex = 0;
+    let nextIndex = raw.startsWith('diff --git ')
+        ? 0
+        : raw.indexOf('\ndiff --git ');
+    if (nextIndex === -1) {
+        processSection(raw, 0, raw.length, sections);
+        return sections.join('').trim();
+    }
+    while (nextIndex !== -1) {
+        const matchIndex = nextIndex === 0 ? 0 : nextIndex + 1; // +1 to skip \n
+        processSection(raw, lastIndex, matchIndex, sections);
+        lastIndex = matchIndex;
+        nextIndex = raw.indexOf('\ndiff --git ', lastIndex);
+    }
+    processSection(raw, lastIndex, raw.length, sections);
+    return sections.join('').trim();
 }
 export function isEmptyDiff(diff) {
     return diff.trim().length === 0;

package/dist/lib/diff-parser.js

@@ -6,10 +6,7 @@ const EMPTY_STATS = Object.freeze({ files: 0, added: 0, deleted: 0 });
 const PATH_SORTER = (left, right) => left.localeCompare(right);
 /** Parse unified diff string into structured file list. */
 export function parseDiffFiles(diff) {
-    if (!diff) {
-        return [];
-    }
-    return parseDiff(diff);
+    return diff ? parseDiff(diff) : [];
 }
 function cleanPath(path) {
     if (path.startsWith('a/') || path.startsWith('b/')) {
@@ -27,43 +24,26 @@ function resolveChangedPath(file) {
     return undefined;
 }
 function sortPaths(paths) {
-    if (paths.size === 0) {
-        return EMPTY_PATHS;
-    }
     return Array.from(paths).sort(PATH_SORTER);
 }
-function buildDiffComputation(files, options) {
+function calculateStats(files) {
     let added = 0;
     let deleted = 0;
-    const paths = options.needPaths ? new Set() : undefined;
-    const summaries = options.needSummaries
-        ? new Array(files.length)
-        : undefined;
-    let index = 0;
     for (const file of files) {
         added += file.additions;
         deleted += file.deletions;
-        if (options.needPaths || options.needSummaries) {
-            const path = resolveChangedPath(file);
-            if (paths && path) {
-                paths.add(path);
-            }
-            if (summaries) {
-                summaries[index] =
-                    `${path ?? UNKNOWN_PATH} (+${file.additions} -${file.deletions})`;
-            }
-        }
-        index += 1;
     }
-    return {
-        added,
-        deleted,
-        paths: paths ?? new Set(),
-        summaries: summaries ?? [],
-    };
+    return { files: files.length, added, deleted };
 }
-function buildStats(filesCount, added, deleted) {
-    return { files: filesCount, added, deleted };
+function getUniquePaths(files) {
+    const paths = new Set();
+    for (const file of files) {
+        const path = resolveChangedPath(file);
+        if (path) {
+            paths.add(path);
+        }
+    }
+    return paths;
 }
 export function computeDiffStatsAndSummaryFromFiles(files) {
     if (files.length === 0) {
@@ -72,14 +52,27 @@ export function computeDiffStatsAndSummaryFromFiles(files) {
             summary: NO_FILES_CHANGED,
         };
     }
-    const computed = buildDiffComputation(files, {
-        needPaths: false,
-        needSummaries: true,
-    });
-    const stats = buildStats(files.length, computed.added, computed.deleted);
+    let added = 0;
+    let deleted = 0;
+    const summaries = [];
+    const MAX_SUMMARY_FILES = 40;
+    let i = 0;
+    for (const file of files) {
+        added += file.additions;
+        deleted += file.deletions;
+        if (i < MAX_SUMMARY_FILES) {
+            const path = resolveChangedPath(file) ?? UNKNOWN_PATH;
+            summaries.push(`${path} (+${file.additions} -${file.deletions})`);
+        }
+        i++;
+    }
+    if (files.length > MAX_SUMMARY_FILES) {
+        summaries.push(`... and ${files.length - MAX_SUMMARY_FILES} more files`);
+    }
+    const stats = { files: files.length, added, deleted };
     return {
         stats,
-        summary: `${computed.summaries.join(', ')} [${stats.files} files, +${stats.added} -${stats.deleted}]`,
+        summary: `${summaries.join(', ')} [${stats.files} files, +${stats.added} -${stats.deleted}]`,
     };
 }
 export function computeDiffStatsAndPathsFromFiles(files) {
@@ -89,13 +82,11 @@ export function computeDiffStatsAndPathsFromFiles(files) {
             paths: EMPTY_PATHS,
         };
     }
-    const computed = buildDiffComputation(files, {
-        needPaths: true,
-        needSummaries: false,
-    });
+    const stats = calculateStats(files);
+    const paths = sortPaths(getUniquePaths(files));
     return {
-        stats: buildStats(files.length, computed.added, computed.deleted),
-        paths: sortPaths(computed.paths),
+        stats,
+        paths,
     };
 }
 /** Extract all unique changed file paths (renamed: returns new path). */
@@ -103,7 +94,7 @@ export function extractChangedPathsFromFiles(files) {
     if (files.length === 0) {
         return EMPTY_PATHS;
     }
-    return sortPaths(buildDiffComputation(files, { needPaths: true, needSummaries: false }).paths);
+    return sortPaths(getUniquePaths(files));
 }
 /** Extract all unique changed file paths (renamed: returns new path). */
 export function extractChangedPaths(diff) {
@@ -113,11 +104,7 @@ export function computeDiffStatsFromFiles(files) {
     if (files.length === 0) {
         return EMPTY_STATS;
     }
-    const computed = buildDiffComputation(files, {
-        needPaths: false,
-        needSummaries: false,
-    });
-    return buildStats(files.length, computed.added, computed.deleted);
+    return calculateStats(files);
 }
 /** Count changed files, added lines, and deleted lines. */
 export function computeDiffStats(diff) {

package/dist/lib/diff-store.js

@@ -1,32 +1,54 @@
+import { createCachedEnvInt } from './env-config.js';
 import { createErrorToolResponse } from './tool-response.js';
 export const DIFF_RESOURCE_URI = 'diff://current';
+const diffCacheTtlMs = createCachedEnvInt('DIFF_CACHE_TTL_MS', 60 * 60 * 1_000 // 1 hour default
+);
 const diffSlots = new Map();
 let sendResourceUpdated;
+function setDiffSlot(key, data) {
+    if (data) {
+        diffSlots.set(key, data);
+        return;
+    }
+    diffSlots.delete(key);
+}
+function notifyDiffUpdated() {
+    void sendResourceUpdated?.({ uri: DIFF_RESOURCE_URI }).catch(() => {
+        // Ignore errors sending resource-updated, which can happen if the server is not fully initialized yet.
+    });
+}
 /** 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);
+    if (typeof inner?.sendResourceUpdated === 'function') {
+        sendResourceUpdated = inner.sendResourceUpdated.bind(inner);
+    }
+    else {
+        console.error('[diff-store] sendResourceUpdated not available — diff resource notifications disabled.');
+    }
 }
 export function storeDiff(data, key = process.cwd()) {
-    diffSlots.set(key, data);
-    void sendResourceUpdated?.({ uri: DIFF_RESOURCE_URI }).catch(() => {
-        // Ignore errors sending resource-updated, which can happen if the server is not fully initialized yet.
-    });
+    setDiffSlot(key, data);
+    notifyDiffUpdated();
 }
 export function getDiff(key = process.cwd()) {
-    return diffSlots.get(key);
+    const slot = diffSlots.get(key);
+    if (!slot) {
+        return undefined;
+    }
+    const age = Date.now() - new Date(slot.generatedAt).getTime();
+    if (age > diffCacheTtlMs.get()) {
+        diffSlots.delete(key);
+        return undefined;
+    }
+    return slot;
 }
 export function hasDiff(key = process.cwd()) {
     return diffSlots.has(key);
 }
 /** Test-only: directly set or clear the diff slot without emitting resource-updated. */
 export function setDiffForTesting(data, key = process.cwd()) {
-    if (data) {
-        diffSlots.set(key, data);
-    }
-    else {
-        diffSlots.delete(key);
-    }
+    setDiffSlot(key, 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.js

@@ -1,9 +1,10 @@
 function parsePositiveInteger(value) {
-    if (value.length === 0) {
+    const normalized = value.trim();
+    if (normalized.length === 0) {
         return undefined;
     }
-    const parsed = Number.parseInt(value, 10);
-    if (Number.isNaN(parsed) || parsed <= 0) {
+    const parsed = Number.parseInt(normalized, 10);
+    if (!Number.isSafeInteger(parsed) || parsed <= 0) {
         return undefined;
     }
     return parsed;

package/dist/lib/errors.js

@@ -4,16 +4,18 @@ export const RETRYABLE_UPSTREAM_ERROR_PATTERN = /(429|500|502|503|504|rate.?limi
 function isObjectRecord(value) {
     return typeof value === 'object' && value !== null;
 }
-function hasStringProperty(value, key) {
+function getStringProperty(value, key) {
     if (!isObjectRecord(value) || !(key in value)) {
-        return false;
+        return undefined;
     }
     const record = value;
-    return typeof record[key] === 'string';
+    const property = record[key];
+    return typeof property === 'string' ? property : undefined;
 }
 export function getErrorMessage(error) {
-    if (hasStringProperty(error, 'message')) {
-        return error.message;
+    const message = getStringProperty(error, 'message');
+    if (message !== undefined) {
+        return message;
     }
     if (typeof error === 'string') {
         return error;

package/dist/lib/gemini-schema.js

@@ -8,6 +8,8 @@ const CONSTRAINT_KEYS = new Set([
     'minItems',
     'maxItems',
     'multipleOf',
+    'pattern',
+    'format',
 ]);
 const INTEGER_JSON_TYPE = 'integer';
 const NUMBER_JSON_TYPE = 'number';