@j0hanz/code-review-analyst-mcp 1.6.2 → 1.6.4

package/README.md

@@ -305,21 +305,20 @@ Summarize a pull request diff and assess high-level risk using the Flash model.
 
 ### `inspect_code_quality`
 
-Deep-dive code review with optional file context using the Pro model with thinking (16K token budget).
+Deep-dive code review using the Pro model with thinking (16K token budget).
 
-| Parameter     | Type       | Required | Description                                         |
-| ------------- | ---------- | -------- | --------------------------------------------------- |
-| `diff`        | `string`   | Yes      | Unified diff text.                                  |
-| `repository`  | `string`   | Yes      | Repository identifier (e.g. `org/repo`).            |
-| `language`    | `string`   | No       | Primary language hint.                              |
-| `focusAreas`  | `string[]` | No       | Areas to inspect: security, correctness, etc.       |
-| `maxFindings` | `number`   | No       | Maximum findings to return (1-25).                  |
-| `files`       | `object[]` | No       | Full file contents (`path`, `content`) for context. |
+| Parameter     | Type       | Required | Description                                   |
+| ------------- | ---------- | -------- | --------------------------------------------- |
+| `diff`        | `string`   | Yes      | Unified diff text.                            |
+| `repository`  | `string`   | Yes      | Repository identifier (e.g. `org/repo`).      |
+| `language`    | `string`   | No       | Primary language hint.                        |
+| `focusAreas`  | `string[]` | No       | Areas to inspect: security, correctness, etc. |
+| `maxFindings` | `number`   | No       | Maximum findings to return (1-25).            |
 
 **Returns:** `summary`, `overallRisk` (low/medium/high/critical), `findings[]` (severity, file, line, title, explanation, recommendation), `testsNeeded[]`, `contextualInsights[]`.
 
 > [!NOTE]
-> Enforces `MAX_CONTEXT_CHARS` (default 500,000) on combined diff + files size. Expect 60-120s latency due to deep thinking.
+> Diff size bounded by `MAX_DIFF_CHARS` (default 120,000). Expect 60-120s latency due to deep thinking.
 
 ### `suggest_search_replace`
 
@@ -378,7 +377,6 @@ Create a test plan covering the changes in the diff using the Flash model with t
 | `GEMINI_MODEL`                  | Override default model selection                     | —            | No       |
 | `GEMINI_HARM_BLOCK_THRESHOLD`   | Safety threshold (BLOCK_NONE, BLOCK_ONLY_HIGH, etc.) | `BLOCK_NONE` | No       |
 | `MAX_DIFF_CHARS`                | Max chars for diff input                             | `120000`     | No       |
-| `MAX_CONTEXT_CHARS`             | Max combined context for inspection                  | `500000`     | No       |
 | `MAX_CONCURRENT_CALLS`          | Max concurrent Gemini requests                       | `10`         | No       |
 | `MAX_CONCURRENT_BATCH_CALLS`    | Max concurrent inline batch requests                 | `2`          | No       |
 | `MAX_CONCURRENT_CALLS_WAIT_MS`  | Max wait time for a free Gemini slot                 | `2000`       | No       |
@@ -407,7 +405,7 @@ Create a test plan covering the changes in the diff using the Flash model with t
 
 ### Deep Code Inspection
 
-1. Call `inspect_code_quality` with the diff and critical files in `files[]`.
+1. Call `inspect_code_quality` with the cached diff.
 2. Use `focusAreas` to target specific concerns (security, performance).
 3. Review `findings` and `contextualInsights`.
 
@@ -457,7 +455,7 @@ The pipeline runs lint, type-check, test, and build, then publishes to three tar
 | Issue                                      | Solution                                                                             |
 | ------------------------------------------ | ------------------------------------------------------------------------------------ |
 | `Missing GEMINI_API_KEY or GOOGLE_API_KEY` | Set one of the API key env vars in your MCP client config.                           |
-| `E_INPUT_TOO_LARGE`                        | Diff or combined context exceeds budget. Split into smaller diffs or reduce files.   |
+| `E_INPUT_TOO_LARGE`                        | Diff exceeds budget. Split into smaller diffs.                                       |
 | `Gemini request timed out`                 | Pro model tasks may take 60-120s. Increase your client timeout.                      |
 | `Too many concurrent Gemini calls`         | Reduce parallel tool calls or increase `MAX_CONCURRENT_CALLS`.                       |
 | No tool output visible                     | Ensure your MCP client is not swallowing `stderr` — the server uses stdio transport. |

package/dist/index.js

@@ -1,9 +1,44 @@
 #!/usr/bin/env node
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { parseCommandLineArgs } from './lib/cli.js';
+import { parseArgs } from 'node:util';
 import { getErrorMessage } from './lib/errors.js';
 import { createServer } from './server.js';
 const SHUTDOWN_SIGNALS = ['SIGINT', 'SIGTERM'];
+// --- CLI Parsing ---
+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/diff-store.d.ts

