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

package/dist/lib/diff-cleaner.js

@@ -33,6 +33,14 @@ function shouldKeepSection(section) {
     }
     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")
@@ -46,25 +54,21 @@ export function cleanDiff(raw) {
     if (!raw)
         return '';
     const sections = [];
-    const delimiter = /^diff --git /gm;
     let lastIndex = 0;
-    let match;
-    while ((match = delimiter.exec(raw)) !== null) {
-        if (match.index > lastIndex) {
-            const section = raw.slice(lastIndex, match.index);
-            if (shouldKeepSection(section)) {
-                sections.push(section);
-            }
-        }
-        lastIndex = match.index;
+    let nextIndex = raw.startsWith('diff --git ')
+        ? 0
+        : raw.indexOf('\ndiff --git ');
+    if (nextIndex === -1) {
+        processSection(raw, 0, raw.length, sections);
+        return sections.join('').trim();
     }
-    // Process the last section
-    if (lastIndex < raw.length) {
-        const section = raw.slice(lastIndex);
-        if (shouldKeepSection(section)) {
-            sections.push(section);
-        }
+    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) {

package/dist/lib/diff-store.js

@@ -1,5 +1,8 @@
+import { createCachedEnvInt } from './env-config.js';
 import { createErrorToolResponse } from './tool-response.js';
 export const DIFF_RESOURCE_URI = 'diff://current';
+const diffCacheTtlMs = createCachedEnvInt('DIFF_CACHE_TTL_MS', 60 * 60 * 1_000 // 1 hour default
+);
 const diffSlots = new Map();
 let sendResourceUpdated;
 function setDiffSlot(key, data) {
@@ -29,7 +32,16 @@ export function storeDiff(data, key = process.cwd()) {
     notifyDiffUpdated();
 }
 export function getDiff(key = process.cwd()) {
-    return diffSlots.get(key);
+    const slot = diffSlots.get(key);
+    if (!slot) {
+        return undefined;
+    }
+    const age = Date.now() - new Date(slot.generatedAt).getTime();
+    if (age > diffCacheTtlMs.get()) {
+        diffSlots.delete(key);
+        return undefined;
+    }
+    return slot;
 }
 export function hasDiff(key = process.cwd()) {
     return diffSlots.has(key);

package/dist/lib/tool-factory.js

@@ -8,7 +8,14 @@ import { stripJsonSchemaConstraints } from './gemini-schema.js';
 import { generateStructuredJson, getCurrentRequestId } from './gemini.js';
 import { createErrorToolResponse, createToolResponse, } from './tool-response.js';
 const DEFAULT_TASK_TTL_MS = 30 * 60 * 1_000;
-const TASK_PROGRESS_TOTAL = 4;
+// Named progress step indices for 7-step progress (0–6).
+const STEP_STARTING = 0;
+const STEP_VALIDATING = 1;
+const STEP_BUILDING_PROMPT = 2;
+const STEP_CALLING_MODEL = 3;
+const STEP_VALIDATING_RESPONSE = 4;
+const STEP_FINALIZING = 5;
+const TASK_PROGRESS_TOTAL = STEP_FINALIZING + 1;
 const INPUT_VALIDATION_FAILED = 'Input validation failed';
 const DEFAULT_PROGRESS_CONTEXT = 'request';
 const CANCELLED_ERROR_PATTERN = /cancelled|canceled/i;
@@ -240,7 +247,7 @@ async function reportProgressCompletionUpdate(reportProgress, toolName, context,
 }
 async function reportSchemaRetryProgressBestEffort(reportProgress, toolName, context, retryCount, maxRetries) {
     try {
-        await reportProgressStepUpdate(reportProgress, toolName, context, 3, `repairing schema retry ${retryCount}/${maxRetries}`);
+        await reportProgressStepUpdate(reportProgress, toolName, context, STEP_VALIDATING_RESPONSE, `schema repair ${retryCount}/${maxRetries}`);
     }
     catch {
         // Progress updates are best-effort and must not interrupt retries.
@@ -281,7 +288,15 @@ function createGeminiLogger(server, taskId) {
             });
         }
         catch {
-            // Logging is best-effort; never fail the tool call.
+            try {
+                const timestamp = new Date().toISOString();
+                const payload = JSON.stringify(asObjectRecord(data));
+                console.error(`[${timestamp}] [gemini:${level}] ${taskId} - ${payload}`);
+            }
+            catch {
+                // Safe fallback if JSON stringify fails
+                console.error(`[gemini:${level}] ${taskId} - (logging failed)`);
+            }
         }
     };
 }
@@ -387,8 +402,19 @@ export class ToolTaskRunner {
     async executeValidation(inputRecord, ctx) {
         const validationError = await validateRequest(this.config, inputRecord, ctx);
         if (validationError) {
-            const validationMessage = validationError.structuredContent.error?.message ??
-                INPUT_VALIDATION_FAILED;
+            let validationMessage = INPUT_VALIDATION_FAILED;
+            try {
+                const text = validationError.content[0]?.text;
+                if (text) {
+                    const parsed = JSON.parse(text);
+                    if (parsed.error?.message) {
+                        validationMessage = parsed.error.message;
+                    }
+                }
+            }
+            catch {
+                // fallback to default
+            }
             await this.updateStatusMessage(validationMessage);
             await reportProgressCompletionUpdate(this.reportProgress, this.config.name, this.progressContext, 'rejected');
             await this.storeResultSafely('completed', validationError);
@@ -404,7 +430,8 @@ export class ToolTaskRunner {
             try {
                 const raw = await generateStructuredJson(createGenerationRequest(this.config, { systemInstruction, prompt: retryPrompt }, this.responseSchema, this.onLog, this.extra.signal));
                 if (attempt === 0) {
-                    await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, 3, 'validating response');
+                    await this.updateStatusMessage('validating response');
+                    await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, STEP_VALIDATING_RESPONSE, 'validating response');
                 }
                 parsed = this.config.resultSchema.parse(raw);
                 break;
@@ -441,16 +468,23 @@ export class ToolTaskRunner {
             const ctx = {
                 diffSlot: this.hasSnapshot ? this.diffSlotSnapshot : getDiff(),
             };
-            await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, 0, 'starting');
+            await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, STEP_STARTING, 'starting');
+            await this.updateStatusMessage('starting');
+            await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, STEP_VALIDATING, 'validating input');
+            await this.updateStatusMessage('validating input');
             if (!(await this.executeValidation(inputRecord, ctx))) {
                 return;
             }
-            await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, 1, 'building prompt');
+            await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, STEP_BUILDING_PROMPT, 'building prompt');
+            await this.updateStatusMessage('building prompt');
             const promptParts = this.config.buildPrompt(inputRecord, ctx);
             const { prompt, systemInstruction } = promptParts;
             const modelLabel = friendlyModelName(this.config.model);
-            await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, 2, modelLabel);
+            await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, STEP_CALLING_MODEL, modelLabel);
+            await this.updateStatusMessage(modelLabel);
             const parsed = await this.executeModelCall(systemInstruction, prompt);
