@contextrail/code-review-agent 0.1.1-alpha.0

package/dist/mcp/client.d.ts

@@ -0,0 +1,429 @@
+import type { Logger } from '../logging/logger.js';
+export type McpClientConfig = {
+    serverUrl: string;
+    authToken?: string;
+    clientName?: string;
+    clientVersion?: string;
+    logger?: Logger;
+    logContext?: {
+        requestId?: string;
+        userId?: string;
+        correlationId?: string;
+    };
+};
+export declare class McpClient {
+    private static readonly DEFAULT_MAX_FAILURES;
+    private static readonly DEFAULT_MAX_RETRIES;
+    private static readonly DEFAULT_BASE_RETRY_DELAY_MS;
+    private client;
+    private transport?;
+    private readonly serverUrl;
+    private readonly authToken?;
+    private readonly logger?;
+    private readonly logContext;
+    private failureCount;
+    private circuitOpenUntil?;
+    private readonly maxFailures;
+    private readonly maxRetries;
+    private readonly baseRetryDelayMs;
+    constructor(config: McpClientConfig);
+    connect(): Promise<void>;
+    close(): Promise<void>;
+    listPrompts(): Promise<{
+        [x: string]: unknown;
+        prompts: {
+            name: string;
+            description?: string | undefined;
+            arguments?: {
+                name: string;
+                description?: string | undefined;
+                required?: boolean | undefined;
+            }[] | undefined;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+            icons?: {
+                src: string;
+                mimeType?: string | undefined;
+                sizes?: string[] | undefined;
+            }[] | undefined;
+            title?: string | undefined;
+        }[];
+        _meta?: {
+            [x: string]: unknown;
+            "io.modelcontextprotocol/related-task"?: {
+                [x: string]: unknown;
+                taskId: string;
+            } | undefined;
+        } | undefined;
+        nextCursor?: string | undefined;
+    }>;
+    getPrompt(params: {
+        name: string;
+        arguments?: Record<string, string>;
+    }): Promise<{
+        [x: string]: unknown;
+        messages: {
+            role: "user" | "assistant";
+            content: {
+                type: "text";
+                text: string;
+                annotations?: {
+                    audience?: ("user" | "assistant")[] | undefined;
+                    priority?: number | undefined;
+                    lastModified?: string | undefined;
+                } | undefined;
+                _meta?: Record<string, unknown> | undefined;
+            } | {
+                type: "image";
+                data: string;
+                mimeType: string;
+                annotations?: {
+                    audience?: ("user" | "assistant")[] | undefined;
+                    priority?: number | undefined;
+                    lastModified?: string | undefined;
+                } | undefined;
+                _meta?: Record<string, unknown> | undefined;
+            } | {
+                type: "audio";
+                data: string;
+                mimeType: string;
+                annotations?: {
+                    audience?: ("user" | "assistant")[] | undefined;
+                    priority?: number | undefined;
+                    lastModified?: string | undefined;
+                } | undefined;
+                _meta?: Record<string, unknown> | undefined;
+            } | {
+                type: "resource";
+                resource: {
+                    uri: string;
+                    text: string;
+                    mimeType?: string | undefined;
+                    _meta?: Record<string, unknown> | undefined;
+                } | {
+                    uri: string;
+                    blob: string;
+                    mimeType?: string | undefined;
+                    _meta?: Record<string, unknown> | undefined;
+                };
+                annotations?: {
+                    audience?: ("user" | "assistant")[] | undefined;
+                    priority?: number | undefined;
+                    lastModified?: string | undefined;
+                } | undefined;
+                _meta?: Record<string, unknown> | undefined;
+            } | {
+                uri: string;
+                name: string;
+                type: "resource_link";
+                description?: string | undefined;
+                mimeType?: string | undefined;
+                annotations?: {
+                    audience?: ("user" | "assistant")[] | undefined;
+                    priority?: number | undefined;
+                    lastModified?: string | undefined;
+                } | undefined;
+                _meta?: {
+                    [x: string]: unknown;
+                } | undefined;
+                icons?: {
+                    src: string;
+                    mimeType?: string | undefined;
+                    sizes?: string[] | undefined;
+                }[] | undefined;
+                title?: string | undefined;
+            };
+        }[];
+        _meta?: {
+            [x: string]: unknown;
+            "io.modelcontextprotocol/related-task"?: {
+                [x: string]: unknown;
+                taskId: string;
+            } | undefined;
+        } | undefined;
+        description?: string | undefined;
+    }>;
+    searchContexts(params: Record<string, unknown>): Promise<{
+        [x: string]: unknown;
+        content: ({
+            type: "text";
+            text: string;
+            annotations?: {
+                audience?: ("user" | "assistant")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: Record<string, unknown> | undefined;
+        } | {
+            type: "image";
+            data: string;
+            mimeType: string;
+            annotations?: {
+                audience?: ("user" | "assistant")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: Record<string, unknown> | undefined;
+        } | {
+            type: "audio";
+            data: string;
+            mimeType: string;
+            annotations?: {
+                audience?: ("user" | "assistant")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: Record<string, unknown> | undefined;
+        } | {
+            type: "resource";
+            resource: {
+                uri: string;
+                text: string;
+                mimeType?: string | undefined;
+                _meta?: Record<string, unknown> | undefined;
+            } | {
+                uri: string;
+                blob: string;
+                mimeType?: string | undefined;
+                _meta?: Record<string, unknown> | undefined;
+            };
+            annotations?: {
+                audience?: ("user" | "assistant")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: Record<string, unknown> | undefined;
+        } | {
+            uri: string;
+            name: string;
+            type: "resource_link";
+            description?: string | undefined;
+            mimeType?: string | undefined;
+            annotations?: {
+                audience?: ("user" | "assistant")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+            icons?: {
+                src: string;
+                mimeType?: string | undefined;
+                sizes?: string[] | undefined;
+            }[] | undefined;
+            title?: string | undefined;
+        })[];
+        _meta?: {
+            [x: string]: unknown;
+            "io.modelcontextprotocol/related-task"?: {
+                [x: string]: unknown;
+                taskId: string;
+            } | undefined;
+        } | undefined;
+        structuredContent?: Record<string, unknown> | undefined;
+        isError?: boolean | undefined;
+    } | {
+        [x: string]: unknown;
+        toolResult: unknown;
+        _meta?: {
+            [x: string]: unknown;
+            "io.modelcontextprotocol/related-task"?: {
+                [x: string]: unknown;
+                taskId: string;
+            } | undefined;
+        } | undefined;
+    }>;
+    getContext(params: Record<string, unknown>): Promise<{
+        [x: string]: unknown;
+        content: ({
+            type: "text";
+            text: string;
+            annotations?: {
+                audience?: ("user" | "assistant")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: Record<string, unknown> | undefined;
+        } | {
+            type: "image";
+            data: string;
+            mimeType: string;
+            annotations?: {
+                audience?: ("user" | "assistant")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: Record<string, unknown> | undefined;
+        } | {
+            type: "audio";
+            data: string;
+            mimeType: string;
+            annotations?: {
+                audience?: ("user" | "assistant")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: Record<string, unknown> | undefined;
+        } | {
+            type: "resource";
+            resource: {
+                uri: string;
+                text: string;
+                mimeType?: string | undefined;
+                _meta?: Record<string, unknown> | undefined;
+            } | {
+                uri: string;
+                blob: string;
+                mimeType?: string | undefined;
+                _meta?: Record<string, unknown> | undefined;
+            };
+            annotations?: {
+                audience?: ("user" | "assistant")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: Record<string, unknown> | undefined;
+        } | {
+            uri: string;
+            name: string;
+            type: "resource_link";
+            description?: string | undefined;
+            mimeType?: string | undefined;
+            annotations?: {
+                audience?: ("user" | "assistant")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+            icons?: {
+                src: string;
+                mimeType?: string | undefined;
+                sizes?: string[] | undefined;
+            }[] | undefined;
+            title?: string | undefined;
+        })[];
+        _meta?: {
+            [x: string]: unknown;
+            "io.modelcontextprotocol/related-task"?: {
+                [x: string]: unknown;
+                taskId: string;
+            } | undefined;
+        } | undefined;
+        structuredContent?: Record<string, unknown> | undefined;
+        isError?: boolean | undefined;
+    } | {
+        [x: string]: unknown;
+        toolResult: unknown;
+        _meta?: {
+            [x: string]: unknown;
+            "io.modelcontextprotocol/related-task"?: {
+                [x: string]: unknown;
+                taskId: string;
+            } | undefined;
+        } | undefined;
+    }>;
+    resolveDependencies(params: Record<string, unknown>): Promise<{
+        [x: string]: unknown;
+        content: ({
+            type: "text";
+            text: string;
+            annotations?: {
+                audience?: ("user" | "assistant")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: Record<string, unknown> | undefined;
+        } | {
+            type: "image";
+            data: string;
+            mimeType: string;
+            annotations?: {
+                audience?: ("user" | "assistant")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: Record<string, unknown> | undefined;
+        } | {
+            type: "audio";
+            data: string;
+            mimeType: string;
+            annotations?: {
+                audience?: ("user" | "assistant")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: Record<string, unknown> | undefined;
+        } | {
+            type: "resource";
+            resource: {
+                uri: string;
+                text: string;
+                mimeType?: string | undefined;
+                _meta?: Record<string, unknown> | undefined;
+            } | {
+                uri: string;
+                blob: string;
+                mimeType?: string | undefined;
+                _meta?: Record<string, unknown> | undefined;
+            };
+            annotations?: {
+                audience?: ("user" | "assistant")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: Record<string, unknown> | undefined;
+        } | {
+            uri: string;
+            name: string;
+            type: "resource_link";
+            description?: string | undefined;
+            mimeType?: string | undefined;
+            annotations?: {
+                audience?: ("user" | "assistant")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+            icons?: {
+                src: string;
+                mimeType?: string | undefined;
+                sizes?: string[] | undefined;
+            }[] | undefined;
+            title?: string | undefined;
+        })[];
+        _meta?: {
+            [x: string]: unknown;
+            "io.modelcontextprotocol/related-task"?: {
+                [x: string]: unknown;
+                taskId: string;
+            } | undefined;
+        } | undefined;
+        structuredContent?: Record<string, unknown> | undefined;
+        isError?: boolean | undefined;
+    } | {
+        [x: string]: unknown;
+        toolResult: unknown;
+        _meta?: {
+            [x: string]: unknown;
+            "io.modelcontextprotocol/related-task"?: {
+                [x: string]: unknown;
+                taskId: string;
+            } | undefined;
+        } | undefined;
+    }>;
+    private executeWithRetry;
+    private ensureCircuitClosed;
+    private recordSuccess;
+    private recordFailure;
+    private isErrorWithCode;
+    private isTransientError;
+    private wrapError;
+    private logError;
+    private wait;
+}

package/dist/mcp/client.js

@@ -0,0 +1,173 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StreamableHTTPClientTransport, } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+export class McpClient {
+    static DEFAULT_MAX_FAILURES = 3;
+    static DEFAULT_MAX_RETRIES = 3;
+    static DEFAULT_BASE_RETRY_DELAY_MS = 200;
+    client;
+    transport;
+    serverUrl;
+    authToken;
+    logger;
+    logContext;
+    failureCount = 0;
+    circuitOpenUntil;
+    maxFailures = McpClient.DEFAULT_MAX_FAILURES;
+    maxRetries = McpClient.DEFAULT_MAX_RETRIES;
+    baseRetryDelayMs = McpClient.DEFAULT_BASE_RETRY_DELAY_MS;
+    constructor(config) {
+        this.serverUrl = config.serverUrl;
+        this.authToken = config.authToken;
+        this.logger = config.logger;
+        this.logContext = config.logContext;
+        this.client = new Client({
+            name: config.clientName ?? 'code-review-agent',
+            version: config.clientVersion ?? '0.1.0',
+        });
+    }
+    async connect() {
+        if (this.transport) {
+            return;
+        }
+        // Validate token before connecting (client-side check)
+        if (this.authToken) {
+            const { validateToken } = await import('./token-validation.js');
+            const validation = validateToken(this.authToken);
+            if (!validation.valid) {
+                this.logger?.warn(`Token validation warning: ${validation.reason}. Proceeding with connection (server will perform full validation).`);
+            }
+        }
+        this.logger?.debug('Connecting to MCP server:', this.serverUrl);
+        const transportOptions = this.authToken
+            ? { requestInit: { headers: { Authorization: `Bearer ${this.authToken}` } } }
+            : undefined;
+        this.transport = new StreamableHTTPClientTransport(new URL(this.serverUrl), transportOptions);
+        try {
+            await this.client.connect(this.transport);
+            this.logger?.debug('Connected to MCP server:', this.serverUrl);
+        }
+        catch (error) {
+            this.transport = undefined;
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            throw new Error(`MCP connection failed for ${this.serverUrl}: ${message}`);
+        }
+    }
+    async close() {
+        this.logger?.debug('Closing MCP client:', this.serverUrl);
+        await this.client.close();
+        this.transport = undefined;
+    }
+    async listPrompts() {
+        this.logger?.debug('Listing prompts');
+        return this.executeWithRetry('listPrompts', () => this.client.listPrompts());
+    }
+    async getPrompt(params) {
+        this.logger?.debug('Getting prompt:', params);
+        return this.executeWithRetry('getPrompt', () => this.client.getPrompt(params));
+    }
+    async searchContexts(params) {
+        this.logger?.debug('Searching contexts:', params);
+        return this.executeWithRetry('search_contexts', () => this.client.callTool({
+            name: 'search_contexts',
+            arguments: params,
+        }));
+    }
+    async getContext(params) {
+        this.logger?.debug('Getting context:', params);
+        return this.executeWithRetry('get_context', () => this.client.callTool({
+            name: 'get_context',
+            arguments: params,
+        }));
+    }
+    async resolveDependencies(params) {
+        this.logger?.debug('Resolving dependencies:', params);
+        return this.executeWithRetry('resolve_dependencies', () => this.client.callTool({
+            name: 'resolve_dependencies',
+            arguments: params,
+        }));
+    }
+    async executeWithRetry(operation, fn) {
+        this.ensureCircuitClosed(operation);
+        for (let attempt = 1; attempt <= this.maxRetries; attempt += 1) {
+            this.logger?.debug(`MCP ${operation} attempt ${attempt}/${this.maxRetries}`);
+            try {
+                const result = await fn();
+                this.recordSuccess();
+                return result;
+            }
+            catch (error) {
+                const wrapped = this.wrapError(operation, error);
+                this.recordFailure();
+                this.logError(operation, wrapped, attempt);
+                if (!this.isTransientError(error) || attempt === this.maxRetries) {
+                    throw wrapped;
+                }
+                await this.wait(this.baseRetryDelayMs * 2 ** (attempt - 1));
+            }
+        }
+        throw new Error(`MCP ${operation} failed after ${this.maxRetries} attempts`);
+    }
+    ensureCircuitClosed(operation) {
+        if (this.circuitOpenUntil && Date.now() < this.circuitOpenUntil) {
+            throw new Error(`Circuit breaker open for ${operation} (${this.serverUrl})`);
+        }
+    }
+    recordSuccess() {
+        this.failureCount = 0;
+        this.circuitOpenUntil = undefined;
+    }
+    recordFailure() {
+        this.failureCount += 1;
+        if (this.failureCount >= this.maxFailures) {
+            this.circuitOpenUntil = Date.now() + this.baseRetryDelayMs * 10;
+        }
+    }
+    isErrorWithCode(error) {
+        if (!error || typeof error !== 'object') {
+            return false;
+        }
+        return 'code' in error && typeof error.code === 'string';
+    }
+    isTransientError(error) {
+        if (this.isErrorWithCode(error)) {
+            return ['ECONNRESET', 'ETIMEDOUT', 'EAI_AGAIN', 'ECONNREFUSED', 'ENETUNREACH'].includes(error.code);
+        }
+        if (error instanceof Error) {
+            return /timeout|timed out|ECONNRESET|ETIMEDOUT/i.test(error.message);
+        }
+        return false;
+    }
+    wrapError(operation, error) {
+        if (error instanceof Error) {
+            if (process.env.NODE_ENV === 'development' && error.stack) {
+                return new Error(`MCP ${operation} failed for ${this.serverUrl}: ${error.message}\n${error.stack}`);
+            }
+            return new Error(`MCP ${operation} failed for ${this.serverUrl}: ${error.message}`);
+        }
+        return new Error(`MCP ${operation} failed for ${this.serverUrl}: Unknown error`);
+    }
+    logError(operation, error, attempt) {
+        const timestamp = new Date().toISOString();
+        const payload = {
+            timestamp,
+            level: 'error',
+            message: `MCP ${operation} error`,
+            operation,
+            serverUrl: this.serverUrl,
+            attempt,
+            requestId: this.logContext?.requestId ?? null,
+            userId: this.logContext?.userId ?? null,
+            correlationId: this.logContext?.correlationId ?? null,
+            errorMessage: error.message,
+            errorStack: process.env.NODE_ENV === 'development' ? (error.stack ?? null) : null,
+        };
+        if (this.logger) {
+            this.logger.error(payload);
+            return;
+        }
+        console.error(JSON.stringify(payload));
+    }
+    wait(durationMs) {
+        return new Promise((resolve) => setTimeout(resolve, durationMs));
+    }
+}