@j0hanz/code-review-analyst-mcp 1.7.1 → 1.7.2

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

@@ -123,6 +123,7 @@ export declare class ToolExecutionRunner<TInput extends object, TResult extends
         reportProgress: (payload: ProgressPayload) => Promise<void>;
         statusReporter: TaskStatusReporter;
     }, signal?: AbortSignal | undefined);
+    private handleInternalLog;
     setResponseSchemaOverride(responseSchema: Record<string, unknown>): void;
     setDiffSlotSnapshot(diffSlotSnapshot: DiffSlot | undefined): void;
     private updateStatusMessage;

package/dist/lib/tool-factory.js

@@ -241,7 +241,7 @@ function normalizeProgressContext(context) {
     return `${compact.slice(0, 77)}...`;
 }
 function formatProgressStep(toolName, context, metadata) {
-    return `${toolName}: ${context} [${metadata}]`;
+    return `${toolName}: ${context} • ${metadata}`;
 }
 function formatProgressCompletion(toolName, context, outcome) {
     return `🗒 ${toolName}: ${context} • ${outcome}`;
@@ -276,7 +276,7 @@ async function reportProgressCompletionUpdate(reportProgress, toolName, context,
 }
 async function reportSchemaRetryProgressBestEffort(reportProgress, toolName, context, retryCount, maxRetries) {
     try {
-        await reportProgressStepUpdate(reportProgress, toolName, context, STEP_VALIDATING_RESPONSE, `schema repair ${retryCount}/${maxRetries}`);
+        await reportProgressStepUpdate(reportProgress, toolName, context, STEP_VALIDATING_RESPONSE, `Schema repair in progress (attempt ${retryCount}/${maxRetries})...`);
     }
     catch {
         // Progress updates are best-effort and must not interrupt retries.
@@ -370,10 +370,28 @@ export class ToolExecutionRunner {
         this.config = config;
         this.signal = signal;
         this.responseSchema = getCachedGeminiResponseSchema(config);
-        this.onLog = dependencies.onLog;
         this.reportProgress = dependencies.reportProgress;
         this.statusReporter = dependencies.statusReporter;
         this.progressContext = DEFAULT_PROGRESS_CONTEXT;
+        this.onLog = async (level, data) => {
+            try {
+                await dependencies.onLog(level, data);
+            }
+            catch {
+                // Ignore logging failures
+            }
+            await this.handleInternalLog(data);
+        };
+    }
+    async handleInternalLog(data) {
+        const record = asObjectRecord(data);
+        if (record.event === 'gemini_retry') {
+            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);
+        }
     }
     setResponseSchemaOverride(responseSchema) {
         this.responseSchema = responseSchema;
@@ -440,8 +458,8 @@ 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('validating response');
-                    await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, STEP_VALIDATING_RESPONSE, 'validating response');
+                    await this.updateStatusMessage('Verifying output structure...');
+                    await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, STEP_VALIDATING_RESPONSE, 'Verifying output structure...');
                 }
                 parsed = this.config.resultSchema.parse(raw);
                 break;
@@ -476,23 +494,23 @@ export class ToolExecutionRunner {
             const ctx = {
                 diffSlot: this.hasSnapshot ? this.diffSlotSnapshot : getDiff(),
             };
-            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');
+            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...');
             const validationError = await this.executeValidation(inputRecord, ctx);
             if (validationError) {
                 return validationError;
             }
-            await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, STEP_BUILDING_PROMPT, 'building prompt');
-            await this.updateStatusMessage('building prompt');
+            await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, STEP_BUILDING_PROMPT, 'Constructing analysis context...');
+            await this.updateStatusMessage('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, 'calling model');
-            await this.updateStatusMessage('calling model');
+            await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, STEP_CALLING_MODEL, 'Querying Gemini model...');
+            await this.updateStatusMessage('Querying Gemini model...');
             const parsed = await this.executeModelCall(systemInstruction, prompt);
-            await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, STEP_FINALIZING, 'finalizing');
-            await this.updateStatusMessage('finalizing');
+            await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, STEP_FINALIZING, 'Processing results...');
+            await this.updateStatusMessage('Processing results...');
             const finalResult = (this.config.transformResult
                 ? this.config.transformResult(inputRecord, parsed, ctx)
                 : parsed);
