@j0hanz/code-review-analyst-mcp 1.7.3 → 1.7.5

package/dist/index.js

@@ -22,9 +22,10 @@ const CLI_OPTIONS = {
     },
 };
 function setStringEnv(name, value) {
-    if (typeof value === 'string') {
-        process.env[name] = value;
+    if (typeof value !== 'string') {
+        return;
     }
+    process.env[name] = value;
 }
 function applyCliEnvironmentOverrides(values) {
     for (const mapping of CLI_ENV_MAPPINGS) {

package/dist/lib/diff-store.js

@@ -10,9 +10,10 @@ let sendResourceUpdated;
 function setDiffSlot(key, data) {
     if (data) {
         diffSlots.set(key, data);
-        return;
     }
-    diffSlots.delete(key);
+    else {
+        diffSlots.delete(key);
+    }
 }
 function notifyDiffUpdated() {
     void sendResourceUpdated?.({ uri: DIFF_RESOURCE_URI }).catch(() => {

package/dist/lib/diff.js

@@ -48,15 +48,10 @@ 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;
+    return (Boolean(section.trim()) &&
+        !BINARY_FILE_LINE.test(section) &&
+        !GIT_BINARY_PATCH.test(section) &&
+        (!HAS_OLD_MODE.test(section) || HAS_HUNK.test(section)));
 }
 function processSection(raw, start, end, sections) {
     if (end > start) {

package/dist/lib/env-config.js

@@ -4,10 +4,7 @@ function parsePositiveInteger(value) {
         return undefined;
     }
     const parsed = Number.parseInt(normalized, 10);
-    if (!Number.isSafeInteger(parsed) || parsed <= 0) {
-        return undefined;
-    }
-    return parsed;
+    return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : undefined;
 }
 function resolveEnvInt(envVar, defaultValue) {
     const envValue = process.env[envVar] ?? '';

package/dist/lib/errors.js

@@ -8,8 +8,7 @@ function getStringProperty(value, key) {
     if (!isObjectRecord(value) || !(key in value)) {
         return undefined;
     }
-    const record = value;
-    const property = record[key];
+    const property = value[key];
     return typeof property === 'string' ? property : undefined;
 }
 export function getErrorMessage(error) {

package/dist/lib/format.d.ts

@@ -0,0 +1,3 @@
+export declare function formatOptionalLine(label: string, value: string | number | undefined): string;
+export declare function formatLanguageSegment(language: string | undefined): string;
+export declare function formatCountLabel(count: number, singular: string, plural: string): string;

package/dist/lib/format.js

@@ -0,0 +1,9 @@
+export function formatOptionalLine(label, value) {
+    return value === undefined ? '' : `\n${label}: ${value}`;
+}
+export function formatLanguageSegment(language) {
+    return formatOptionalLine('Language', language);
+}
+export function formatCountLabel(count, singular, plural) {
+    return `${count} ${count === 1 ? singular : plural}`;
+}

package/dist/lib/gemini-schema.js

@@ -1,4 +1,4 @@
-const CONSTRAINT_KEYS = new Set([
+const CONSTRAINT_KEY_VALUES = [
     'minLength',
     'maxLength',
     'minimum',
@@ -10,7 +10,8 @@ const CONSTRAINT_KEYS = new Set([
     'multipleOf',
     'pattern',
     'format',
-]);
+];
+const CONSTRAINT_KEYS = new Set(CONSTRAINT_KEY_VALUES);
 const INTEGER_JSON_TYPE = 'integer';
 const NUMBER_JSON_TYPE = 'number';
 function isJsonRecord(value) {

package/dist/lib/gemini.js

@@ -17,11 +17,8 @@ const GEMINI_BATCH_MODE_ENV_VAR = 'GEMINI_BATCH_MODE';
 const GEMINI_API_KEY_ENV_VAR = 'GEMINI_API_KEY';
 const GOOGLE_API_KEY_ENV_VAR = 'GOOGLE_API_KEY';
 function getDefaultModel() {
-    if (_defaultModel !== undefined)
-        return _defaultModel;
-    const value = process.env[GEMINI_MODEL_ENV_VAR] ?? DEFAULT_MODEL;
-    _defaultModel = value;
-    return value;
+    _defaultModel ??= process.env[GEMINI_MODEL_ENV_VAR] ?? DEFAULT_MODEL;
+    return _defaultModel;
 }
 const DEFAULT_MAX_RETRIES = 3;
 const DEFAULT_TIMEOUT_MS = 90_000;
@@ -208,10 +205,10 @@ function getSafetySettings(threshold) {
     if (cached) {
         return cached;
     }
-    const settings = new Array();
-    for (const category of SAFETY_CATEGORIES) {
-        settings.push({ category, threshold });
-    }
+    const settings = SAFETY_CATEGORIES.map((category) => ({
+        category,
+        threshold,
+    }));
     safetySettingsCache.set(threshold, settings);
     return settings;
 }

package/dist/lib/markdown.d.ts

@@ -0,0 +1,2 @@
+export declare function toBulletedList(lines: readonly string[]): string;
+export declare function toInlineCode(value: string): string;

package/dist/lib/markdown.js

@@ -0,0 +1,6 @@
+export function toBulletedList(lines) {
+    return lines.map((line) => `- ${line}`).join('\n');
+}
+export function toInlineCode(value) {
+    return `\`${value}\``;
+}

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

@@ -6,9 +6,9 @@ export declare const DEFAULT_LANGUAGE = "detect";
 export declare const DEFAULT_FRAMEWORK = "detect";
 /** Extended timeout for deep analysis calls (ms). */
 export declare const DEFAULT_TIMEOUT_EXTENDED_MS = 120000;
-export declare const MODEL_TIMEOUT_MS: {
+export declare const MODEL_TIMEOUT_MS: Readonly<{
     readonly extended: 120000;
-};
+}>;
 /** Thinking level for Flash triage. */
 export declare const FLASH_TRIAGE_THINKING_LEVEL: "minimal";
 /** Thinking level for Flash analysis. */

package/dist/lib/model-config.js

@@ -6,10 +6,9 @@ export const DEFAULT_LANGUAGE = 'detect';
 export const DEFAULT_FRAMEWORK = 'detect';
 /** Extended timeout for deep analysis calls (ms). */
 export const DEFAULT_TIMEOUT_EXTENDED_MS = 120_000;
-export const MODEL_TIMEOUT_MS = {
+export const MODEL_TIMEOUT_MS = Object.freeze({
     extended: DEFAULT_TIMEOUT_EXTENDED_MS,
-};
-Object.freeze(MODEL_TIMEOUT_MS);
+});
 // ---------------------------------------------------------------------------
 // Budgets (Thinking & Output)
 // ---------------------------------------------------------------------------

package/dist/lib/tool-contracts.js

@@ -10,17 +10,17 @@ export const INSPECTION_FOCUS_AREAS = [
     'concurrency',
 ];
 export function buildStructuredToolRuntimeOptions(contract) {
-    const options = {};
-    if (contract.thinkingLevel !== undefined) {
-        options.thinkingLevel = contract.thinkingLevel;
-    }
-    if (contract.temperature !== undefined) {
-        options.temperature = contract.temperature;
-    }
-    if (contract.deterministicJson !== undefined) {
-        options.deterministicJson = contract.deterministicJson;
-    }
-    return options;
+    return {
+        ...(contract.thinkingLevel !== undefined
+            ? { thinkingLevel: contract.thinkingLevel }
+            : {}),
+        ...(contract.temperature !== undefined
+            ? { temperature: contract.temperature }
+            : {}),
+        ...(contract.deterministicJson !== undefined
+            ? { deterministicJson: contract.deterministicJson }
+            : {}),
+    };
 }
 export const TOOL_CONTRACTS = [
     {

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

@@ -130,6 +130,7 @@ export declare class ToolExecutionRunner<TInput extends object, TResult extends
     private storeResultSafely;
     private executeValidation;
     private executeModelCall;
+    private reportAndStatus;
     run(input: unknown): Promise<CallToolResult>;
 }
 export declare function registerStructuredToolTask<TInput extends object, TResult extends object = Record<string, unknown>, TFinal extends TResult = TResult>(server: McpServer, config: StructuredToolTaskConfig<TInput, TResult, TFinal>): void;

package/dist/lib/tool-factory.js

@@ -37,11 +37,10 @@ function buildToolAnnotations(annotations) {
             openWorldHint: true,
         };
     }
-    const annotationOverrides = { ...annotations };
-    delete annotationOverrides.destructiveHint;
+    const { destructiveHint, ...annotationOverrides } = annotations;
     return {
-        readOnlyHint: !annotations.destructiveHint,
-        idempotentHint: !annotations.destructiveHint,
+        readOnlyHint: !destructiveHint,
+        idempotentHint: !destructiveHint,
         openWorldHint: true,
         ...annotationOverrides,
     };
@@ -183,13 +182,17 @@ function createProgressReporter(extra) {
         };
     }
     const progressToken = rawToken;
-    let lastCurrent = 0;
+    let lastCurrent = -1;
     let didSendTerminal = false;
     return async (payload) => {
         if (didSendTerminal) {
             return;
         }
-        const current = Math.max(payload.current, lastCurrent);
+        let { current } = payload;
+        if (current <= lastCurrent && current < (payload.total ?? Infinity)) {
+            current = lastCurrent + 0.01;
+        }
+        current = Math.max(current, lastCurrent);
         const total = payload.total !== undefined
             ? Math.max(payload.total, current)
             : undefined;
@@ -265,18 +268,20 @@ 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),
     });
 }
 async function reportSchemaRetryProgressBestEffort(reportProgress, toolName, context, retryCount, maxRetries) {
     try {
-        await reportProgressStepUpdate(reportProgress, toolName, context, STEP_VALIDATING_RESPONSE, `Schema repair in progress (attempt ${retryCount}/${maxRetries})...`);
+        await reportProgressStepUpdate(reportProgress, toolName, context, STEP_VALIDATING_RESPONSE + retryCount / (maxRetries + 1), `Schema repair in progress (attempt ${retryCount}/${maxRetries})...`);
     }
     catch {
         // Progress updates are best-effort and must not interrupt retries.
@@ -389,13 +394,11 @@ export class ToolExecutionRunner {
             const details = asObjectRecord(record.details);
             const { attempt } = details;
             const msg = `Network error. Retrying (attempt ${String(attempt)})...`;
-            await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, STEP_CALLING_MODEL, msg);
-            await this.updateStatusMessage(msg);
+            await this.reportAndStatus(STEP_CALLING_MODEL, msg);
         }
         else if (record.event === 'gemini_queue_acquired') {
             const msg = 'Model queue acquired, generating response...';
-            await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, STEP_CALLING_MODEL, msg);
-            await this.updateStatusMessage(msg);
+            await this.reportAndStatus(STEP_CALLING_MODEL, msg);
         }
     }
     setResponseSchemaOverride(responseSchema) {
@@ -463,8 +466,7 @@ export class ToolExecutionRunner {
             try {
                 const raw = await generateStructuredJson(createGenerationRequest(this.config, { systemInstruction, prompt: retryPrompt }, this.responseSchema, this.onLog, this.signal));
                 if (attempt === 0) {
-                    await this.updateStatusMessage('Verifying output structure...');
-                    await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, STEP_VALIDATING_RESPONSE, 'Verifying output structure...');
+                    await this.reportAndStatus(STEP_VALIDATING_RESPONSE, 'Verifying output structure...');
                 }
                 parsed = this.config.resultSchema.parse(raw);
                 break;
@@ -492,6 +494,10 @@ export class ToolExecutionRunner {
         }
         return parsed;
     }
+    async reportAndStatus(step, message) {
+        await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, step, message);
+        await this.updateStatusMessage(message);
+    }
     async run(input) {
         try {
             const inputRecord = parseToolInput(input, this.config.fullInputSchema);
@@ -499,23 +505,18 @@ export class ToolExecutionRunner {
             const ctx = {
                 diffSlot: this.hasSnapshot ? this.diffSlotSnapshot : getDiff(),
             };
-            await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, STEP_STARTING, 'Initializing...');
-            await this.updateStatusMessage('Initializing...');
-            await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, STEP_VALIDATING, 'Validating request parameters...');
-            await this.updateStatusMessage('Validating request parameters...');
+            await this.reportAndStatus(STEP_STARTING, 'Initializing...');
+            await this.reportAndStatus(STEP_VALIDATING, 'Validating request parameters...');
             const validationError = await this.executeValidation(inputRecord, ctx);
             if (validationError) {
                 return validationError;
             }
-            await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, STEP_BUILDING_PROMPT, 'Constructing analysis context...');
-            await this.updateStatusMessage('Constructing analysis context...');
+            await this.reportAndStatus(STEP_BUILDING_PROMPT, 'Constructing analysis context...');
             const promptParts = this.config.buildPrompt(inputRecord, ctx);
             const { prompt, systemInstruction } = promptParts;
-            await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, STEP_CALLING_MODEL, 'Querying Gemini model...');
-            await this.updateStatusMessage('Querying Gemini model...');
+            await this.reportAndStatus(STEP_CALLING_MODEL, 'Querying Gemini model...');
             const parsed = await this.executeModelCall(systemInstruction, prompt);
-            await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, STEP_FINALIZING, 'Processing results...');
-            await this.updateStatusMessage('Processing results...');
+            await this.reportAndStatus(STEP_FINALIZING, 'Processing results...');
             const finalResult = (this.config.transformResult
                 ? this.config.transformResult(inputRecord, parsed, ctx)
                 : parsed);
@@ -557,35 +558,54 @@ export function registerStructuredToolTask(server, config) {
         geminiSchema: config.geminiSchema,
         resultSchema: config.resultSchema,
     });
-    server.registerTool(config.name, {
+    server.experimental.tasks.registerToolTask(config.name, {
         title: config.title,
         description: config.description,
         inputSchema: config.inputSchema,
         outputSchema: DefaultOutputSchema,
         annotations: buildToolAnnotations(config.annotations),
-    }, async (input, extra) => {
-        const runner = new ToolExecutionRunner(config, {
-            onLog: async (level, data) => {
-                // Standard logging for tool calls
-                try {
-                    await server.sendLoggingMessage({
-                        level: toLoggingLevel(level),
-                        logger: 'gemini',
-                        data: asObjectRecord(data),
-                    });
-                }
-                catch {
-                    // Fallback if logging fails
-                }
-            },
-            reportProgress: createProgressReporter(extra),
-            statusReporter: {
-                updateStatus: async () => {
-                    // No-op for standard tool calls as they don't have a persistent task status
+        execution: {
+            taskSupport: 'optional',
+        },
+    }, {
+        createTask: async (input, extra) => {
+            const task = await extra.taskStore.createTask({ ttl: 300000 });
+            const extendedStore = extra.taskStore;
+            const runner = new ToolExecutionRunner(config, {
+                onLog: async (level, data) => {
+                    try {
+                        await server.sendLoggingMessage({
+                            level: toLoggingLevel(level),
+                            logger: 'gemini',
+                            data: asObjectRecord(data),
+                        });
+                    }
+                    catch {
+                        // Fallback if logging fails
+                    }
                 },
-            },
-        });
-        runner.setResponseSchemaOverride(responseSchema);
-        return await runner.run(input);
+                reportProgress: createProgressReporter(extra),
+                statusReporter: {
+                    updateStatus: async (message) => {
+                        await extendedStore.updateTaskStatus(task.taskId, 'working', message);
+                    },
+                    storeResult: async (status, result) => {
+                        await extra.taskStore.storeTaskResult(task.taskId, status, result);
+                    },
+                },
+            });
+            runner.setResponseSchemaOverride(responseSchema);
+            // Run in background
+            runner.run(input).catch(async (error) => {
+                await extendedStore.updateTaskStatus(task.taskId, 'failed', getErrorMessage(error));
+            });
+            return { task };
+        },
+        getTask: async (input, extra) => {
+            return await extra.taskStore.getTask(extra.taskId);
+        },
+        getTaskResult: async (input, extra) => {
+            return (await extra.taskStore.getTaskResult(extra.taskId));
+        },
     });
 }

package/dist/lib/tool-response.js

@@ -6,16 +6,17 @@ function appendErrorMeta(error, meta) {
         error.kind = meta.kind;
     }
 }
+function createToolError(code, message, meta) {
+    const error = { code, message };
+    appendErrorMeta(error, meta);
+    return error;
+}
 function toTextContent(structured, textContent) {
     const text = textContent ?? JSON.stringify(structured);
     return [{ type: 'text', text }];
 }
 function createErrorStructuredContent(code, message, result, meta) {
-    const error = {
-        code,
-        message,
-    };
-    appendErrorMeta(error, meta);
+    const error = createToolError(code, message, meta);
     if (result === undefined) {
         return { ok: false, error };
     }

package/dist/lib/types.d.ts

@@ -1,11 +1,12 @@
 export type JsonObject = Record<string, unknown>;
 export type GeminiLogHandler = (level: string, data: unknown) => Promise<void>;
+export type GeminiThinkingLevel = 'minimal' | 'low' | 'medium' | 'high';
 export interface GeminiRequestExecutionOptions {
     maxRetries?: number;
     timeoutMs?: number;
     temperature?: number;
     maxOutputTokens?: number;
-    thinkingLevel?: 'minimal' | 'low' | 'medium' | 'high';
+    thinkingLevel?: GeminiThinkingLevel;
     includeThoughts?: boolean;
     signal?: AbortSignal;
     onLog?: GeminiLogHandler;

package/dist/prompts/index.js

@@ -1,5 +1,6 @@
 import { completable } from '@modelcontextprotocol/sdk/server/completable.js';
 import { z } from 'zod';
+import { toInlineCode } from '../lib/markdown.js';
 import { getToolContract, getToolContractNames, INSPECTION_FOCUS_AREAS, } from '../lib/tool-contracts.js';
 export const PROMPT_DEFINITIONS = [
     {
@@ -34,7 +35,7 @@ function completeByPrefix(values, prefix) {
 function getToolGuide(tool) {
     const contract = getToolContract(tool);
     if (!contract) {
-        return `Use \`${tool}\` to analyze your code changes.`;
+        return `Use ${toInlineCode(tool)} to analyze your code changes.`;
     }
     const { thinkingLevel } = contract;
     const modelLine = thinkingLevel !== undefined
@@ -66,12 +67,14 @@ function registerHelpPrompt(server, instructions) {
     }));
 }
 function buildReviewGuideText(tool, focusArea) {
+    const toolCode = toInlineCode(tool);
+    const suggestToolCode = toInlineCode('suggest_search_replace');
     return (`# Guide: ${tool} / ${focusArea}\n\n` +
-        `## Tool: \`${tool}\`\n${getToolGuide(tool)}\n\n` +
+        `## Tool: ${toolCode}\n${getToolGuide(tool)}\n\n` +
         `## Focus: ${focusArea}\n${getFocusAreaGuide(focusArea)}\n\n` +
         `## Example Fix\n` +
         `Finding: "Uncaught promise rejection"\n` +
-        `Call \`suggest_search_replace\`:\n` +
+        `Call ${suggestToolCode}:\n` +
         '```\n' +
         `search: "  } catch {\\n  }"\n` +
         `replace: "  } catch (err) {\\n    logger.error(err);\\n  }"\n` +

package/dist/resources/index.js

@@ -13,6 +13,16 @@ function completeByPrefix(values, prefix) {
 function createMarkdownContent(uri, text) {
     return { uri: uri.href, mimeType: RESOURCE_MIME_TYPE, text };
 }
+function formatUnknownToolMessage(name) {
+    return `Unknown tool: ${name}`;
+}
+function formatDiffResourceText() {
+    const slot = getDiff();
+    if (!slot) {
+        return '# No diff cached. Call generate_diff first.';
+    }
+    return `# Diff — ${slot.mode} — ${slot.generatedAt}\n# ${slot.stats.files} file(s), +${slot.stats.added} -${slot.stats.deleted}\n\n${slot.diff}`;
+}
 export const STATIC_RESOURCES = [
     {
         id: 'server-instructions',
@@ -77,7 +87,7 @@ function registerToolInfoResources(server) {
     }, (uri, { toolName }) => {
         const name = typeof toolName === 'string' ? toolName : '';
         const info = getToolInfo(name);
-        const text = info ?? `Unknown tool: ${name}`;
+        const text = info ?? formatUnknownToolMessage(name);
         return { contents: [createMarkdownContent(uri, text)] };
     });
 }
@@ -91,13 +101,15 @@ function registerDiffResource(server) {
             audience: RESOURCE_AUDIENCE,
             priority: 1.0,
         },
-    }, (uri) => {
-        const slot = getDiff();
-        const text = slot
-            ? `# Diff — ${slot.mode} — ${slot.generatedAt}\n# ${slot.stats.files} file(s), +${slot.stats.added} -${slot.stats.deleted}\n\n${slot.diff}`
-            : '# No diff cached. Call generate_diff first.';
-        return { contents: [{ uri: uri.href, mimeType: PATCH_MIME_TYPE, text }] };
-    });
+    }, (uri) => ({
+        contents: [
+            {
+                uri: uri.href,
+                mimeType: PATCH_MIME_TYPE,
+                text: formatDiffResourceText(),
+            },
+        ],
+    }));
 }
 export function registerAllResources(server, instructions) {
     for (const def of STATIC_RESOURCES) {

package/dist/resources/instructions.js

@@ -1,12 +1,13 @@
+import { toBulletedList, toInlineCode } from '../lib/markdown.js';
 import { getToolContracts } from '../lib/tool-contracts.js';
 import { PROMPT_DEFINITIONS } from '../prompts/index.js';
 import { DIFF_RESOURCE_DESCRIPTION, STATIC_RESOURCES } from './index.js';
 import { getSharedConstraints } from './tool-info.js';
-const PROMPT_LIST = PROMPT_DEFINITIONS.map((def) => `- \`${def.name}\`: ${def.description}`);
+const PROMPT_LIST = PROMPT_DEFINITIONS.map((def) => `${toInlineCode(def.name)}: ${def.description}`);
 const RESOURCE_LIST = [
-    ...STATIC_RESOURCES.map((def) => `- \`${def.uri}\`: ${def.description}`),
-    '- `internal://tool-info/{toolName}`: Per-tool contract details.',
-    `- \`diff://current\`: ${DIFF_RESOURCE_DESCRIPTION}`,
+    ...STATIC_RESOURCES.map((def) => `${toInlineCode(def.uri)}: ${def.description}`),
+    `${toInlineCode('internal://tool-info/{toolName}')}: Per-tool contract details.`,
+    `${toInlineCode('diff://current')}: ${DIFF_RESOURCE_DESCRIPTION}`,
 ];
 function formatParameterLine(parameter) {
     const req = parameter.required ? 'req' : 'opt';
@@ -41,7 +42,7 @@ export function buildServerInstructions() {
         .map((contract) => `\`${contract.name}\``)
         .join(', ');
     const toolSections = contracts.map((contract) => formatToolSection(contract));
-    const constraintLines = getSharedConstraints().map((constraint) => `- ${constraint}`);
+    const constraintLines = toBulletedList(getSharedConstraints());
     return `# CODE REVIEW ANALYST MCP
 
 ## CORE
@@ -50,16 +51,16 @@ export function buildServerInstructions() {
 - Tools: ${toolNames}
 
 ## PROMPTS
-${PROMPT_LIST.join('\n')}
+${toBulletedList(PROMPT_LIST)}
 
 ## RESOURCES
-${RESOURCE_LIST.join('\n')}
+${toBulletedList(RESOURCE_LIST)}
 
 ## TOOLS
 ${toolSections.join('\n\n')}
 
 ## CONSTRAINTS
-${constraintLines.join('\n')}
+${constraintLines}
 
 ## TASK LIFECYCLE
 - Progress steps (0–6): starting → validating input → building prompt → calling model → validating response → finalizing → done.

package/dist/resources/server-config.js

@@ -1,4 +1,5 @@
 import { createCachedEnvInt } from '../lib/env-config.js';
+import { toInlineCode } from '../lib/markdown.js';
 import { FLASH_MODEL } from '../lib/model-config.js';
 import { getToolContracts } from '../lib/tool-contracts.js';
 const DEFAULT_MAX_DIFF_CHARS = 120_000;
@@ -41,7 +42,7 @@ export function buildServerConfig() {
     const toolRows = getToolContracts()
         .filter((contract) => contract.model !== 'none')
         .map((contract) => {
-        return `| \`${contract.name}\` | \`${contract.model}\` | ${formatThinkingLevel(contract.thinkingLevel)} | ${formatTimeout(contract.timeoutMs)} | ${formatNumber(contract.maxOutputTokens)} |`;
+        return `| ${toInlineCode(contract.name)} | ${toInlineCode(contract.model)} | ${formatThinkingLevel(contract.thinkingLevel)} | ${formatTimeout(contract.timeoutMs)} | ${formatNumber(contract.maxOutputTokens)} |`;
     })
         .join('\n');
     return `# Server Configuration
@@ -50,15 +51,15 @@ export function buildServerConfig() {
 
 | Limit | Value | Env |
 |-------|-------|-----|
-| Diff limit | ${formatNumber(maxDiffChars)} chars | \`MAX_DIFF_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\` |
-| Batch mode | ${batchMode} | \`GEMINI_BATCH_MODE\` |
+| Diff limit | ${formatNumber(maxDiffChars)} chars | ${toInlineCode('MAX_DIFF_CHARS')} |
+| Concurrency limit | ${maxConcurrent} | ${toInlineCode('MAX_CONCURRENT_CALLS')} |
+| Batch concurrency limit | ${maxConcurrentBatch} | ${toInlineCode('MAX_CONCURRENT_BATCH_CALLS')} |
+| Wait timeout | ${formatNumber(concurrentWaitMs)}ms | ${toInlineCode('MAX_CONCURRENT_CALLS_WAIT_MS')} |
+| Batch mode | ${batchMode} | ${toInlineCode('GEMINI_BATCH_MODE')} |
 
 ## Model Assignments
 
-Default model: \`${defaultModel}\` (override with \`GEMINI_MODEL\`)
+Default model: ${toInlineCode(defaultModel)} (override with ${toInlineCode('GEMINI_MODEL')})
 
 | Tool | Model | Thinking Level | Timeout | Max Output Tokens |
 |------|-------|----------------|---------|-------------------|
@@ -66,17 +67,17 @@ ${toolRows}
 
 ## Safety
 
-- Harm block threshold: \`${safetyThreshold}\`
-- Override with \`GEMINI_HARM_BLOCK_THRESHOLD\` (BLOCK_NONE, BLOCK_ONLY_HIGH, BLOCK_MEDIUM_AND_ABOVE, BLOCK_LOW_AND_ABOVE)
+- Harm block threshold: ${toInlineCode(safetyThreshold)}
+- Override with ${toInlineCode('GEMINI_HARM_BLOCK_THRESHOLD')} (BLOCK_NONE, BLOCK_ONLY_HIGH, BLOCK_MEDIUM_AND_ABOVE, BLOCK_LOW_AND_ABOVE)
 
 ## API Keys
 
-- Set \`GEMINI_API_KEY\` or \`GOOGLE_API_KEY\` environment variable (required)
+- Set ${toInlineCode('GEMINI_API_KEY')} or ${toInlineCode('GOOGLE_API_KEY')} environment variable (required)
 
 ## Batch Mode
 
-- \`GEMINI_BATCH_MODE\`: \`off\` (default) or \`inline\`
-- \`GEMINI_BATCH_POLL_INTERVAL_MS\`: poll cadence for batch status checks
-- \`GEMINI_BATCH_TIMEOUT_MS\`: max wait for batch completion
+- ${toInlineCode('GEMINI_BATCH_MODE')}: ${toInlineCode('off')} (default) or ${toInlineCode('inline')}
+- ${toInlineCode('GEMINI_BATCH_POLL_INTERVAL_MS')}: poll cadence for batch status checks
+- ${toInlineCode('GEMINI_BATCH_TIMEOUT_MS')}: max wait for batch completion
 `;
 }

package/dist/resources/tool-catalog.js

@@ -1,13 +1,14 @@
+import { toInlineCode } from '../lib/markdown.js';
 import { buildCoreContextPack } from './tool-info.js';
 const TOOL_CATALOG_CONTENT = `# Tool Catalog Details
 
 ## Optional Parameters
 
-- \`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.
-- \`testFramework\`: Framework hint. \`generate_test_plan\` only.
-- \`maxTestCases\`: Output cap (1–30). \`generate_test_plan\` only.
+- ${toInlineCode('language')}: Primary language hint (auto-detects). All tools except ${toInlineCode('suggest_search_replace')}.
+- ${toInlineCode('focusAreas')}: Focus tags (security, performance, etc.). ${toInlineCode('inspect_code_quality')} only.
+- ${toInlineCode('maxFindings')}: Output cap (1–25). ${toInlineCode('inspect_code_quality')} only.
+- ${toInlineCode('testFramework')}: Framework hint. ${toInlineCode('generate_test_plan')} only.
+- ${toInlineCode('maxTestCases')}: Output cap (1–30). ${toInlineCode('generate_test_plan')} only.
 
 ## Cross-Tool Data Flow
 
@@ -26,12 +27,12 @@ generate_review_summary ──→ overallRisk ──────┤
 
 ## When to Use Each Tool
 
-- **Triage**: \`analyze_pr_impact\`, \`generate_review_summary\`.
-- **Inspection**: \`inspect_code_quality\`.
-- **Fixes**: \`suggest_search_replace\` (one finding/call).
-- **Tests**: \`generate_test_plan\`.
-- **Complexity**: \`analyze_time_space_complexity\`.
-- **Breaking API**: \`detect_api_breaking_changes\`.
+- **Triage**: ${toInlineCode('analyze_pr_impact')}, ${toInlineCode('generate_review_summary')}.
+- **Inspection**: ${toInlineCode('inspect_code_quality')}.
+- **Fixes**: ${toInlineCode('suggest_search_replace')} (one finding/call).
+- **Tests**: ${toInlineCode('generate_test_plan')}.
+- **Complexity**: ${toInlineCode('analyze_time_space_complexity')}.
+- **Breaking API**: ${toInlineCode('detect_api_breaking_changes')}.
 `;
 export function buildToolCatalog() {
     return `${buildCoreContextPack()}\n\n${TOOL_CATALOG_CONTENT}`;

package/dist/resources/tool-info.js

@@ -1,3 +1,4 @@
+import { toBulletedList, toInlineCode } from '../lib/markdown.js';
 import { getToolContract, getToolContracts } from '../lib/tool-contracts.js';
 const GLOBAL_CONSTRAINTS = [
     'Diff budget: <= 120K chars.',
@@ -71,7 +72,7 @@ ${entry.crossToolFlow.map((f) => `- ${f}`).join('\n')}
 `;
 }
 function formatCompactToolRow(entry) {
-    return `| \`${entry.name}\` | ${entry.model} | ${entry.timeout} | ${entry.maxOutputTokens} | ${entry.purpose} |`;
+    return `| ${toInlineCode(entry.name)} | ${entry.model} | ${entry.timeout} | ${entry.maxOutputTokens} | ${entry.purpose} |`;
 }
 export function buildCoreContextPack() {
     const rows = TOOL_NAMES.flatMap((toolName) => {
@@ -91,9 +92,7 @@ export function buildCoreContextPack() {
 ${rows.join('\n')}
 
 ## Shared Constraints
-${getSharedConstraints()
-        .map((constraint) => `- ${constraint}`)
-        .join('\n')}
+${toBulletedList(getSharedConstraints())}
 `;
 }
 export function getSharedConstraints() {

package/dist/resources/workflows.js

@@ -1,3 +1,4 @@
+import { toBulletedList } from '../lib/markdown.js';
 import { getToolContracts } from '../lib/tool-contracts.js';
 import { getSharedConstraints } from './tool-info.js';
 function buildWorkflowToolReference() {
@@ -47,9 +48,7 @@ export function buildWorkflowGuide() {
 > Use for algorithm or API changes. Diff-only input.
 
 ## Shared Constraints
-${getSharedConstraints()
-        .map((constraint) => `- ${constraint}`)
-        .join('\n')}
+${toBulletedList(getSharedConstraints())}
 
 ## Tool Reference
 

package/dist/schemas/inputs.js

@@ -26,17 +26,19 @@ function createRepositorySchema() {
 function createOptionalBoundedInteger(min, max, description) {
     return z.number().int().min(min).max(max).optional().describe(description);
 }
+const RepositorySchema = createRepositorySchema();
+const LanguageSchema = createLanguageSchema();
 export const AnalyzePrImpactInputSchema = z.strictObject({
-    repository: createRepositorySchema(),
-    language: createLanguageSchema(),
+    repository: RepositorySchema,
+    language: LanguageSchema,
 });
 export const GenerateReviewSummaryInputSchema = z.strictObject({
-    repository: createRepositorySchema(),
-    language: createLanguageSchema(),
+    repository: RepositorySchema,
+    language: LanguageSchema,
 });
 export const InspectCodeQualityInputSchema = z.strictObject({
-    repository: createRepositorySchema(),
-    language: createLanguageSchema(),
+    repository: RepositorySchema,
+    language: LanguageSchema,
     focusAreas: z
         .array(createBoundedString(INPUT_LIMITS.focusArea.min, INPUT_LIMITS.focusArea.max, 'Focus tag (e.g. security, logic).'))
         .min(1)
@@ -50,14 +52,14 @@ export const SuggestSearchReplaceInputSchema = z.strictObject({
     findingDetails: createBoundedString(INPUT_LIMITS.findingDetails.min, INPUT_LIMITS.findingDetails.max, 'Exact finding explanation from inspect_code_quality.'),
 });
 export const GenerateTestPlanInputSchema = z.strictObject({
-    repository: createRepositorySchema(),
-    language: createLanguageSchema(),
+    repository: RepositorySchema,
+    language: LanguageSchema,
     testFramework: createOptionalBoundedString(INPUT_LIMITS.testFramework.min, INPUT_LIMITS.testFramework.max, 'Test framework (jest, pytest, etc). Auto-infer.'),
     maxTestCases: createOptionalBoundedInteger(INPUT_LIMITS.maxTestCases.min, INPUT_LIMITS.maxTestCases.max, 'Max test cases (1-30). Default: 15.'),
 });
 export const AnalyzeComplexityInputSchema = z.strictObject({
-    language: createLanguageSchema(),
+    language: LanguageSchema,
 });
 export const DetectApiBreakingInputSchema = z.strictObject({
-    language: createLanguageSchema(),
+    language: LanguageSchema,
 });

package/dist/schemas/outputs.js

@@ -28,6 +28,7 @@ const OUTPUT_LIMITS = {
 };
 const QUALITY_RISK_LEVELS = ['low', 'medium', 'high', 'critical'];
 const MERGE_RISK_LEVELS = ['low', 'medium', 'high'];
+const REVIEW_SUMMARY_LIMITS = OUTPUT_LIMITS.reviewDiffResult.summary;
 const ERROR_KINDS = [
     'validation',
     'budget',
@@ -49,8 +50,8 @@ function createBoundedStringArray(itemMin, itemMax, minItems, maxItems, descript
 function createReviewSummarySchema(description) {
     return z
         .string()
-        .min(OUTPUT_LIMITS.reviewDiffResult.summary.min)
-        .max(OUTPUT_LIMITS.reviewDiffResult.summary.max)
+        .min(REVIEW_SUMMARY_LIMITS.min)
+        .max(REVIEW_SUMMARY_LIMITS.max)
         .describe(description);
 }
 const reviewFindingSeveritySchema = z

package/dist/server.js

@@ -14,6 +14,11 @@ const UTF8_ENCODING = 'utf8';
 const PackageJsonSchema = z.object({
     version: z.string().min(1),
 });
+const TASK_TOOL_CALL_CAPABILITY = {
+    tools: {
+        call: {},
+    },
+};
 const SERVER_CAPABILITIES = {
     logging: {},
     completions: {},
@@ -23,11 +28,7 @@ const SERVER_CAPABILITIES = {
     tasks: {
         list: {},
         cancel: {},
-        requests: {
-            tools: {
-                call: {},
-            },
-        },
+        requests: TASK_TOOL_CALL_CAPABILITY,
     },
 };
 function readUtf8File(path) {

package/dist/tools/analyze-complexity.js

@@ -1,3 +1,4 @@
+import { formatLanguageSegment } from '../lib/format.js';
 import { buildStructuredToolRuntimeOptions, requireToolContract, } from '../lib/tool-contracts.js';
 import { registerStructuredToolTask } from '../lib/tool-factory.js';
 import { AnalyzeComplexityInputSchema } from '../schemas/inputs.js';
@@ -42,9 +43,7 @@ export function registerAnalyzeComplexityTool(server) {
         formatOutput: (result) => `Time=${result.timeComplexity}, Space=${result.spaceComplexity}. ${result.explanation}`,
         buildPrompt: (input, ctx) => {
             const diff = ctx.diffSlot?.diff ?? '';
-            const languageLine = input.language
-                ? `\nLanguage: ${input.language}`
-                : '';
+            const languageLine = formatLanguageSegment(input.language);
             return {
                 systemInstruction: SYSTEM_INSTRUCTION,
                 prompt: `${languageLine}\nDiff:\n${diff}\n\nBased on the diff above, analyze the Big-O time and space complexity.`.trimStart(),

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

@@ -1,4 +1,5 @@
 import { computeDiffStatsAndSummaryFromFiles } from '../lib/diff.js';
+import { formatLanguageSegment } from '../lib/format.js';
 import { buildStructuredToolRuntimeOptions, requireToolContract, } from '../lib/tool-contracts.js';
 import { registerStructuredToolTask } from '../lib/tool-factory.js';
 import { AnalyzePrImpactInputSchema } from '../schemas/inputs.js';
@@ -24,9 +25,6 @@ Analyze the unified diff to assess:
 </constraints>
 `;
 const TOOL_CONTRACT = requireToolContract('analyze_pr_impact');
-function formatLanguageSegment(language) {
-    return language ? `\nLanguage: ${language}` : '';
-}
 export function registerAnalyzePrImpactTool(server) {
     registerStructuredToolTask(server, {
         name: 'analyze_pr_impact',

package/dist/tools/detect-api-breaking.js

@@ -1,3 +1,4 @@
+import { formatLanguageSegment } from '../lib/format.js';
 import { buildStructuredToolRuntimeOptions, requireToolContract, } from '../lib/tool-contracts.js';
 import { registerStructuredToolTask } from '../lib/tool-factory.js';
 import { DetectApiBreakingInputSchema } from '../schemas/inputs.js';
@@ -41,9 +42,7 @@ export function registerDetectApiBreakingTool(server) {
             : 'No breaking changes.',
         buildPrompt: (input, ctx) => {
             const diff = ctx.diffSlot?.diff ?? '';
-            const languageLine = input.language
-                ? `\nLanguage: ${input.language}`
-                : '';
+            const languageLine = formatLanguageSegment(input.language);
             return {
                 systemInstruction: SYSTEM_INSTRUCTION,
                 prompt: `${languageLine}\nDiff:\n${diff}\n\nBased on the diff above, detect any breaking API changes.`.trimStart(),

package/dist/tools/generate-diff.js

@@ -38,6 +38,13 @@ function describeModeHint(mode) {
         ? 'staged with git add'
         : 'modified but not yet staged (git add)';
 }
+function formatGitFailureMessage(err) {
+    if (typeof err.code === 'number') {
+        const stderr = err.stderr?.trim() ?? 'unknown error';
+        return `git exited with code ${String(err.code)}: ${stderr}. Ensure the working directory is a git repository.`;
+    }
+    return `Failed to run git: ${err.message}. Ensure git is installed and the working directory is a git repository.`;
+}
 export function registerGenerateDiffTool(server) {
     server.registerTool('generate_diff', {
         title: 'Generate Diff',
@@ -90,11 +97,7 @@ export function registerGenerateDiffTool(server) {
         }
         catch (error) {
             const err = error;
-            if (err.code && typeof err.code === 'number') {
-                const stderr = err.stderr ? err.stderr.trim() : '';
-                return createErrorToolResponse('E_GENERATE_DIFF', `git exited with code ${String(err.code)}: ${stderr || 'unknown error'}. Ensure the working directory is a git repository.`, undefined, { retryable: false, kind: 'internal' });
-            }
-            return createErrorToolResponse('E_GENERATE_DIFF', `Failed to run git: ${err.message}. Ensure git is installed and the working directory is a git repository.`, undefined, { retryable: false, kind: 'internal' });
+            return createErrorToolResponse('E_GENERATE_DIFF', formatGitFailureMessage(err), undefined, { retryable: false, kind: 'internal' });
         }
     }));
 }

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

@@ -1,3 +1,4 @@
+import { formatLanguageSegment } from '../lib/format.js';
 import { buildStructuredToolRuntimeOptions, requireToolContract, } from '../lib/tool-contracts.js';
 import { registerStructuredToolTask, } from '../lib/tool-factory.js';
 import { GenerateReviewSummaryInputSchema } from '../schemas/inputs.js';
@@ -25,9 +26,6 @@ Summarize the pull request based on the diff:
 - Return valid JSON matching the schema.
 </constraints>
 `;
-function formatLanguageSegment(language) {
-    return language ? `\nLanguage: ${language}` : '';
-}
 function getDiffStats(ctx) {
     const slot = ctx.diffSlot;
     if (!slot) {

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

@@ -1,4 +1,5 @@
 import { computeDiffStatsAndPathsFromFiles } from '../lib/diff.js';
+import { formatOptionalLine } from '../lib/format.js';
 import { buildStructuredToolRuntimeOptions, requireToolContract, } from '../lib/tool-contracts.js';
 import { registerStructuredToolTask } from '../lib/tool-factory.js';
 import { GenerateTestPlanInputSchema } from '../schemas/inputs.js';
@@ -22,9 +23,6 @@ Generate a prioritized test plan for the provided diff:
 </constraints>
 `;
 const TOOL_CONTRACT = requireToolContract('generate_test_plan');
-function formatOptionalLine(label, value) {
-    return value === undefined ? '' : `\n${label}: ${value}`;
-}
 export function registerGenerateTestPlanTool(server) {
     registerStructuredToolTask(server, {
         name: 'generate_test_plan',

package/dist/tools/index.js

@@ -17,7 +17,7 @@ const TOOL_REGISTRARS = [
     registerDetectApiBreakingTool,
 ];
 export function registerAllTools(server) {
-    for (const registrar of TOOL_REGISTRARS) {
+    TOOL_REGISTRARS.forEach((registrar) => {
         registrar(server);
-    }
+    });
 }

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

@@ -1,4 +1,5 @@
 import { computeDiffStatsAndSummaryFromFiles } from '../lib/diff.js';
+import { formatOptionalLine } from '../lib/format.js';
 import { buildStructuredToolRuntimeOptions, requireToolContract, } from '../lib/tool-contracts.js';
 import { registerStructuredToolTask } from '../lib/tool-factory.js';
 import { InspectCodeQualityInputSchema } from '../schemas/inputs.js';
@@ -25,9 +26,6 @@ Perform a deep code review of the provided diff:
 </constraints>
 `;
 const TOOL_CONTRACT = requireToolContract('inspect_code_quality');
-function formatOptionalLine(label, value) {
-    return value === undefined ? '' : `\n${label}: ${value}`;
-}
 function capFindings(findings, maxFindings) {
     return findings.slice(0, maxFindings ?? findings.length);
 }

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

@@ -1,4 +1,5 @@
 import { extractChangedPathsFromFiles } from '../lib/diff.js';
+import { formatCountLabel } from '../lib/format.js';
 import { buildStructuredToolRuntimeOptions, requireToolContract, } from '../lib/tool-contracts.js';
 import { registerStructuredToolTask } from '../lib/tool-factory.js';
 import { SuggestSearchReplaceInputSchema } from '../schemas/inputs.js';
@@ -24,7 +25,7 @@ Generate minimal search-and-replace blocks to fix the described issue:
 `;
 const TOOL_CONTRACT = requireToolContract('suggest_search_replace');
 function formatPatchCount(count) {
-    return `${count} ${count === 1 ? 'patch' : 'patches'}`;
+    return formatCountLabel(count, 'patch', 'patches');
 }
 export function registerSuggestSearchReplaceTool(server) {
     registerStructuredToolTask(server, {

package/package.json

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