@@ -1,5 +1,5 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { ParsedFile } from './diff-parser.js';
+import type { ParsedFile } from './diff.js';
 import { createErrorToolResponse } from './tool-response.js';
 export declare const DIFF_RESOURCE_URI = "diff://current";
 export interface DiffStats {

package/dist/lib/diff.d.ts

@@ -0,0 +1,30 @@
+import type { File as ParsedFile } from 'parse-diff';
+import { createErrorToolResponse } from './tool-response.js';
+export type { ParsedFile };
+export declare function getMaxDiffChars(): number;
+export declare function resetMaxDiffCharsCacheForTesting(): void;
+export declare function exceedsDiffBudget(diff: string): boolean;
+export declare function getDiffBudgetError(diffLength: number, maxChars?: number): string;
+export declare function validateDiffBudget(diff: string): ReturnType<typeof createErrorToolResponse> | undefined;
+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"];
+export declare function cleanDiff(raw: string): string;
+export declare function isEmptyDiff(diff: string): boolean;
+export interface DiffStats {
+    files: number;
+    added: number;
+    deleted: number;
+}
+export declare function parseDiffFiles(diff: string): ParsedFile[];
+export declare function computeDiffStatsAndSummaryFromFiles(files: readonly ParsedFile[]): Readonly<{
+    stats: DiffStats;
+    summary: string;
+}>;
+export declare function computeDiffStatsAndPathsFromFiles(files: readonly ParsedFile[]): Readonly<{
+    stats: DiffStats;
+    paths: string[];
+}>;
+export declare function extractChangedPathsFromFiles(files: readonly ParsedFile[]): string[];
+export declare function extractChangedPaths(diff: string): string[];
+export declare function computeDiffStatsFromFiles(files: readonly ParsedFile[]): Readonly<DiffStats>;
+export declare function computeDiffStats(diff: string): Readonly<DiffStats>;
+export declare function formatFileSummary(files: ParsedFile[]): string;

package/dist/lib/diff.js

@@ -0,0 +1,189 @@
+import parseDiff from 'parse-diff';
+import { createCachedEnvInt } from './env-config.js';
+import { createErrorToolResponse } from './tool-response.js';
+// --- Diff Budget ---
+const DEFAULT_MAX_DIFF_CHARS = 120_000;
+const MAX_DIFF_CHARS_ENV_VAR = 'MAX_DIFF_CHARS';
+const numberFormatter = new Intl.NumberFormat('en-US');
+const diffCharsConfig = createCachedEnvInt(MAX_DIFF_CHARS_ENV_VAR, DEFAULT_MAX_DIFF_CHARS);
+export function getMaxDiffChars() {
+    return diffCharsConfig.get();
+}
+export function resetMaxDiffCharsCacheForTesting() {
+    diffCharsConfig.reset();
+}
+export function exceedsDiffBudget(diff) {
+    return diff.length > getMaxDiffChars();
+}
+export function getDiffBudgetError(diffLength, maxChars = getMaxDiffChars()) {
+    return `diff exceeds max allowed size (${numberFormatter.format(diffLength)} chars > ${numberFormatter.format(maxChars)} chars)`;
+}
+const BUDGET_ERROR_META = { retryable: false, kind: 'budget' };
+export function validateDiffBudget(diff) {
+    const providedChars = diff.length;
+    const maxChars = getMaxDiffChars();
+    if (providedChars <= maxChars) {
+        return undefined;
+    }
+    return createErrorToolResponse('E_INPUT_TOO_LARGE', getDiffBudgetError(providedChars, maxChars), { providedChars, maxChars }, BUDGET_ERROR_META);
+}
+// --- Diff Cleaner ---
+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',
+];
+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);
+        }
+    }
+}
+export function cleanDiff(raw) {
+    if (!raw)
+        return '';
+    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;
+}
+// --- Diff Parser ---
+const UNKNOWN_PATH = 'unknown';
+const NO_FILES_CHANGED = 'No files changed.';
+const EMPTY_PATHS = [];
+const EMPTY_STATS = Object.freeze({ files: 0, added: 0, deleted: 0 });
+const PATH_SORTER = (left, right) => left.localeCompare(right);
+export function parseDiffFiles(diff) {
+    return diff ? parseDiff(diff) : [];
+}
+function cleanPath(path) {
+    if (path.startsWith('a/') || path.startsWith('b/')) {
+        return path.slice(2);
+    }
+    return path;
+}
+function resolveChangedPath(file) {
+    if (file.to && file.to !== '/dev/null')
+        return cleanPath(file.to);
+    if (file.from && file.from !== '/dev/null')
+        return cleanPath(file.from);
+    return undefined;
+}
+function sortPaths(paths) {
+    return Array.from(paths).sort(PATH_SORTER);
+}
+function calculateStats(files) {
+    let added = 0;
+    let deleted = 0;
+    for (const file of files) {
+        added += file.additions;
+        deleted += file.deletions;
+    }
+    return { files: files.length, 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) {
+        return { stats: EMPTY_STATS, summary: NO_FILES_CHANGED };
+    }
+    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: `${summaries.join(', ')} [${stats.files} files, +${stats.added} -${stats.deleted}]`,
+    };
+}
+export function computeDiffStatsAndPathsFromFiles(files) {
+    if (files.length === 0) {
+        return { stats: EMPTY_STATS, paths: EMPTY_PATHS };
+    }
+    const stats = calculateStats(files);
+    const paths = sortPaths(getUniquePaths(files));
+    return { stats, paths };
+}
+export function extractChangedPathsFromFiles(files) {
+    if (files.length === 0)
+        return EMPTY_PATHS;
+    return sortPaths(getUniquePaths(files));
+}
+export function extractChangedPaths(diff) {
+    return extractChangedPathsFromFiles(parseDiffFiles(diff));
+}
+export function computeDiffStatsFromFiles(files) {
+    if (files.length === 0)
+        return EMPTY_STATS;
+    return calculateStats(files);
+}
+export function computeDiffStats(diff) {
+    return computeDiffStatsFromFiles(parseDiffFiles(diff));
+}
+export function formatFileSummary(files) {
+    return computeDiffStatsAndSummaryFromFiles(files).summary;
+}

package/dist/lib/gemini.js

