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

package/dist/lib/gemini.js

@@ -38,6 +38,7 @@ const DIGITS_ONLY_PATTERN = /^\d+$/;
 const TRUE_ENV_VALUES = new Set(['1', 'true', 'yes', 'on']);
 const FALSE_ENV_VALUES = new Set(['0', 'false', 'no', 'off']);
 const SLEEP_UNREF_OPTIONS = { ref: false };
+const JSON_CODE_BLOCK_PATTERN = /```(?:json)?\n?([\s\S]*?)(?=\n?```)/u;
 const maxConcurrentCallsConfig = createCachedEnvInt('MAX_CONCURRENT_CALLS', 10);
 const maxConcurrentBatchCallsConfig = createCachedEnvInt('MAX_CONCURRENT_BATCH_CALLS', 2);
 const concurrencyWaitMsConfig = createCachedEnvInt('MAX_CONCURRENT_CALLS_WAIT_MS', 2_000);
@@ -45,8 +46,8 @@ const batchPollIntervalMsConfig = createCachedEnvInt('GEMINI_BATCH_POLL_INTERVAL
 const batchTimeoutMsConfig = createCachedEnvInt('GEMINI_BATCH_TIMEOUT_MS', 120_000);
 let activeCalls = 0;
 let activeBatchCalls = 0;
-const slotWaiters = [];
-const batchSlotWaiters = [];
+const slotWaiters = new Set();
+const batchSlotWaiters = new Set();
 const RETRYABLE_TRANSIENT_CODES = new Set([
     'RESOURCE_EXHAUSTED',
     'UNAVAILABLE',
@@ -54,6 +55,36 @@ const RETRYABLE_TRANSIENT_CODES = new Set([
     'INTERNAL',
     'ABORTED',
 ]);
+function getWaiterCount(waiters) {
+    return waiters instanceof Set ? waiters.size : waiters.length;
+}
+function addWaiter(waiters, waiter) {
+    if (waiters instanceof Set) {
+        waiters.add(waiter);
+        return;
+    }
+    waiters.push(waiter);
+}
+function removeWaiter(waiters, waiter) {
+    if (waiters instanceof Set) {
+        waiters.delete(waiter);
+        return;
+    }
+    const index = waiters.indexOf(waiter);
+    if (index !== -1) {
+        waiters.splice(index, 1);
+    }
+}
+function popNextWaiter(waiters) {
+    if (waiters instanceof Set) {
+        const next = waiters.values().next().value;
+        if (next !== undefined) {
+            waiters.delete(next);
+        }
+        return next;
+    }
+    return waiters.shift();
+}
 const SAFETY_CATEGORIES = [
     HarmCategory.HARM_CATEGORY_HATE_SPEECH,
     HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
@@ -371,7 +402,7 @@ function parseStructuredResponse(responseText) {
     catch {
         // fast-path failed; try extracting from markdown block
     }
-    const jsonMatch = /```(?:json)?\n?([\s\S]*?)(?=\n?```)/u.exec(responseText);
+    const jsonMatch = JSON_CODE_BLOCK_PATTERN.exec(responseText);
     const jsonText = jsonMatch?.[1] ?? responseText;
     try {
         return JSON.parse(jsonText);
@@ -501,13 +532,13 @@ function canRetryAttempt(attempt, maxRetries, error) {
     return attempt < maxRetries && shouldRetry(error);
 }
 function tryWakeNextWaiter() {
-    const next = slotWaiters.shift();
+    const next = popNextWaiter(slotWaiters);
     if (next !== undefined) {
         next();
     }
 }
 async function waitForSlot(limit, getActiveCount, acquireSlot, waiters, requestSignal) {
-    if (waiters.length === 0 && getActiveCount() < limit) {
+    if (getWaiterCount(waiters) === 0 && getActiveCount() < limit) {
         acquireSlot();
         return;
     }
@@ -526,12 +557,9 @@ async function waitForSlot(limit, getActiveCount, acquireSlot, waiters, requestS
             acquireSlot();
             resolve();
         };
-        waiters.push(waiter);
-        const removeWaiter = () => {
-            const idx = waiters.indexOf(waiter);
-            if (idx !== -1) {
-                waiters.splice(idx, 1);
-            }
+        addWaiter(waiters, waiter);
+        const removeCurrentWaiter = () => {
+            removeWaiter(waiters, waiter);
         };
         const detachAbortListener = () => {
             if (requestSignal) {
@@ -542,7 +570,7 @@ async function waitForSlot(limit, getActiveCount, acquireSlot, waiters, requestS
             if (settled)
                 return;
             settled = true;
-            removeWaiter();
+            removeCurrentWaiter();
             detachAbortListener();
             reject(new Error(formatConcurrencyLimitErrorMessage(limit, waitLimitMs)));
         }, waitLimitMs);
@@ -551,7 +579,7 @@ async function waitForSlot(limit, getActiveCount, acquireSlot, waiters, requestS
             if (settled)
                 return;
             settled = true;
-            removeWaiter();
+            removeCurrentWaiter();
             clearTimeout(deadlineTimer);
             reject(new Error('Gemini request was cancelled.'));
         };
@@ -566,7 +594,7 @@ async function waitForConcurrencySlot(limit, requestSignal) {
     }, slotWaiters, requestSignal);
 }
 function tryWakeNextBatchWaiter() {
-    const next = batchSlotWaiters.shift();
+    const next = popNextWaiter(batchSlotWaiters);
     if (next !== undefined) {
         next();
     }
@@ -770,7 +798,7 @@ async function runInlineBatchWithPolling(request, model, onLog) {
 export function getGeminiQueueSnapshot() {
     return {
         activeCalls,
-        waitingCalls: slotWaiters.length,
+        waitingCalls: slotWaiters.size,
     };
 }
 export async function generateStructuredJson(request) {
@@ -793,7 +821,7 @@ export async function generateStructuredJson(request) {
     await safeCallOnLog(onLog, 'info', {
         event: 'gemini_queue_acquired',
         queueWaitMs,
-        waitingCalls: batchMode === 'inline' ? batchSlotWaiters.length : slotWaiters.length,
+        waitingCalls: batchMode === 'inline' ? batchSlotWaiters.size : slotWaiters.size,
         activeCalls,
         activeBatchCalls,
         mode: batchMode,

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

@@ -111,11 +111,13 @@ export declare class ToolTaskRunner<TInput extends object, TResult extends objec
     private readonly task;
     private diffSlotSnapshot;
     private hasSnapshot;
-    private readonly responseSchema;
+    private responseSchema;
     private readonly onLog;
     private readonly reportProgress;
     private progressContext;
+    private lastStatusMessage;
     constructor(server: McpServer, config: StructuredToolTaskConfig<TInput, TResult, TFinal>, extra: CreateTaskRequestHandlerExtra, task: TaskLike);
+    setResponseSchemaOverride(responseSchema: Record<string, unknown>): void;
     setDiffSlotSnapshot(diffSlotSnapshot: DiffSlot | undefined): void;
     private updateStatusMessage;
     private storeResultSafely;

package/dist/lib/tool-factory.js

@@ -28,6 +28,9 @@ 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;
+const MODEL_IMMEDIATE_RESPONSE_META_KEY = 'io.modelcontextprotocol/model-immediate-response';
+const responseSchemaCache = new WeakMap();
+const progressReporterCache = new WeakMap();
 function buildToolAnnotations(annotations) {
     if (!annotations) {
         return {
@@ -49,6 +52,18 @@ function createGeminiResponseSchema(config) {
     const sourceSchema = config.geminiSchema ?? config.resultSchema;
     return stripJsonSchemaConstraints(z.toJSONSchema(sourceSchema));
 }
+function getCachedGeminiResponseSchema(config) {
+    const cached = responseSchemaCache.get(config);
+    if (cached) {
+        return cached;
+    }
+    const responseSchema = createGeminiResponseSchema({
+        geminiSchema: config.geminiSchema,
+        resultSchema: config.resultSchema,
+    });
+    responseSchemaCache.set(config, responseSchema);
+    return responseSchema;
+}
 function parseToolInput(input, fullInputSchema) {
     return fullInputSchema.parse(input);
 }
@@ -165,24 +180,14 @@ function isRetryableUpstreamMessage(message) {
     return (RETRYABLE_UPSTREAM_ERROR_PATTERN.test(message) ||
         BUSY_ERROR_PATTERN.test(message));
 }
-function sendTaskProgress(extra, payload) {
+function createProgressReporter(extra) {
     const rawToken = extra._meta?.progressToken;
     if (typeof rawToken !== 'string' && typeof rawToken !== 'number') {
-        return Promise.resolve();
+        return async () => {
+            // Request did not provide a progress token.
+        };
     }
-    const params = {
-        progressToken: rawToken,
-        progress: payload.current,
-        ...(payload.total !== undefined ? { total: payload.total } : {}),
-        ...(payload.message !== undefined ? { message: payload.message } : {}),
-    };
-    return extra
-        .sendNotification({ method: 'notifications/progress', params })
-        .catch(() => {
-        // Progress notifications are best-effort; never fail tool execution.
-    });
-}
-function createProgressReporter(extra) {
+    const progressToken = rawToken;
     let lastCurrent = 0;
     let didSendTerminal = false;
     return async (payload) => {
@@ -200,13 +205,36 @@ function createProgressReporter(extra) {
         if (payload.message !== undefined) {
             progressPayload.message = payload.message;
         }
-        await sendTaskProgress(extra, progressPayload);
+        const params = {
+            progressToken,
+            progress: progressPayload.current,
+            ...(progressPayload.total !== undefined
+                ? { total: progressPayload.total }
+                : {}),
+            ...(progressPayload.message !== undefined
+                ? { message: progressPayload.message }
+                : {}),
+        };
+        await extra
+            .sendNotification({ method: 'notifications/progress', params })
+            .catch(() => {
+            // Progress notifications are best-effort; never fail tool execution.
+        });
         lastCurrent = current;
         if (total !== undefined && total === current) {
             didSendTerminal = true;
         }
     };
 }
+function getOrCreateProgressReporter(extra) {
+    const cached = progressReporterCache.get(extra);
+    if (cached) {
+        return cached;
+    }
+    const created = createProgressReporter(extra);
+    progressReporterCache.set(extra, created);
+    return created;
+}
 function normalizeProgressContext(context) {
     const compact = context?.replace(/\s+/g, ' ').trim();
     if (!compact) {
@@ -240,8 +268,10 @@ function createFailureStatusMessage(outcome, errorMessage) {
     return errorMessage;
 }
 async function sendSingleStepProgress(extra, toolName, context, current, state) {
-    await sendTaskProgress(extra, {
+    const reporter = getOrCreateProgressReporter(extra);
+    await reporter({
         current,
+        total: 1,
         message: current === 0
             ? formatProgressStep(toolName, context, state)
             : formatProgressCompletion(toolName, context, state),
@@ -377,26 +407,32 @@ export class ToolTaskRunner {
     onLog;
     reportProgress;
     progressContext;
+    lastStatusMessage;
     constructor(server, config, extra, task) {
         this.server = server;
         this.config = config;
         this.extra = extra;
         this.task = task;
-        this.responseSchema = createGeminiResponseSchema({
-            geminiSchema: config.geminiSchema,
-            resultSchema: config.resultSchema,
-        });
+        this.responseSchema = getCachedGeminiResponseSchema(config);
         this.onLog = createGeminiLogger(server, task.taskId);
         this.reportProgress = createProgressReporter(extra);
         this.progressContext = DEFAULT_PROGRESS_CONTEXT;
     }
+    setResponseSchemaOverride(responseSchema) {
+        this.responseSchema = responseSchema;
+        responseSchemaCache.set(this.config, responseSchema);
+    }
     setDiffSlotSnapshot(diffSlotSnapshot) {
         this.diffSlotSnapshot = diffSlotSnapshot;
         this.hasSnapshot = true;
     }
     async updateStatusMessage(message) {
+        if (this.lastStatusMessage === message) {
+            return;
+        }
         try {
             await this.extra.taskStore.updateTaskStatus(this.task.taskId, 'working', message);
+            this.lastStatusMessage = message;
         }
         catch {
             // Best-effort
@@ -524,6 +560,10 @@ export class ToolTaskRunner {
     }
 }
 export function registerStructuredToolTask(server, config) {
+    const responseSchema = createGeminiResponseSchema({
+        geminiSchema: config.geminiSchema,
+        resultSchema: config.resultSchema,
+    });
     server.experimental.tasks.registerToolTask(config.name, {
         title: config.title,
         description: config.description,
@@ -540,6 +580,7 @@ export function registerStructuredToolTask(server, config) {
             // preserves task-level TOCTOU safety without deep-clone overhead.
             const diffSlotSnapshot = currentDiff;
             const runner = new ToolTaskRunner(server, config, extra, task);
+            runner.setResponseSchemaOverride(responseSchema);
             runner.setDiffSlotSnapshot(diffSlotSnapshot);
             setImmediate(() => {
                 void runner.run(input).catch(async (error) => {
@@ -555,7 +596,12 @@ export function registerStructuredToolTask(server, config) {
                     }
                 });
             });
-            return { task };
+            return {
+                task,
+                _meta: {
+                    [MODEL_IMMEDIATE_RESPONSE_META_KEY]: `${config.name} accepted as task ${task.taskId}`,
+                },
+            };
         },
         getTask: async (_input, extra) => {
             return await extra.taskStore.getTask(extra.taskId);

package/dist/tools/generate-diff.js

@@ -9,12 +9,19 @@ import { DefaultOutputSchema } from '../schemas/outputs.js';
 const GIT_TIMEOUT_MS = 30_000;
 const GIT_MAX_BUFFER = 10 * 1024 * 1024; // 10 MB
 const execFileAsync = promisify(execFile);
-async function findGitRoot() {
+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: process.cwd(),
+        cwd,
         encoding: 'utf8',
     });
-    return stdout.trim();
+    const gitRoot = stdout.trim();
+    gitRootByCwd.set(cwd, gitRoot);
+    return gitRoot;
 }
 function buildGitArgs(mode) {
     const args = ['diff', '--no-color', '--no-ext-diff'];

package/package.json

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