devchain-cli 0.6.1 → 0.7.1

package/dist/server/modules/mcp/services/mcp.service.js

@@ -1,10 +1,43 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
@@ -23,12 +56,16 @@ const tmux_service_1 = require("../../terminal/services/tmux.service");
 const epics_service_1 = require("../../epics/services/epics.service");
 const settings_service_1 = require("../../settings/services/settings.service");
 const guests_service_1 = require("../../guests/services/guests.service");
+const reviews_service_1 = require("../../reviews/services/reviews.service");
 const logger_1 = require("../../../common/logging/logger");
+const schema_registry_1 = require("../dtos/schema-registry");
 const mcp_dto_1 = require("../dtos/mcp.dto");
 const instructions_resolver_1 = require("./instructions-resolver");
 const error_types_1 = require("../../../common/errors/error-types");
+const path_validation_1 = require("../../../common/validation/path-validation");
 const common_2 = require("@nestjs/common");
 const zod_1 = require("zod");
+const param_suggestion_1 = require("../utils/param-suggestion");
 const logger = (0, logger_1.createLogger)('McpService');
 function getActorFromContext(ctx) {
     if (ctx.type === 'agent') {
@@ -58,7 +95,7 @@ function redactParams(params) {
     return params;
 }
 let McpService = class McpService {
-    constructor(storage, chatService, sessionsService, messagePoolService, terminalGateway, tmuxService, epicsService, settingsService, guestsService) {
+    constructor(storage, chatService, sessionsService, messagePoolService, terminalGateway, tmuxService, epicsService, settingsService, guestsService, reviewsService) {
         this.storage = storage;
         this.chatService = chatService;
         this.sessionsService = sessionsService;
@@ -68,6 +105,7 @@ let McpService = class McpService {
         this.epicsService = epicsService;
         this.settingsService = settingsService;
         this.guestsService = guestsService;
+        this.reviewsService = reviewsService;
         this.DEFAULT_INLINE_MAX_BYTES = 64 * 1024;
         logger.info('McpService initialized');
         this.featureFlags = this.storage.getFeatureFlags();
@@ -100,70 +138,84 @@ let McpService = class McpService {
         return { id: matches[0].id, name: matches[0].name };
     }
     async handleToolCall(tool, params) {
+        const normalizedParams = params ?? {};
+        const normalizedTool = tool.replace(/[.\-/]/g, '_');
         try {
-            const normalizedTool = tool.replace(/[.\-/]/g, '_');
-            logger.info({ tool: normalizedTool, originalTool: tool, params: redactParams(params) }, 'Handling MCP tool call');
+            logger.info({ tool: normalizedTool, originalTool: tool, params: redactParams(normalizedParams) }, 'Handling MCP tool call');
             switch (normalizedTool) {
                 case 'devchain_create_record':
-                    return await this.createRecord(params);
+                    return await this.createRecord(normalizedParams);
                 case 'devchain_update_record':
-                    return await this.updateRecord(params);
+                    return await this.updateRecord(normalizedParams);
                 case 'devchain_get_record':
-                    return await this.getRecord(params);
+                    return await this.getRecord(normalizedParams);
                 case 'devchain_list_records':
-                    return await this.listRecords(params);
+                    return await this.listRecords(normalizedParams);
                 case 'devchain_add_tags':
-                    return await this.addTags(params);
+                    return await this.addTags(normalizedParams);
                 case 'devchain_remove_tags':
-                    return await this.removeTags(params);
+                    return await this.removeTags(normalizedParams);
                 case 'devchain_list_documents':
-                    return await this.listDocuments(params);
+                    return await this.listDocuments(normalizedParams);
                 case 'devchain_get_document':
-                    return await this.getDocument(params);
+                    return await this.getDocument(normalizedParams);
                 case 'devchain_create_document':
-                    return await this.createDocument(params);
+                    return await this.createDocument(normalizedParams);
                 case 'devchain_update_document':
-                    return await this.updateDocument(params);
+                    return await this.updateDocument(normalizedParams);
                 case 'devchain_list_prompts':
-                    return await this.listPrompts(params);
+                    return await this.listPrompts(normalizedParams);
                 case 'devchain_get_prompt':
-                    return await this.getPrompt(params);
+                    return await this.getPrompt(normalizedParams);
                 case 'devchain_list_agents':
-                    return await this.listAgents(params);
+                    return await this.listAgents(normalizedParams);
                 case 'devchain_get_agent_by_name':
-                    return await this.getAgentByName(params);
+                    return await this.getAgentByName(normalizedParams);
                 case 'devchain_list_statuses':
-                    return await this.listStatuses(params);
+                    return await this.listStatuses(normalizedParams);
                 case 'devchain_list_epics':
-                    return await this.listEpics(params);
+                    return await this.listEpics(normalizedParams);
                 case 'devchain_list_assigned_epics_tasks':
-                    return await this.listAssignedEpicsTasks(params);
+                    return await this.listAssignedEpicsTasks(normalizedParams);
                 case 'devchain_create_epic':
-                    return await this.createEpic(params);
+                    return await this.createEpic(normalizedParams);
                 case 'devchain_get_epic_by_id':
-                    return await this.getEpicById(params);
+                    return await this.getEpicById(normalizedParams);
                 case 'devchain_add_epic_comment':
-                    return await this.addEpicComment(params);
+                    return await this.addEpicComment(normalizedParams);
                 case 'devchain_update_epic':
-                    return await this.updateEpic(params);
+                    return await this.updateEpic(normalizedParams);
                 case 'notifications_initialized':
                     return { success: true, data: { acknowledged: true } };
                 case 'devchain_send_message':
-                    return await this.sendMessage(params);
+                    return await this.sendMessage(normalizedParams);
                 case 'devchain_chat_ack':
-                    return await this.chatAck(params);
+                    return await this.chatAck(normalizedParams);
                 case 'devchain_chat_list_members':
-                    return await this.chatListMembers(params);
+                    return await this.chatListMembers(normalizedParams);
                 case 'devchain_chat_read_history':
-                    return await this.chatReadHistory(params);
+                    return await this.chatReadHistory(normalizedParams);
                 case 'devchain_activity_start':
-                    return await this.activityStart(params);
+                    return await this.activityStart(normalizedParams);
                 case 'devchain_activity_finish':
-                    return await this.activityFinish(params);
+                    return await this.activityFinish(normalizedParams);
                 case 'devchain_list_sessions':
+                    schema_registry_1.ListSessionsParamsSchema.parse(normalizedParams);
                     return await this.listSessions();
                 case 'devchain_register_guest':
-                    return await this.registerGuest(params);
+                    return await this.registerGuest(normalizedParams);
+                case 'devchain_list_reviews':
+                    return await this.listReviews(normalizedParams);
+                case 'devchain_get_review':
+                    return await this.getReview(normalizedParams);
+                case 'devchain_get_review_comments':
+                    return await this.getReviewComments(normalizedParams);
+                case 'devchain_reply_comment':
+                    return await this.replyComment(normalizedParams);
+                case 'devchain_resolve_comment':
+                    return await this.resolveComment(normalizedParams);
+                case 'devchain_apply_suggestion':
+                    return await this.applySuggestion(normalizedParams);
                 default:
                     logger.warn({ tool: normalizedTool }, 'Unknown MCP tool');
                     return {
@@ -178,12 +230,27 @@ let McpService = class McpService {
         catch (error) {
             logger.error({ tool, error }, 'MCP tool call failed');
             if (error instanceof zod_1.ZodError) {
+                const suggestions = [];
+                for (const issue of error.issues) {
+                    if (issue.code === 'unrecognized_keys') {
+                        const unknownKeys = issue.keys;
+                        for (const key of unknownKeys) {
+                            const suggestion = (0, param_suggestion_1.suggestNestedPath)(key, normalizedTool);
+                            if (suggestion) {
+                                suggestions.push(suggestion);
+                            }
+                        }
+                    }
+                }
                 return {
                     success: false,
                     error: {
                         code: 'VALIDATION_ERROR',
                         message: 'Invalid parameters supplied to MCP tool.',
-                        data: { issues: error.issues },
+                        data: {
+                            issues: error.issues,
+                            ...(suggestions.length > 0 && { suggestions }),
+                        },
                     },
                 };
             }
@@ -2637,6 +2704,606 @@ let McpService = class McpService {
             .replace(/[^a-z0-9]+/g, '-')
             .replace(/(^-|-$)/g, '');
     }
+    async listReviews(params) {
+        const validated = mcp_dto_1.ListReviewsParamsSchema.parse(params);
+        const ctx = await this.resolveSessionContext(validated.sessionId);
+        if (!ctx.success)
+            return ctx;
+        const { project } = ctx.data;
+        if (!project) {
+            return {
+                success: false,
+                error: {
+                    code: 'PROJECT_NOT_FOUND',
+                    message: 'No project associated with this session',
+                },
+            };
+        }
+        if (!this.reviewsService) {
+            return {
+                success: false,
+                error: {
+                    code: 'SERVICE_UNAVAILABLE',
+                    message: 'ReviewsService is not available',
+                },
+            };
+        }
+        const result = await this.reviewsService.listReviews(project.id, {
+            status: validated.status,
+            epicId: validated.epicId,
+            limit: validated.limit ?? 100,
+            offset: validated.offset ?? 0,
+        });
+        const reviews = result.items.map((review) => ({
+            id: review.id,
+            title: review.title,
+            description: review.description,
+            status: review.status,
+            baseRef: review.baseRef,
+            headRef: review.headRef,
+            baseSha: review.baseSha,
+            headSha: review.headSha,
+            epicId: review.epicId,
+            createdBy: review.createdBy,
+            createdByAgentId: review.createdByAgentId,
+            version: review.version,
+            commentCount: review.commentCount,
+            createdAt: review.createdAt,
+            updatedAt: review.updatedAt,
+        }));
+        const response = {
+            reviews,
+            total: result.total,
+            limit: result.limit,
+            offset: result.offset,
+        };
+        return { success: true, data: response };
+    }
+    async getReview(params) {
+        const validated = mcp_dto_1.GetReviewParamsSchema.parse(params);
+        const ctx = await this.resolveSessionContext(validated.sessionId);
+        if (!ctx.success)
+            return ctx;
+        const { project } = ctx.data;
+        if (!project) {
+            return {
+                success: false,
+                error: {
+                    code: 'PROJECT_NOT_FOUND',
+                    message: 'No project associated with this session',
+                },
+            };
+        }
+        if (!this.reviewsService) {
+            return {
+                success: false,
+                error: {
+                    code: 'SERVICE_UNAVAILABLE',
+                    message: 'ReviewsService is not available',
+                },
+            };
+        }
+        try {
+            const reviewWithFiles = await this.reviewsService.getReview(validated.reviewId);
+            if (reviewWithFiles.projectId !== project.id) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'REVIEW_NOT_FOUND',
+                        message: `Review ${validated.reviewId} does not belong to this project`,
+                    },
+                };
+            }
+            const commentsResult = await this.reviewsService.listComments(validated.reviewId, {
+                limit: 500,
+            });
+            const agentIds = new Set();
+            for (const comment of commentsResult.items) {
+                if (comment.authorAgentId)
+                    agentIds.add(comment.authorAgentId);
+            }
+            const agentNameById = new Map();
+            for (const agentId of agentIds) {
+                try {
+                    const agent = await this.storage.getAgent(agentId);
+                    agentNameById.set(agentId, agent.name);
+                }
+                catch {
+                }
+            }
+            const comments = commentsResult.items.map((comment) => ({
+                id: comment.id,
+                filePath: comment.filePath,
+                lineStart: comment.lineStart,
+                lineEnd: comment.lineEnd,
+                side: comment.side,
+                content: comment.content,
+                commentType: comment.commentType,
+                status: comment.status,
+                authorType: comment.authorType,
+                authorAgentId: comment.authorAgentId,
+                authorAgentName: comment.authorAgentId
+                    ? agentNameById.get(comment.authorAgentId)
+                    : undefined,
+                parentId: comment.parentId,
+                version: comment.version,
+                createdAt: comment.createdAt,
+                updatedAt: comment.updatedAt,
+            }));
+            const changedFiles = (reviewWithFiles.changedFiles ?? []).map((file) => ({
+                path: file.path,
+                status: file.status,
+                additions: file.additions,
+                deletions: file.deletions,
+                oldPath: file.oldPath,
+            }));
+            const response = {
+                review: {
+                    id: reviewWithFiles.id,
+                    title: reviewWithFiles.title,
+                    description: reviewWithFiles.description,
+                    status: reviewWithFiles.status,
+                    baseRef: reviewWithFiles.baseRef,
+                    headRef: reviewWithFiles.headRef,
+                    baseSha: reviewWithFiles.baseSha,
+                    headSha: reviewWithFiles.headSha,
+                    epicId: reviewWithFiles.epicId,
+                    createdBy: reviewWithFiles.createdBy,
+                    createdByAgentId: reviewWithFiles.createdByAgentId,
+                    version: reviewWithFiles.version,
+                    createdAt: reviewWithFiles.createdAt,
+                    updatedAt: reviewWithFiles.updatedAt,
+                },
+                changedFiles,
+                comments,
+            };
+            return { success: true, data: response };
+        }
+        catch (error) {
+            if (error instanceof error_types_1.NotFoundError) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'REVIEW_NOT_FOUND',
+                        message: `Review ${validated.reviewId} was not found`,
+                    },
+                };
+            }
+            throw error;
+        }
+    }
+    async getReviewComments(params) {
+        const validated = mcp_dto_1.GetReviewCommentsParamsSchema.parse(params);
+        const ctx = await this.resolveSessionContext(validated.sessionId);
+        if (!ctx.success)
+            return ctx;
+        const { project } = ctx.data;
+        if (!project) {
+            return {
+                success: false,
+                error: {
+                    code: 'PROJECT_NOT_FOUND',
+                    message: 'No project associated with this session',
+                },
+            };
+        }
+        if (!this.reviewsService) {
+            return {
+                success: false,
+                error: {
+                    code: 'SERVICE_UNAVAILABLE',
+                    message: 'ReviewsService is not available',
+                },
+            };
+        }
+        try {
+            const review = await this.storage.getReview(validated.reviewId);
+            if (review.projectId !== project.id) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'REVIEW_NOT_FOUND',
+                        message: `Review ${validated.reviewId} does not belong to this project`,
+                    },
+                };
+            }
+            const result = await this.reviewsService.listComments(validated.reviewId, {
+                status: validated.status,
+                filePath: validated.filePath,
+                limit: validated.limit ?? 100,
+                offset: validated.offset ?? 0,
+            });
+            const agentIds = new Set();
+            for (const comment of result.items) {
+                if (comment.authorAgentId)
+                    agentIds.add(comment.authorAgentId);
+            }
+            const agentNameById = new Map();
+            for (const agentId of agentIds) {
+                try {
+                    const agent = await this.storage.getAgent(agentId);
+                    agentNameById.set(agentId, agent.name);
+                }
+                catch {
+                }
+            }
+            const comments = result.items.map((comment) => ({
+                id: comment.id,
+                filePath: comment.filePath,
+                lineStart: comment.lineStart,
+                lineEnd: comment.lineEnd,
+                side: comment.side,
+                content: comment.content,
+                commentType: comment.commentType,
+                status: comment.status,
+                authorType: comment.authorType,
+                authorAgentId: comment.authorAgentId,
+                authorAgentName: comment.authorAgentId
+                    ? agentNameById.get(comment.authorAgentId)
+                    : undefined,
+                parentId: comment.parentId,
+                version: comment.version,
+                createdAt: comment.createdAt,
+                updatedAt: comment.updatedAt,
+            }));
+            const response = {
+                comments,
+                total: result.total,
+                limit: result.limit,
+                offset: result.offset,
+            };
+            return { success: true, data: response };
+        }
+        catch (error) {
+            if (error instanceof error_types_1.NotFoundError) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'REVIEW_NOT_FOUND',
+                        message: `Review ${validated.reviewId} was not found`,
+                    },
+                };
+            }
+            throw error;
+        }
+    }
+    async replyComment(params) {
+        const validated = mcp_dto_1.ReplyCommentParamsSchema.parse(params);
+        const ctx = await this.resolveSessionContext(validated.sessionId);
+        if (!ctx.success)
+            return ctx;
+        const { project } = ctx.data;
+        const actor = getActorFromContext(ctx.data);
+        if (!project) {
+            return {
+                success: false,
+                error: {
+                    code: 'PROJECT_NOT_FOUND',
+                    message: 'No project associated with this session',
+                },
+            };
+        }
+        if (!this.reviewsService) {
+            return {
+                success: false,
+                error: {
+                    code: 'SERVICE_UNAVAILABLE',
+                    message: 'ReviewsService is not available',
+                },
+            };
+        }
+        try {
+            const review = await this.storage.getReview(validated.reviewId);
+            if (review.projectId !== project.id) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'REVIEW_NOT_FOUND',
+                        message: `Review ${validated.reviewId} does not belong to this project`,
+                    },
+                };
+            }
+            const comment = await this.reviewsService.createComment(validated.reviewId, {
+                parentId: validated.parentCommentId,
+                content: validated.content,
+                filePath: validated.filePath,
+                lineStart: validated.lineStart,
+                lineEnd: validated.lineEnd,
+                commentType: validated.commentType ?? 'comment',
+                authorType: 'agent',
+                authorAgentId: actor?.id,
+                targetAgentIds: validated.targetAgentIds,
+            });
+            const response = {
+                comment: {
+                    id: comment.id,
+                    filePath: comment.filePath,
+                    lineStart: comment.lineStart,
+                    lineEnd: comment.lineEnd,
+                    side: comment.side,
+                    content: comment.content,
+                    commentType: comment.commentType,
+                    status: comment.status,
+                    authorType: comment.authorType,
+                    authorAgentId: comment.authorAgentId,
+                    authorAgentName: actor?.name,
+                    parentId: comment.parentId,
+                    version: comment.version,
+                    createdAt: comment.createdAt,
+                    updatedAt: comment.updatedAt,
+                },
+            };
+            return { success: true, data: response };
+        }
+        catch (error) {
+            if (error instanceof error_types_1.NotFoundError) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'REVIEW_NOT_FOUND',
+                        message: `Review ${validated.reviewId} was not found`,
+                    },
+                };
+            }
+            throw error;
+        }
+    }
+    async resolveComment(params) {
+        const validated = mcp_dto_1.ResolveCommentParamsSchema.parse(params);
+        const ctx = await this.resolveSessionContext(validated.sessionId);
+        if (!ctx.success)
+            return ctx;
+        const { project } = ctx.data;
+        if (!project) {
+            return {
+                success: false,
+                error: {
+                    code: 'PROJECT_NOT_FOUND',
+                    message: 'No project associated with this session',
+                },
+            };
+        }
+        if (!this.reviewsService) {
+            return {
+                success: false,
+                error: {
+                    code: 'SERVICE_UNAVAILABLE',
+                    message: 'ReviewsService is not available',
+                },
+            };
+        }
+        try {
+            const comment = await this.storage.getReviewComment(validated.commentId);
+            const review = await this.storage.getReview(comment.reviewId);
+            if (review.projectId !== project.id) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'COMMENT_NOT_FOUND',
+                        message: `Comment ${validated.commentId} does not belong to this project`,
+                    },
+                };
+            }
+            const updatedComment = await this.reviewsService.resolveComment(comment.reviewId, validated.commentId, validated.resolution, validated.version);
+            let authorAgentName;
+            if (updatedComment.authorAgentId) {
+                try {
+                    const agent = await this.storage.getAgent(updatedComment.authorAgentId);
+                    authorAgentName = agent.name;
+                }
+                catch {
+                }
+            }
+            const response = {
+                comment: {
+                    id: updatedComment.id,
+                    filePath: updatedComment.filePath,
+                    lineStart: updatedComment.lineStart,
+                    lineEnd: updatedComment.lineEnd,
+                    side: updatedComment.side,
+                    content: updatedComment.content,
+                    commentType: updatedComment.commentType,
+                    status: updatedComment.status,
+                    authorType: updatedComment.authorType,
+                    authorAgentId: updatedComment.authorAgentId,
+                    authorAgentName,
+                    parentId: updatedComment.parentId,
+                    version: updatedComment.version,
+                    createdAt: updatedComment.createdAt,
+                    updatedAt: updatedComment.updatedAt,
+                },
+            };
+            return { success: true, data: response };
+        }
+        catch (error) {
+            if (error instanceof error_types_1.NotFoundError) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'COMMENT_NOT_FOUND',
+                        message: `Comment ${validated.commentId} was not found`,
+                    },
+                };
+            }
+            throw error;
+        }
+    }
+    async applySuggestion(params) {
+        const validated = mcp_dto_1.ApplySuggestionParamsSchema.parse(params);
+        const ctx = await this.resolveSessionContext(validated.sessionId);
+        if (!ctx.success)
+            return ctx;
+        const { project } = ctx.data;
+        if (!project) {
+            return {
+                success: false,
+                error: {
+                    code: 'PROJECT_NOT_FOUND',
+                    message: 'No project associated with this session',
+                },
+            };
+        }
+        if (!this.reviewsService) {
+            return {
+                success: false,
+                error: {
+                    code: 'SERVICE_UNAVAILABLE',
+                    message: 'ReviewsService is not available',
+                },
+            };
+        }
+        try {
+            const comment = await this.storage.getReviewComment(validated.commentId);
+            const review = await this.storage.getReview(comment.reviewId);
+            if (review.projectId !== project.id) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'COMMENT_NOT_FOUND',
+                        message: `Comment ${validated.commentId} does not belong to this project`,
+                    },
+                };
+            }
+            if (!comment.filePath || comment.lineStart === null) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'INVALID_SUGGESTION',
+                        message: 'Comment does not have file path or line information',
+                    },
+                };
+            }
+            const suggestionMatch = comment.content.match(/```suggestion\s*\n([\s\S]*?)```/);
+            if (!suggestionMatch) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'NO_SUGGESTION',
+                        message: 'Comment does not contain a suggestion block',
+                    },
+                };
+            }
+            const suggestedCode = suggestionMatch[1].trimEnd();
+            const lineStart = comment.lineStart;
+            const lineEnd = comment.lineEnd ?? comment.lineStart;
+            let validatedPath;
+            try {
+                validatedPath = (0, path_validation_1.validatePathWithinRoot)(project.rootPath, comment.filePath, {
+                    errorPrefix: 'Invalid file path in comment',
+                });
+            }
+            catch (error) {
+                if (error instanceof error_types_1.ValidationError) {
+                    return {
+                        success: false,
+                        error: {
+                            code: 'PATH_TRAVERSAL_BLOCKED',
+                            message: error.message,
+                            data: error.details,
+                        },
+                    };
+                }
+                throw error;
+            }
+            let realFilePath;
+            try {
+                realFilePath = await (0, path_validation_1.validateResolvedPathWithinRoot)(validatedPath.absolutePath, project.rootPath, { errorPrefix: 'Symlink validation failed' });
+            }
+            catch (error) {
+                if (error instanceof error_types_1.ValidationError) {
+                    return {
+                        success: false,
+                        error: {
+                            code: 'SYMLINK_ESCAPE_BLOCKED',
+                            message: error.message,
+                            data: error.details,
+                        },
+                    };
+                }
+                throw error;
+            }
+            const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+            const filePath = realFilePath;
+            const fileContent = await fs.readFile(filePath, 'utf-8');
+            const lines = fileContent.split('\n');
+            try {
+                (0, path_validation_1.validateLineBounds)(lineStart, lineEnd, lines.length);
+            }
+            catch (error) {
+                if (error instanceof error_types_1.ValidationError) {
+                    return {
+                        success: false,
+                        error: {
+                            code: 'INVALID_LINE_BOUNDS',
+                            message: error.message,
+                            data: error.details,
+                        },
+                    };
+                }
+                throw error;
+            }
+            const suggestedLines = suggestedCode.split('\n');
+            lines.splice(lineStart - 1, lineEnd - lineStart + 1, ...suggestedLines);
+            await fs.writeFile(filePath, lines.join('\n'), 'utf-8');
+            const updatedComment = await this.reviewsService.resolveComment(comment.reviewId, validated.commentId, 'resolved', validated.version);
+            let authorAgentName;
+            if (updatedComment.authorAgentId) {
+                try {
+                    const agent = await this.storage.getAgent(updatedComment.authorAgentId);
+                    authorAgentName = agent.name;
+                }
+                catch {
+                }
+            }
+            const response = {
+                comment: {
+                    id: updatedComment.id,
+                    filePath: updatedComment.filePath,
+                    lineStart: updatedComment.lineStart,
+                    lineEnd: updatedComment.lineEnd,
+                    side: updatedComment.side,
+                    content: updatedComment.content,
+                    commentType: updatedComment.commentType,
+                    status: updatedComment.status,
+                    authorType: updatedComment.authorType,
+                    authorAgentId: updatedComment.authorAgentId,
+                    authorAgentName,
+                    parentId: updatedComment.parentId,
+                    version: updatedComment.version,
+                    createdAt: updatedComment.createdAt,
+                    updatedAt: updatedComment.updatedAt,
+                },
+                applied: {
+                    filePath: comment.filePath,
+                    lineStart,
+                    lineEnd,
+                    suggestedCode,
+                },
+            };
+            return { success: true, data: response };
+        }
+        catch (error) {
+            if (error instanceof error_types_1.NotFoundError) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'COMMENT_NOT_FOUND',
+                        message: `Comment ${validated.commentId} was not found`,
+                    },
+                };
+            }
+            if (error.code === 'ENOENT') {
+                return {
+                    success: false,
+                    error: {
+                        code: 'FILE_NOT_FOUND',
+                        message: `File not found at path`,
+                    },
+                };
+            }
+            throw error;
+        }
+    }
 };
 exports.McpService = McpService;
 exports.McpService = McpService = __decorate([
@@ -2650,6 +3317,7 @@ exports.McpService = McpService = __decorate([
     __param(6, (0, common_1.Inject)((0, common_1.forwardRef)(() => epics_service_1.EpicsService))),
     __param(7, (0, common_1.Inject)((0, common_1.forwardRef)(() => settings_service_1.SettingsService))),
     __param(8, (0, common_1.Inject)((0, common_1.forwardRef)(() => guests_service_1.GuestsService))),
+    __param(9, (0, common_1.Inject)((0, common_1.forwardRef)(() => reviews_service_1.ReviewsService))),
     __metadata("design:paramtypes", [Object, chat_service_1.ChatService,
         sessions_service_1.SessionsService,
         sessions_message_pool_service_1.SessionsMessagePoolService,
@@ -2657,6 +3325,7 @@ exports.McpService = McpService = __decorate([
         tmux_service_1.TmuxService,
         epics_service_1.EpicsService,
         settings_service_1.SettingsService,
-        guests_service_1.GuestsService])
+        guests_service_1.GuestsService,
+        reviews_service_1.ReviewsService])
 ], McpService);
 //# sourceMappingURL=mcp.service.js.map