@@ -522,24 +522,28 @@ async function waitForSlot(limit, getActiveCount, acquireSlot, waiters, requestS
                 return;
             settled = true;
             clearTimeout(deadlineTimer);
-            if (requestSignal) {
-                requestSignal.removeEventListener('abort', onAbort);
-            }
+            detachAbortListener();
             acquireSlot();
             resolve();
         };
         waiters.push(waiter);
-        const deadlineTimer = setTimeout(() => {
-            if (settled)
-                return;
-            settled = true;
+        const removeWaiter = () => {
             const idx = waiters.indexOf(waiter);
             if (idx !== -1) {
                 waiters.splice(idx, 1);
             }
+        };
+        const detachAbortListener = () => {
             if (requestSignal) {
                 requestSignal.removeEventListener('abort', onAbort);
             }
+        };
+        const deadlineTimer = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            removeWaiter();
+            detachAbortListener();
             reject(new Error(formatConcurrencyLimitErrorMessage(limit, waitLimitMs)));
         }, waitLimitMs);
         deadlineTimer.unref();
@@ -547,10 +551,7 @@ async function waitForSlot(limit, getActiveCount, acquireSlot, waiters, requestS
             if (settled)
                 return;
             settled = true;
-            const idx = waiters.indexOf(waiter);
-            if (idx !== -1) {
-                waiters.splice(idx, 1);
-            }
+            removeWaiter();
             clearTimeout(deadlineTimer);
             reject(new Error('Gemini request was cancelled.'));
         };

package/dist/lib/tool-contracts.d.ts