+            await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, STEP_FINALIZING, 'finalizing');
+            await this.updateStatusMessage('finalizing');
             const finalResult = (this.config.transformResult
                 ? this.config.transformResult(inputRecord, parsed, ctx)
                 : parsed);
@@ -459,6 +493,7 @@ export class ToolTaskRunner {
                 : undefined;
             const outcome = this.config.formatOutcome?.(finalResult) ?? 'completed';
             await reportProgressCompletionUpdate(this.reportProgress, this.config.name, this.progressContext, outcome);
+            await this.updateStatusMessage(`completed: ${outcome}`);
             await this.storeResultSafely('completed', createToolResponse({
                 ok: true,
                 result: finalResult,

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

@@ -24,7 +24,9 @@ interface ToolResponse<TStructuredContent extends ToolStructuredContent> {
     content: ToolTextContent[];
     structuredContent: TStructuredContent;
 }
-interface ErrorToolResponse extends ToolResponse<ToolStructuredContent> {
+interface ErrorToolResponse {
+    [key: string]: unknown;
+    content: ToolTextContent[];
     isError: true;
 }
 export declare function createToolResponse<TStructuredContent extends ToolStructuredContent>(structured: TStructuredContent, textContent?: string): ToolResponse<TStructuredContent>;

package/dist/lib/tool-response.js

@@ -29,5 +29,8 @@ export function createToolResponse(structured, textContent) {
 }
 export function createErrorToolResponse(code, message, result, meta) {
     const structured = createErrorStructuredContent(code, message, result, meta);
-    return { ...createToolResponse(structured), isError: true };
+    return {
+        content: toTextContent(structured),
+        isError: true,
+    };
 }

package/dist/prompts/index.js

@@ -17,13 +17,13 @@ const TOOLS = getToolContractNames();
 const TOOL_DESCRIPTION_TEXT = 'Select tool for review guide.';
 const FOCUS_DESCRIPTION_TEXT = 'Select focus area.';
 const FOCUS_AREA_GUIDES = {
-    security: 'Focus: Injection, auth, crypto, OWASP.',
-    correctness: 'Focus: Logic, edge cases, algorithms, contracts.',
-    performance: 'Focus: Complexity, allocations, I/O, queries.',
-    regressions: 'Focus: Behavior changes, guards, types, breaks.',
-    tests: 'Focus: Coverage, edge cases, flakes, error paths.',
-    maintainability: 'Focus: Complexity, readability, structure, patterns.',
-    concurrency: 'Focus: Race conditions, deadlocks, shared state.',
+    security: 'Focus: Injection (SQL/XSS), auth, crypto, OWASP Top 10.',
+    correctness: 'Focus: Logic errors, edge cases, algorithm validity, type safety.',
+    performance: 'Focus: Big-O complexity, memory allocations, I/O latency, N+1 queries.',
+    regressions: 'Focus: Behavior changes, missing guards, breaking API changes.',
+    tests: 'Focus: Missing coverage, flaky tests, error paths.',
+    maintainability: 'Focus: Code complexity, readability, DRY violations, patterns.',
+    concurrency: 'Focus: Race conditions, deadlocks, lack of atomicity.',
 };
 function isFocusArea(value) {
     return INSPECTION_FOCUS_AREAS.includes(value);

package/dist/resources/instructions.js

@@ -60,6 +60,11 @@ ${toolSections.join('\n\n')}
 
 ## CONSTRAINTS
 ${constraintLines.join('\n')}
+
+## TASK LIFECYCLE
+- Progress steps (0–6): starting → validating input → building prompt → calling model → validating response → finalizing → done.
+- Status messages update at each phase for task introspection.
+- Schema repair: on validation failure, retries with error feedback (configurable via \`GEMINI_SCHEMA_RETRIES\`).
 - Task terminal states: \`completed\` and \`failed\`; cancellations are surfaced as \`failed\` with \`error.kind=cancelled\`.
 `;
 }

package/dist/tools/analyze-complexity.js

@@ -6,7 +6,7 @@ const SYSTEM_INSTRUCTION = `
 Algorithm Complexity Analyst.
 Analyze Big-O time/space complexity for changes.
 Detect performance degradation vs original.
-Identify bottlenecks (loops, recursion, aux structures).
+Identify bottlenecks: nested loops, unbounded recursion, heavy allocations.
 Return strict JSON.
 `;
 const TOOL_CONTRACT = requireToolContract('analyze_time_space_complexity');
@@ -35,7 +35,7 @@ export function registerAnalyzeComplexityTool(server) {
                 : '';
             return {
                 systemInstruction: SYSTEM_INSTRUCTION,
-                prompt: `${languageLine}\\nDiff:\\n${diff}\\n\\nBased on the diff above, analyze the Big-O time and space complexity.`.trimStart(),
+                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

@@ -5,7 +5,7 @@ import { AnalyzePrImpactInputSchema } from '../schemas/inputs.js';
 import { PrImpactResultSchema } from '../schemas/outputs.js';
 const SYSTEM_INSTRUCTION = `
 Technical Change Analyst.
-Analyze diff for objective impact: severity, categories, breaking changes, affected areas, rollback complexity.
+Assess objective impact: severity, risk categories, breaking changes, rollback cost.
 Strictly diff-based; no inference.
 Return strict JSON.
 `;
@@ -27,6 +27,7 @@ export function registerAnalyzePrImpactTool(server) {
         maxOutputTokens: TOOL_CONTRACT.maxOutputTokens,
         ...buildStructuredToolRuntimeOptions(TOOL_CONTRACT),
         requiresDiff: true,
+        progressContext: (input) => input.repository,
         formatOutcome: (result) => `severity: ${result.severity}`,
         formatOutput: (result) => `[${result.severity}] ${result.summary}`,
         buildPrompt: (input, ctx) => {

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

@@ -5,8 +5,8 @@ import { DetectApiBreakingResultSchema } from '../schemas/outputs.js';
 const SYSTEM_INSTRUCTION = `
 API Compatibility Analyst.
 Detect breaking changes to public APIs/contracts/interfaces.
-Breaking = consumer update required.
-Classify: element, nature, impact, mitigation.
+Definition: Breaking change = requires consumer code modification.
+Output: element, nature, impact, mitigation.
 Return strict JSON.
 `;
 const TOOL_CONTRACT = requireToolContract('detect_api_breaking_changes');
@@ -35,7 +35,7 @@ export function registerDetectApiBreakingTool(server) {
                 : '';
             return {
                 systemInstruction: SYSTEM_INSTRUCTION,
-                prompt: `${languageLine}\\nDiff:\\n${diff}\\n\\nBased on the diff above, detect any breaking API changes.`.trimStart(),
+                prompt: `${languageLine}\nDiff:\n${diff}\n\nBased on the diff above, detect any breaking API changes.`.trimStart(),
             };
         },
     });

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

@@ -9,7 +9,7 @@ const TOOL_CONTRACT = requireToolContract('generate_review_summary');
 const SYSTEM_INSTRUCTION = `
 Senior Code Reviewer.
 Summarize PR: risk, key changes, merge recommendation (merge/squash/block).
-Specific logic changes only.
+Focus: Logic/behavior changes. Ignore: formatting/style/typos.
 Return strict JSON.
 `;
 function formatLanguageSegment(language) {
@@ -41,6 +41,7 @@ export function registerGenerateReviewSummaryTool(server) {
         maxOutputTokens: TOOL_CONTRACT.maxOutputTokens,
         ...buildStructuredToolRuntimeOptions(TOOL_CONTRACT),
         requiresDiff: true,
+        progressContext: (input) => input.repository,
         formatOutcome: (result) => `risk: ${result.overallRisk}`,
         transformResult: (_input, result, ctx) => {
             const { files, added, deleted } = getDiffStats(ctx);

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

@@ -5,9 +5,9 @@ import { GenerateTestPlanInputSchema } from '../schemas/inputs.js';
 import { TestPlanResultSchema } from '../schemas/outputs.js';
 const SYSTEM_INSTRUCTION = `
 QA Automation Architect.
-Test plan for diff.
-Prioritize: negative, edge, branches, integration.
-Target specific visible behavior.
+Generate test plan for diff.
+Prioritize: negative cases, edge cases, branch coverage, integration points.
+Focus: observable behavior only.
 Return strict JSON.
 `;
 const TOOL_CONTRACT = requireToolContract('generate_test_plan');
@@ -28,6 +28,7 @@ export function registerGenerateTestPlanTool(server) {
         maxOutputTokens: TOOL_CONTRACT.maxOutputTokens,
         ...buildStructuredToolRuntimeOptions(TOOL_CONTRACT),
         requiresDiff: true,
+        progressContext: (input) => input.repository,
         formatOutcome: (result) => `${result.testCases.length} test cases`,
         formatOutput: (result) => `${result.summary}\n${result.testCases.length} test cases.`,
         transformResult: (input, result) => {

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

@@ -18,7 +18,7 @@ const SYSTEM_INSTRUCTION = `
 Principal Engineer Code Review.
 Source: Unified diff (primary), File excerpts (supplementary context).
 Goal: Identify bugs, security, performance, maintainability.
-Ignore style. Prioritize correctness/failure modes.
+Constraint: Ignore style/formatting. Prioritize correctness/failure modes.
 Return strict JSON.
 `;
 const TOOL_CONTRACT = requireToolContract('inspect_code_quality');

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

@@ -6,8 +6,8 @@ import { SearchReplaceResultSchema } from '../schemas/outputs.js';
 const SYSTEM_INSTRUCTION = `
 Code Remediation Expert.
 Generate minimal search/replace blocks for described issue.
-CRITICAL: 'search' must be verbatim (exact whitespace/indentation).
-No out-of-scope changes. Omit if imprecise.
+Constraint: 'search' must be verbatim (exact whitespace/indentation).
+Constraint: No context drift. Omit patch if exact match uncertain.
 Return strict JSON.
 `;
 const TOOL_CONTRACT = requireToolContract('suggest_search_replace');
@@ -28,6 +28,7 @@ export function registerSuggestSearchReplaceTool(server) {
         maxOutputTokens: TOOL_CONTRACT.maxOutputTokens,
         ...buildStructuredToolRuntimeOptions(TOOL_CONTRACT),
         requiresDiff: true,
+        progressContext: (input) => input.findingTitle,
         formatOutcome: (result) => formatPatchCount(result.blocks.length),
         formatOutput: (result) => {
             const count = result.blocks.length;

package/package.json

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