@@ -503,7 +521,7 @@ export class ToolExecutionRunner {
                 const ageMs = Date.now() - new Date(ctx.diffSlot.generatedAt).getTime();
                 if (ageMs > diffStaleWarningMs.get()) {
                     const ageMinutes = Math.round(ageMs / 60_000);
-                    const warning = `\n\n⚠️ Warning: The analyzed diff is over ${ageMinutes} minutes old. If you have made recent changes, please run generate_diff again.`;
+                    const warning = `\n\nWarning: The analyzed diff is over ${ageMinutes} minutes old. If you have made recent changes, please run generate_diff again.`;
                     textContent = textContent ? textContent + warning : warning;
                 }
             }

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 (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.',
+    security: 'Focus: Injection, Auth, Crypto, OWASP.',
+    correctness: 'Focus: Logic, Edge Cases, Types.',
+    performance: 'Focus: Complexity, Memory, Latency.',
+    regressions: 'Focus: Behavior Changes, Breaking APIs.',
+    tests: 'Focus: Coverage, Error Paths.',
+    maintainability: 'Focus: Complexity, Readability, Patterns.',
+    concurrency: 'Focus: Races, Deadlocks, Atomicity.',
 };
 function isFocusArea(value) {
     return INSPECTION_FOCUS_AREAS.includes(value);

package/dist/tools/analyze-complexity.js

@@ -3,11 +3,23 @@ import { registerStructuredToolTask } from '../lib/tool-factory.js';
 import { AnalyzeComplexityInputSchema } from '../schemas/inputs.js';
 import { AnalyzeComplexityResultSchema } from '../schemas/outputs.js';
 const SYSTEM_INSTRUCTION = `
+<role>
 Algorithm Complexity Analyst.
-Analyze Big-O time/space complexity for changes.
-Detect performance degradation vs original.
-Identify bottlenecks: nested loops, unbounded recursion, heavy allocations.
-Return strict JSON.
+You are an expert in Big-O analysis and performance optimization.
+</role>
+
+<task>
+Analyze the time and space complexity of the code changes:
+- Compare new complexity vs. original implementation.
+- Detect performance degradation (regression).
+- Identify bottlenecks (nested loops, recursion, allocations).
+</task>
+
+<constraints>
+- Focus on the changed code paths.
+- Flag degradation only if complexity class worsens (e.g., O(n) -> O(n^2)).
+- Return valid JSON matching the schema.
+</constraints>
 `;
 const TOOL_CONTRACT = requireToolContract('analyze_time_space_complexity');
 export function registerAnalyzeComplexityTool(server) {
@@ -23,6 +35,7 @@ export function registerAnalyzeComplexityTool(server) {
         maxOutputTokens: TOOL_CONTRACT.maxOutputTokens,
         ...buildStructuredToolRuntimeOptions(TOOL_CONTRACT),
         requiresDiff: true,
+        progressContext: (input) => input.language ?? 'auto-detect',
         formatOutcome: (result) => result.isDegradation
             ? 'Performance degradation detected'
             : 'No degradation',

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

@@ -4,10 +4,24 @@ import { registerStructuredToolTask } from '../lib/tool-factory.js';
 import { AnalyzePrImpactInputSchema } from '../schemas/inputs.js';
 import { PrImpactResultSchema } from '../schemas/outputs.js';
 const SYSTEM_INSTRUCTION = `
+<role>
 Technical Change Analyst.
-Assess objective impact: severity, risk categories, breaking changes, rollback cost.
-Strictly diff-based; no inference.
-Return strict JSON.
+You are a strict, objective auditor of code changes.
+</role>
+
+<task>
+Analyze the unified diff to assess:
+- Severity (low/medium/high/critical)
+- Risk categories (security, stability, etc.)
+- Breaking changes (API, contract, schema)
+- Rollback complexity
+</task>
+
+<constraints>
+- Base analysis ONLY on the provided diff. No external inference.
+- Ignore formatting/style changes unless they affect logic.
+- Return valid JSON matching the schema.
+</constraints>
 `;
 const TOOL_CONTRACT = requireToolContract('analyze_pr_impact');
 function formatLanguageSegment(language) {

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

@@ -3,11 +3,22 @@ import { registerStructuredToolTask } from '../lib/tool-factory.js';
 import { DetectApiBreakingInputSchema } from '../schemas/inputs.js';
 import { DetectApiBreakingResultSchema } from '../schemas/outputs.js';
 const SYSTEM_INSTRUCTION = `
+<role>
 API Compatibility Analyst.
-Detect breaking changes to public APIs/contracts/interfaces.
-Definition: Breaking change = requires consumer code modification.
-Output: element, nature, impact, mitigation.
-Return strict JSON.
+You are a strict guardian of public interfaces and contracts.
+</role>
+
+<task>
+Detect breaking changes in public APIs, interfaces, or schemas:
+- Identify changes that require consumer code modification.
+- classify the nature, impact, and mitigation for each break.
+</task>
+
+<constraints>
+- Definition: Breaking change = backwards-incompatible modification.
+- Ignore internal/private APIs unless exported.
+- Return valid JSON matching the schema.
+</constraints>
 `;
 const TOOL_CONTRACT = requireToolContract('detect_api_breaking_changes');
 export function registerDetectApiBreakingTool(server) {
@@ -23,6 +34,7 @@ export function registerDetectApiBreakingTool(server) {
         maxOutputTokens: TOOL_CONTRACT.maxOutputTokens,
         ...buildStructuredToolRuntimeOptions(TOOL_CONTRACT),
         requiresDiff: true,
+        progressContext: (input) => input.language ?? 'auto-detect',
         formatOutcome: (result) => `${result.breakingChanges.length} breaking change(s) found`,
         formatOutput: (result) => result.hasBreakingChanges
             ? `${result.breakingChanges.length} breaking changes found.`

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

@@ -7,10 +7,23 @@ const ReviewSummaryModelSchema = ReviewSummaryResultSchema.omit({
 });
 const TOOL_CONTRACT = requireToolContract('generate_review_summary');
 const SYSTEM_INSTRUCTION = `
+<role>
 Senior Code Reviewer.
-Summarize PR: risk, key changes, merge recommendation (merge/squash/block).
-Focus: Logic/behavior changes. Ignore: formatting/style/typos.
-Return strict JSON.
+You are a pragmatic engineer focused on stability and maintainability.
+</role>
+
+<task>
+Summarize the pull request based on the diff:
+- Assess overall risk (low/medium/high).
+- Highlight key logic/behavior changes.
+- Recommend action: merge, squash, or block.
+</task>
+
+<constraints>
+- Focus on logic and behavior; ignore style, formatting, and typos.
+- Be concise and actionable.
+- Return valid JSON matching the schema.
+</constraints>
 `;
 function formatLanguageSegment(language) {
     return language ? `\nLanguage: ${language}` : '';

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

@@ -4,11 +4,22 @@ import { registerStructuredToolTask } from '../lib/tool-factory.js';
 import { GenerateTestPlanInputSchema } from '../schemas/inputs.js';
 import { TestPlanResultSchema } from '../schemas/outputs.js';
 const SYSTEM_INSTRUCTION = `
+<role>
 QA Automation Architect.
-Generate test plan for diff.
-Prioritize: negative cases, edge cases, branch coverage, integration points.
-Focus: observable behavior only.
-Return strict JSON.
+You are an expert in test strategy and coverage analysis.
+</role>
+
+<task>
+Generate a prioritized test plan for the provided diff:
+- Focus on negative cases, edge cases, and boundary conditions.
+- Target branch coverage and integration points.
+</task>
+
+<constraints>
+- Focus on observable behavior changes.
+- Ignore internal refactors that do not affect contract.
+- Return valid JSON matching the schema.
+</constraints>
 `;
 const TOOL_CONTRACT = requireToolContract('generate_test_plan');
 function formatOptionalLine(label, value) {

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

@@ -5,11 +5,24 @@ import { InspectCodeQualityInputSchema } from '../schemas/inputs.js';
 import { CodeQualityOutputSchema, CodeQualityResultSchema, } from '../schemas/outputs.js';
 const DEFAULT_FOCUS_AREAS = 'General';
 const SYSTEM_INSTRUCTION = `
-Principal Engineer Code Review.
-Source: Unified diff.
-Goal: Identify bugs, security, performance, maintainability.
-Constraint: Ignore style/formatting. Prioritize correctness/failure modes.
-Return strict JSON.
+<role>
+Principal Engineer.
+You are an expert in code quality, security, and performance.
+</role>
+
+<task>
+Perform a deep code review of the provided diff:
+- Identify bugs, security vulnerabilities, and performance issues.
+- Assess maintainability and clarity.
+- Provide contextual insights if full file content is available.
+</task>
+
+<constraints>
+- Ignore style/formatting/whitespace changes.
+- Prioritize correctness and failure modes over opinionated patterns.
+- Findings must be actionable and specific to the diff.
+- Return valid JSON matching the schema.
+</constraints>
 `;
 const TOOL_CONTRACT = requireToolContract('inspect_code_quality');
 function formatOptionalLine(label, value) {
@@ -32,6 +45,12 @@ export function registerInspectCodeQualityTool(server) {
         maxOutputTokens: TOOL_CONTRACT.maxOutputTokens,
         ...buildStructuredToolRuntimeOptions(TOOL_CONTRACT),
         requiresDiff: true,
+        progressContext: (input) => {
+            const focus = input.focusAreas
+                ? `[${input.focusAreas.join(',')}]`
+                : 'general';
+            return `${input.repository} ${focus}`;
+        },
         formatOutcome: (result) => `${result.findings.length} findings, risk: ${result.overallRisk}`,
         formatOutput: (result) => {
             const count = result.findings.length;

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

@@ -4,11 +4,23 @@ import { registerStructuredToolTask } from '../lib/tool-factory.js';
 import { SuggestSearchReplaceInputSchema } from '../schemas/inputs.js';
 import { SearchReplaceResultSchema } from '../schemas/outputs.js';
 const SYSTEM_INSTRUCTION = `
+<role>
 Code Remediation Expert.
-Generate minimal search/replace blocks for described issue.
-Constraint: 'search' must be verbatim (exact whitespace/indentation).
-Constraint: No context drift. Omit patch if exact match uncertain.
-Return strict JSON.
+You are a precise tool for generating automated code fixes.
+</role>
+
+<task>
+Generate minimal search-and-replace blocks to fix the described issue:
+- 'search' block must match the existing code EXACTLY (including whitespace).
+- 'replace' block must be syntactically correct and follow local style.
+</task>
+
+<constraints>
+- Verbatim match required: preserve all indentation and newlines in 'search'.
+- Do not include surrounding code unless necessary for uniqueness.
+- If exact match is ambiguous, return an empty block list.
+- Return valid JSON matching the schema.
+</constraints>
 `;
 const TOOL_CONTRACT = requireToolContract('suggest_search_replace');
 function formatPatchCount(count) {

package/package.json

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