@@ -103,7 +103,7 @@ export declare const TOOL_CONTRACTS: readonly [{
     readonly crossToolFlow: readonly ["Use before deep review to decide whether Pro analysis is needed."];
 }, {
     readonly name: "inspect_code_quality";
-    readonly purpose: "Deep code review over the cached diff; files are optional supplementary excerpts only.";
+    readonly purpose: "Deep code review over the cached diff.";
     readonly model: "gemini-3-pro-preview";
     readonly timeoutMs: 120000;
     readonly thinkingLevel: "high";
@@ -134,17 +134,11 @@ export declare const TOOL_CONTRACTS: readonly [{
         readonly required: false;
         readonly constraints: "1-25";
         readonly description: "Post-generation cap applied to findings.";
-    }, {
-        readonly name: "files";
-        readonly type: "object[]";
-        readonly required: false;
-        readonly constraints: "1-20 files, 100K chars/file";
-        readonly description: "Optional short excerpts for supplementary context only; avoid full files — the diff is the primary source.";
     }];
     readonly outputShape: "{summary, overallRisk, findings[], testsNeeded[], contextualInsights[], totalFindings}";
-    readonly gotchas: readonly ["Requires generate_diff to be called first.", "Combined diff + file context is bounded by MAX_CONTEXT_CHARS.", "maxFindings caps output after generation.", "files[] is token-expensive — omit unless the diff lacks critical structural context (e.g. class hierarchy, imports). Never pass full files."];
+    readonly gotchas: readonly ["Requires generate_diff to be called first.", "maxFindings caps output after generation."];
     readonly crossToolFlow: readonly ["findings[].title -> suggest_search_replace.findingTitle", "findings[].explanation -> suggest_search_replace.findingDetails"];
-    readonly constraints: readonly ["Context budget (diff + files) < 500K chars."];
+    readonly constraints: readonly ["Diff budget bounded by MAX_DIFF_CHARS."];
 }, {
     readonly name: "suggest_search_replace";
     readonly purpose: "Generate verbatim search/replace fix blocks for one finding.";

package/dist/lib/tool-contracts.js

@@ -118,7 +118,7 @@ export const TOOL_CONTRACTS = [
     },
     {
         name: 'inspect_code_quality',
-        purpose: 'Deep code review over the cached diff; files are optional supplementary excerpts only.',
+        purpose: 'Deep code review over the cached diff.',
         model: PRO_MODEL,
         timeoutMs: DEFAULT_TIMEOUT_PRO_MS,
         thinkingLevel: PRO_THINKING_LEVEL,
@@ -154,26 +154,17 @@ export const TOOL_CONTRACTS = [
                 constraints: '1-25',
                 description: 'Post-generation cap applied to findings.',
             },
-            {
-                name: 'files',
-                type: 'object[]',
-                required: false,
-                constraints: '1-20 files, 100K chars/file',
-                description: 'Optional short excerpts for supplementary context only; avoid full files — the diff is the primary source.',
-            },
         ],
         outputShape: '{summary, overallRisk, findings[], testsNeeded[], contextualInsights[], totalFindings}',
         gotchas: [
             'Requires generate_diff to be called first.',
-            'Combined diff + file context is bounded by MAX_CONTEXT_CHARS.',
             'maxFindings caps output after generation.',
-            'files[] is token-expensive — omit unless the diff lacks critical structural context (e.g. class hierarchy, imports). Never pass full files.',
         ],
         crossToolFlow: [
             'findings[].title -> suggest_search_replace.findingTitle',
             'findings[].explanation -> suggest_search_replace.findingDetails',
         ],
-        constraints: ['Context budget (diff + files) < 500K chars.'],
+        constraints: ['Diff budget bounded by MAX_DIFF_CHARS.'],
     },
     {
         name: 'suggest_search_replace',

package/dist/lib/tool-factory.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { DefaultOutputSchema } from '../schemas/outputs.js';
-import { validateDiffBudget } from './diff-budget.js';
 import { createNoDiffError, getDiff } from './diff-store.js';
+import { validateDiffBudget } from './diff.js';
 import { createCachedEnvInt } from './env-config.js';
 import { getErrorMessage, RETRYABLE_UPSTREAM_ERROR_PATTERN } from './errors.js';
 import { stripJsonSchemaConstraints } from './gemini-schema.js';
@@ -28,6 +28,23 @@ const DEFAULT_SCHEMA_RETRY_ERROR_CHARS = 1_500;
 const schemaRetryErrorCharsConfig = createCachedEnvInt('MAX_SCHEMA_RETRY_ERROR_CHARS', DEFAULT_SCHEMA_RETRY_ERROR_CHARS);
 const DETERMINISTIC_JSON_RETRY_NOTE = 'Deterministic JSON mode: keep key names exactly as schema-defined and preserve stable field ordering.';
 const JSON_PARSE_ERROR_PATTERN = /model produced invalid json/i;
+function buildToolAnnotations(annotations) {
+    if (!annotations) {
+        return {
+            readOnlyHint: true,
+            idempotentHint: true,
+            openWorldHint: true,
+        };
+    }
+    const annotationOverrides = { ...annotations };
+    delete annotationOverrides.destructiveHint;
+    return {
+        readOnlyHint: !annotations.destructiveHint,
+        idempotentHint: !annotations.destructiveHint,
+        openWorldHint: true,
+        ...annotationOverrides,
+    };
+}
 function createGeminiResponseSchema(config) {
     const sourceSchema = config.geminiSchema ?? config.resultSchema;
     return stripJsonSchemaConstraints(z.toJSONSchema(sourceSchema));
@@ -225,7 +242,6 @@ function createFailureStatusMessage(outcome, errorMessage) {
 async function sendSingleStepProgress(extra, toolName, context, current, state) {
     await sendTaskProgress(extra, {
         current,
-        total: 1,
         message: current === 0
             ? formatProgressStep(toolName, context, state)
             : formatProgressCompletion(toolName, context, state),
@@ -234,14 +250,12 @@ async function sendSingleStepProgress(extra, toolName, context, current, state)
 async function reportProgressStepUpdate(reportProgress, toolName, context, current, metadata) {
     await reportProgress({
         current,
-        total: TASK_PROGRESS_TOTAL,
         message: formatProgressStep(toolName, context, metadata),
     });
 }
 async function reportProgressCompletionUpdate(reportProgress, toolName, context, outcome) {
     await reportProgress({
         current: TASK_PROGRESS_TOTAL,
-        total: TASK_PROGRESS_TOTAL,
         message: formatProgressCompletion(toolName, context, outcome),
     });
 }
@@ -515,19 +529,7 @@ export function registerStructuredToolTask(server, config) {
         description: config.description,
         inputSchema: config.inputSchema,
         outputSchema: DefaultOutputSchema,
-        annotations: {
-            readOnlyHint: !config.annotations?.destructiveHint,
-            idempotentHint: !config.annotations?.destructiveHint,
-            openWorldHint: true,
-            ...(() => {
-                if (!config.annotations) {
-                    return {};
-                }
-                const annotationOverrides = { ...config.annotations };
-                delete annotationOverrides.destructiveHint;
-                return annotationOverrides;
-            })(),
-        },
+        annotations: buildToolAnnotations(config.annotations),
     }, {
         createTask: async (input, extra) => {
             const task = await extra.taskStore.createTask({

package/dist/lib/types.d.ts

@@ -1,8 +1,5 @@
 export type JsonObject = Record<string, unknown>;
 export type GeminiLogHandler = (level: string, data: unknown) => Promise<void>;
-export interface GeminiFunctionCallingContext {
-    readonly modelParts: readonly unknown[];
-}
 export interface GeminiRequestExecutionOptions {
     maxRetries?: number;
     timeoutMs?: number;
@@ -13,7 +10,6 @@ export interface GeminiRequestExecutionOptions {
     signal?: AbortSignal;
     onLog?: GeminiLogHandler;
     responseKeyOrdering?: readonly string[];
-    functionCallingContext?: GeminiFunctionCallingContext;
     batchMode?: 'off' | 'inline';
 }
 export interface GeminiStructuredRequestOptions extends GeminiRequestExecutionOptions {

package/dist/resources/server-config.js

@@ -2,7 +2,6 @@ import { createCachedEnvInt } from '../lib/env-config.js';
 import { FLASH_MODEL } from '../lib/model-config.js';
 import { getToolContracts } from '../lib/tool-contracts.js';
 const DEFAULT_MAX_DIFF_CHARS = 120_000;
-const DEFAULT_MAX_CONTEXT_CHARS = 500_000;
 const DEFAULT_MAX_CONCURRENT_CALLS = 10;
 const DEFAULT_CONCURRENT_WAIT_MS = 2_000;
 const DEFAULT_SAFETY_THRESHOLD = 'BLOCK_NONE';
@@ -10,7 +9,6 @@ const GEMINI_HARM_BLOCK_THRESHOLD_ENV_VAR = 'GEMINI_HARM_BLOCK_THRESHOLD';
 const GEMINI_MODEL_ENV_VAR = 'GEMINI_MODEL';
 const GEMINI_BATCH_MODE_ENV_VAR = 'GEMINI_BATCH_MODE';
 const diffCharsConfig = createCachedEnvInt('MAX_DIFF_CHARS', DEFAULT_MAX_DIFF_CHARS);
-const contextCharsConfig = createCachedEnvInt('MAX_CONTEXT_CHARS', DEFAULT_MAX_CONTEXT_CHARS);
 const concurrentCallsConfig = createCachedEnvInt('MAX_CONCURRENT_CALLS', DEFAULT_MAX_CONCURRENT_CALLS);
 const concurrentBatchCallsConfig = createCachedEnvInt('MAX_CONCURRENT_BATCH_CALLS', 2);
 const concurrentWaitConfig = createCachedEnvInt('MAX_CONCURRENT_CALLS_WAIT_MS', DEFAULT_CONCURRENT_WAIT_MS);
@@ -34,7 +32,6 @@ function formatThinkingLevel(level) {
 }
 export function buildServerConfig() {
     const maxDiffChars = diffCharsConfig.get();
-    const maxContextChars = contextCharsConfig.get();
     const maxConcurrent = concurrentCallsConfig.get();
     const maxConcurrentBatch = concurrentBatchCallsConfig.get();
     const concurrentWaitMs = concurrentWaitConfig.get();
@@ -54,7 +51,6 @@ export function buildServerConfig() {
 | Limit | Value | Env |
 |-------|-------|-----|
 | Diff limit | ${formatNumber(maxDiffChars)} chars | \`MAX_DIFF_CHARS\` |
-| Context limit (inspect) | ${formatNumber(maxContextChars)} chars | \`MAX_CONTEXT_CHARS\` |
 | Concurrency limit | ${maxConcurrent} | \`MAX_CONCURRENT_CALLS\` |
 | Batch concurrency limit | ${maxConcurrentBatch} | \`MAX_CONCURRENT_BATCH_CALLS\` |
 | Wait timeout | ${formatNumber(concurrentWaitMs)}ms | \`MAX_CONCURRENT_CALLS_WAIT_MS\` |

package/dist/resources/tool-catalog.js

@@ -6,7 +6,6 @@ const TOOL_CATALOG_CONTENT = `# Tool Catalog Details
 - \`language\`: Primary language hint (auto-detects). All tools except \`suggest_search_replace\`.
 - \`focusAreas\`: Focus tags (security, performance, etc.). \`inspect_code_quality\` only.
 - \`maxFindings\`: Output cap (1–25). \`inspect_code_quality\` only.
-- \`files\`: File context (max 20 files, 100K chars/file). \`inspect_code_quality\` only.
 - \`testFramework\`: Framework hint. \`generate_test_plan\` only.
 - \`maxTestCases\`: Output cap (1–30). \`generate_test_plan\` only.
 

package/dist/schemas/inputs.d.ts

@@ -1,8 +1,4 @@
 import { z } from 'zod';
-export declare const FileContextSchema: z.ZodObject<{
-    path: z.ZodString;
-    content: z.ZodString;
-}, z.core.$strict>;
 export declare const AnalyzePrImpactInputSchema: z.ZodObject<{
     repository: z.ZodString;
     language: z.ZodOptional<z.ZodString>;
@@ -16,10 +12,6 @@ export declare const InspectCodeQualityInputSchema: z.ZodObject<{
     language: z.ZodOptional<z.ZodString>;
     focusAreas: z.ZodOptional<z.ZodArray<z.ZodString>>;
     maxFindings: z.ZodOptional<z.ZodNumber>;
-    files: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        path: z.ZodString;
-        content: z.ZodString;
-    }, z.core.$strict>>>;
 }, z.core.$strict>;
 export declare const SuggestSearchReplaceInputSchema: z.ZodObject<{
     findingTitle: z.ZodString;

package/dist/schemas/inputs.js

@@ -2,11 +2,6 @@ import { z } from 'zod';
 const INPUT_LIMITS = {
     repository: { min: 1, max: 200 },
     language: { min: 2, max: 32 },
-    fileContext: {
-        path: { min: 1, max: 500 },
-        content: { min: 0, max: 100_000 },
-        maxItems: 20,
-    },
     focusArea: { min: 2, max: 80, maxItems: 12 },
     maxFindings: { min: 1, max: 25 },
     findingTitle: { min: 3, max: 160 },
@@ -31,10 +26,6 @@ function createRepositorySchema() {
 function createOptionalBoundedInteger(min, max, description) {
     return z.number().int().min(min).max(max).optional().describe(description);
 }
-export const FileContextSchema = z.strictObject({
-    path: createBoundedString(INPUT_LIMITS.fileContext.path.min, INPUT_LIMITS.fileContext.path.max, 'Repo-relative path (e.g. src/utils.ts).'),
-    content: createBoundedString(INPUT_LIMITS.fileContext.content.min, INPUT_LIMITS.fileContext.content.max, 'Relevant excerpt (changed lines + context). Avoid full files.'),
-});
 export const AnalyzePrImpactInputSchema = z.strictObject({
     repository: createRepositorySchema(),
     language: createLanguageSchema(),
@@ -53,12 +44,6 @@ export const InspectCodeQualityInputSchema = z.strictObject({
         .optional()
         .describe('Review focus areas. Tags: security, correctness, performance, regressions, tests, maintainability, concurrency.'),
     maxFindings: createOptionalBoundedInteger(INPUT_LIMITS.maxFindings.min, INPUT_LIMITS.maxFindings.max, 'Max findings (1-25). Default: 10.'),
-    files: z
-        .array(FileContextSchema)
-        .min(1)
-        .max(INPUT_LIMITS.fileContext.maxItems)
-        .optional()
-        .describe('File content (changed files). Omit if large. Diff is primary source.'),
 });
 export const SuggestSearchReplaceInputSchema = z.strictObject({
     findingTitle: createBoundedString(INPUT_LIMITS.findingTitle.min, INPUT_LIMITS.findingTitle.max, 'Exact finding title from inspect_code_quality.'),

package/dist/schemas/outputs.js

@@ -108,7 +108,7 @@ const CODE_QUALITY_SHARED_FIELDS = {
         .max(30)
         .describe('Findings (severity desc).'),
     testsNeeded: createBoundedStringArray(1, 300, 0, 12, 'Test cases needed to validate this change.'),
-    contextualInsights: createBoundedStringArray(1, 500, 0, 5, 'Cross-file insights (omit if no file context).'),
+    contextualInsights: createBoundedStringArray(1, 500, 0, 5, 'Cross-file insights from diff analysis.'),
 };
 export const PrImpactResultSchema = z.strictObject({
     severity: z.enum(QUALITY_RISK_LEVELS).describe('Overall severity.'),

package/dist/tools/analyze-pr-impact.js

@@ -1,4 +1,4 @@
-import { computeDiffStatsAndSummaryFromFiles } from '../lib/diff-parser.js';
+import { computeDiffStatsAndSummaryFromFiles } from '../lib/diff.js';
 import { buildStructuredToolRuntimeOptions, requireToolContract, } from '../lib/tool-contracts.js';
 import { registerStructuredToolTask } from '../lib/tool-factory.js';
 import { AnalyzePrImpactInputSchema } from '../schemas/inputs.js';

package/dist/tools/generate-diff.js

@@ -1,9 +1,8 @@
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { z } from 'zod';
-import { cleanDiff, isEmptyDiff, NOISY_EXCLUDE_PATHSPECS, } from '../lib/diff-cleaner.js';
-import { computeDiffStatsFromFiles, parseDiffFiles, } from '../lib/diff-parser.js';
 import { DIFF_RESOURCE_URI, storeDiff } from '../lib/diff-store.js';
+import { cleanDiff, computeDiffStatsFromFiles, isEmptyDiff, NOISY_EXCLUDE_PATHSPECS, parseDiffFiles, } from '../lib/diff.js';
 import { wrapToolHandler } from '../lib/tool-factory.js';
 import { createErrorToolResponse, createToolResponse, } from '../lib/tool-response.js';
 import { DefaultOutputSchema } from '../schemas/outputs.js';

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

@@ -1,4 +1,4 @@
-import { computeDiffStatsAndPathsFromFiles } from '../lib/diff-parser.js';
+import { computeDiffStatsAndPathsFromFiles } from '../lib/diff.js';
 import { buildStructuredToolRuntimeOptions, requireToolContract, } from '../lib/tool-contracts.js';
 import { registerStructuredToolTask } from '../lib/tool-factory.js';
 import { GenerateTestPlanInputSchema } from '../schemas/inputs.js';

package/dist/tools/inspect-code-quality.d.ts

@@ -1,4 +1,2 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-export declare function sanitizePath(path: string): string;
-export declare function sanitizeContent(content: string): string;
 export declare function registerInspectCodeQualityTool(server: McpServer): void;

package/dist/tools/inspect-code-quality.js

@@ -1,61 +1,28 @@
-import { validateContextBudget } from '../lib/context-budget.js';
-import { computeDiffStatsAndSummaryFromFiles } from '../lib/diff-parser.js';
+import { computeDiffStatsAndSummaryFromFiles } from '../lib/diff.js';
 import { buildStructuredToolRuntimeOptions, requireToolContract, } from '../lib/tool-contracts.js';
 import { registerStructuredToolTask } from '../lib/tool-factory.js';
 import { InspectCodeQualityInputSchema } from '../schemas/inputs.js';
 import { CodeQualityOutputSchema, CodeQualityResultSchema, } from '../schemas/outputs.js';
 const DEFAULT_FOCUS_AREAS = 'General';
-const FILE_CONTEXT_HEADING = '\nFull File Context:\n';
-const PATH_ESCAPE_REPLACEMENTS = {
-    '"': '\\"',
-    '\n': ' ',
-    '\r': ' ',
-    '<': '&lt;',
-    '>': '&gt;',
-};
-const PATH_ESCAPE_PATTERN = /["\n\r<>]/g;
 const SYSTEM_INSTRUCTION = `
 Principal Engineer Code Review.
-Source: Unified diff (primary), File excerpts (supplementary context).
+Source: Unified diff.
 Goal: Identify bugs, security, performance, maintainability.
 Constraint: Ignore style/formatting. Prioritize correctness/failure modes.
 Return strict JSON.
 `;
 const TOOL_CONTRACT = requireToolContract('inspect_code_quality');
-export function sanitizePath(path) {
-    return path.replace(PATH_ESCAPE_PATTERN, (match) => {
-        return PATH_ESCAPE_REPLACEMENTS[match];
-    });
-}
-export function sanitizeContent(content) {
-    return content
-        .replaceAll('<<END_FILE>>', '<END_FILE_ESCAPED>')
-        .replaceAll('<<FILE', '<FILE');
-}
 function formatOptionalLine(label, value) {
     return value === undefined ? '' : `\n${label}: ${value}`;
 }
 function capFindings(findings, maxFindings) {
     return findings.slice(0, maxFindings ?? findings.length);
 }
-function formatFileContext(files) {
-    if (!files || files.length === 0) {
-        return '';
-    }
-    return (FILE_CONTEXT_HEADING +
-        files
-            .map((file) => `
-<<FILE path="${sanitizePath(file.path)}">>
-${sanitizeContent(file.content)}
-<<END_FILE>>
-`)
-            .join('\n'));
-}
 export function registerInspectCodeQualityTool(server) {
     registerStructuredToolTask(server, {
         name: 'inspect_code_quality',
         title: 'Inspect Code Quality',
-        description: 'Deep code review. Prerequisite: generate_diff. Auto-infer repo/language/focus. Operates primarily on the diff; files are optional supplementary excerpts only.',
+        description: 'Deep code review. Prerequisite: generate_diff. Auto-infer repo/language/focus. Operates on the cached diff.',
         inputSchema: InspectCodeQualityInputSchema,
         fullInputSchema: InspectCodeQualityInputSchema,
         resultSchema: CodeQualityOutputSchema,
@@ -65,15 +32,7 @@ export function registerInspectCodeQualityTool(server) {
         timeoutMs: TOOL_CONTRACT.timeoutMs,
         maxOutputTokens: TOOL_CONTRACT.maxOutputTokens,
         ...buildStructuredToolRuntimeOptions(TOOL_CONTRACT),
-        progressContext: (input) => {
-            const fileCount = input.files?.length;
-            return fileCount ? `+${fileCount} files` : '';
-        },
         requiresDiff: true,
-        validateInput: (input, ctx) => {
-            // Diff presence and budget checked by requiresDiff: true
-            return validateContextBudget(ctx.diffSlot?.diff ?? '', input.files);
-        },
         formatOutcome: (result) => `${result.findings.length} findings, risk: ${result.overallRisk}`,
         formatOutput: (result) => {
             const count = result.findings.length;
@@ -90,25 +49,20 @@ export function registerInspectCodeQualityTool(server) {
             const diff = ctx.diffSlot?.diff ?? '';
             const parsedFiles = ctx.diffSlot?.parsedFiles ?? [];
             const { summary: fileSummary } = computeDiffStatsAndSummaryFromFiles(parsedFiles);
-            const fileContext = formatFileContext(input.files);
             const languageLine = formatOptionalLine('Language', input.language);
             const maxFindingsLine = formatOptionalLine('Max Findings', input.maxFindings);
-            const noFilesNote = !input.files?.length
-                ? '\nNote: No file excerpts provided. Review based on diff only; leave contextualInsights empty.'
-                : '';
             return {
                 systemInstruction: SYSTEM_INSTRUCTION,
                 prompt: `
 Repository: ${input.repository}${languageLine}
-Focus Areas: ${input.focusAreas?.join(', ') ?? DEFAULT_FOCUS_AREAS}${maxFindingsLine}${noFilesNote}
+Focus Areas: ${input.focusAreas?.join(', ') ?? DEFAULT_FOCUS_AREAS}${maxFindingsLine}
 Changed Files:
 ${fileSummary}
 
 Diff:
 ${diff}
-${fileContext}
 
-Based on the diff and file context above, perform a deep code review focusing on the specified areas.
+Based on the diff above, perform a deep code review focusing on the specified areas.
 `,
             };
         },

package/dist/tools/suggest-search-replace.js

@@ -1,4 +1,4 @@
-import { extractChangedPathsFromFiles } from '../lib/diff-parser.js';
+import { extractChangedPathsFromFiles } from '../lib/diff.js';
 import { buildStructuredToolRuntimeOptions, requireToolContract, } from '../lib/tool-contracts.js';
 import { registerStructuredToolTask } from '../lib/tool-factory.js';
 import { SuggestSearchReplaceInputSchema } from '../schemas/inputs.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@j0hanz/code-review-analyst-mcp",
-  "version": "1.6.2",
+  "version": "1.6.4",
   "mcpName": "io.github.j0hanz/code-review-analyst",
   "description": "Gemini-powered MCP server for code review analysis.",
   "type": "module",

package/dist/lib/cli.d.ts

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

package/dist/lib/cli.js

@@ -1,35 +0,0 @@
-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.d.ts

@@ -1,8 +0,0 @@
-import { createErrorToolResponse } from './tool-response.js';
-interface FileContent {
-    content: string;
-}
-export declare function resetMaxContextCharsCacheForTesting(): void;
-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

@@ -1,36 +0,0 @@
-import { createCachedEnvInt } from './env-config.js';
-import { createErrorToolResponse } from './tool-response.js';
-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 total = 0;
-    for (const file of files) {
-        total += file.content.length;
-    }
-    return total;
-}
-function createContextBudgetMessage(size, max) {
-    return `Combined context size ${size} chars exceeds limit of ${max} chars.`;
-}
-export function resetMaxContextCharsCacheForTesting() {
-    contextCharsConfig.reset();
-}
-function getMaxContextChars() {
-    return contextCharsConfig.get();
-}
-export function computeContextSize(diff, files) {
-    if (!files || files.length === 0) {
-        return diff.length;
-    }
-    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', createContextBudgetMessage(size, max), { providedChars: size, maxChars: max }, BUDGET_ERROR_META);
-    }
-    return undefined;
-}

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

@@ -1,6 +0,0 @@
-import { createErrorToolResponse } from './tool-response.js';
-export declare function getMaxDiffChars(): number;
-export declare function resetMaxDiffCharsCacheForTesting(): void;
-export declare function exceedsDiffBudget(diff: string): boolean;
-export declare function getDiffBudgetError(diffLength: number, maxChars?: number): string;
-export declare function validateDiffBudget(diff: string): ReturnType<typeof createErrorToolResponse> | undefined;

package/dist/lib/diff-budget.js

@@ -1,31 +0,0 @@
-import { createCachedEnvInt } from './env-config.js';
-import { createErrorToolResponse } from './tool-response.js';
-const DEFAULT_MAX_DIFF_CHARS = 120_000;
-const MAX_DIFF_CHARS_ENV_VAR = 'MAX_DIFF_CHARS';
-const numberFormatter = new Intl.NumberFormat('en-US');
-const diffCharsConfig = createCachedEnvInt(MAX_DIFF_CHARS_ENV_VAR, DEFAULT_MAX_DIFF_CHARS);
-export function getMaxDiffChars() {
-    return diffCharsConfig.get();
-}
-export function resetMaxDiffCharsCacheForTesting() {
-    diffCharsConfig.reset();
-}
-export function exceedsDiffBudget(diff) {
-    const maxChars = getMaxDiffChars();
-    return diff.length > maxChars;
-}
-function formatDiffBudgetError(diffLength, maxChars) {
-    return `diff exceeds max allowed size (${numberFormatter.format(diffLength)} chars > ${numberFormatter.format(maxChars)} chars)`;
-}
-export function getDiffBudgetError(diffLength, maxChars = getMaxDiffChars()) {
-    return formatDiffBudgetError(diffLength, maxChars);
-}
-const BUDGET_ERROR_META = { retryable: false, kind: 'budget' };
-export function validateDiffBudget(diff) {
-    const providedChars = diff.length;
-    const maxChars = getMaxDiffChars();
-    if (providedChars <= maxChars) {
-        return undefined;
-    }
-    return createErrorToolResponse('E_INPUT_TOO_LARGE', getDiffBudgetError(providedChars, maxChars), { providedChars, maxChars }, BUDGET_ERROR_META);
-}

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

@@ -1,12 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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;
-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")
- * - 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 '';
-    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.d.ts

@@ -1,34 +0,0 @@
-import type { File as ParsedFile } from 'parse-diff';
-export type { ParsedFile };
-interface DiffStats {
-    files: number;
-    added: number;
-    deleted: number;
-}
-/** Parse unified diff string into structured file list. */
-export declare function parseDiffFiles(diff: string): ParsedFile[];
-export declare function computeDiffStatsAndSummaryFromFiles(files: readonly ParsedFile[]): Readonly<{
-    stats: DiffStats;
-    summary: string;
-}>;
-export declare function computeDiffStatsAndPathsFromFiles(files: readonly ParsedFile[]): Readonly<{
-    stats: DiffStats;
-    paths: string[];
-}>;
-/** Extract all unique changed file paths (renamed: returns new path). */
-export declare function extractChangedPathsFromFiles(files: readonly ParsedFile[]): string[];
-/** Extract all unique changed file paths (renamed: returns new path). */
-export declare function extractChangedPaths(diff: string): string[];
-export declare function computeDiffStatsFromFiles(files: readonly ParsedFile[]): Readonly<{
-    files: number;
-    added: number;
-    deleted: number;
-}>;
-/** Count changed files, added lines, and deleted lines. */
-export declare function computeDiffStats(diff: string): Readonly<{
-    files: number;
-    added: number;
-    deleted: number;
-}>;
-/** Generate human-readable summary of changed files and line counts. */
-export declare function formatFileSummary(files: ParsedFile[]): string;

package/dist/lib/diff-parser.js

@@ -1,116 +0,0 @@
-import parseDiff from 'parse-diff';
-const UNKNOWN_PATH = 'unknown';
-const NO_FILES_CHANGED = 'No files changed.';
-const EMPTY_PATHS = [];
-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) {
-    return diff ? parseDiff(diff) : [];
-}
-function cleanPath(path) {
-    if (path.startsWith('a/') || path.startsWith('b/')) {
-        return path.slice(2);
-    }
-    return path;
-}
-function resolveChangedPath(file) {
-    if (file.to && file.to !== '/dev/null') {
-        return cleanPath(file.to);
-    }
-    if (file.from && file.from !== '/dev/null') {
-        return cleanPath(file.from);
-    }
-    return undefined;
-}
-function sortPaths(paths) {
-    return Array.from(paths).sort(PATH_SORTER);
-}
-function calculateStats(files) {
-    let added = 0;
-    let deleted = 0;
-    for (const file of files) {
-        added += file.additions;
-        deleted += file.deletions;
-    }
-    return { files: files.length, 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) {
-        return {
-            stats: EMPTY_STATS,
-            summary: NO_FILES_CHANGED,
-        };
-    }
-    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: `${summaries.join(', ')} [${stats.files} files, +${stats.added} -${stats.deleted}]`,
-    };
-}
-export function computeDiffStatsAndPathsFromFiles(files) {
-    if (files.length === 0) {
-        return {
-            stats: EMPTY_STATS,
-            paths: EMPTY_PATHS,
-        };
-    }
-    const stats = calculateStats(files);
-    const paths = sortPaths(getUniquePaths(files));
-    return {
-        stats,
-        paths,
-    };
-}
-/** Extract all unique changed file paths (renamed: returns new path). */
-export function extractChangedPathsFromFiles(files) {
-    if (files.length === 0) {
-        return EMPTY_PATHS;
-    }
-    return sortPaths(getUniquePaths(files));
-}
-/** Extract all unique changed file paths (renamed: returns new path). */
-export function extractChangedPaths(diff) {
-    return extractChangedPathsFromFiles(parseDiffFiles(diff));
-}
-export function computeDiffStatsFromFiles(files) {
-    if (files.length === 0) {
-        return EMPTY_STATS;
-    }
-    return calculateStats(files);
-}
-/** Count changed files, added lines, and deleted lines. */
-export function computeDiffStats(diff) {
-    return computeDiffStatsFromFiles(parseDiffFiles(diff));
-}
-/** Generate human-readable summary of changed files and line counts. */
-export function formatFileSummary(files) {
-    return computeDiffStatsAndSummaryFromFiles(files).summary;
-}