devchain-cli 0.12.3 → 0.13.0

package/dist/server/modules/mcp/services/handlers/review-tools.js

@@ -1,37 +1,4 @@
 "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 __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;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleListReviews = handleListReviews;
 exports.handleGetReview = handleGetReview;
@@ -40,115 +7,70 @@ exports.handleReplyComment = handleReplyComment;
 exports.handleResolveComment = handleResolveComment;
 exports.handleApplySuggestion = handleApplySuggestion;
 const error_types_1 = require("../../../../common/errors/error-types");
-const path_validation_1 = require("../../../../common/validation/path-validation");
-const mcp_dto_1 = require("../../dtos/mcp.dto");
-function getActorFromContext(ctx) {
-    if (ctx.type === 'agent') {
-        return ctx.agent;
-    }
-    if (ctx.type === 'guest') {
-        return {
-            id: ctx.guest.id,
-            name: ctx.guest.name,
-            projectId: ctx.guest.projectId,
-        };
-    }
-    return null;
-}
-function missingSessionResolver() {
-    return {
-        success: false,
-        error: {
-            code: 'SERVICE_UNAVAILABLE',
-            message: 'Session resolution requires full app context (not available in standalone MCP mode)',
-        },
-    };
-}
-async function resolveSessionContext(ctx, sessionId) {
-    if (!ctx.resolveSessionContext) {
-        return missingSessionResolver();
-    }
-    return ctx.resolveSessionContext(sessionId);
-}
+const service_unavailable_error_1 = require("../../../../common/errors/service-unavailable.error");
+const session_context_helpers_1 = require("../utils/session-context-helpers");
+const agent_name_resolver_1 = require("../utils/agent-name-resolver");
+const require_project_1 = require("../utils/require-project");
+const review_suggestion_applier_service_1 = require("../../../reviews/services/review-suggestion-applier.service");
 async function handleListReviews(ctx, params) {
-    const validated = mcp_dto_1.ListReviewsParamsSchema.parse(params);
-    const sessionCtxResult = await resolveSessionContext(ctx, validated.sessionId);
-    if (!sessionCtxResult.success)
-        return sessionCtxResult;
-    const { project } = sessionCtxResult.data;
-    if (!project) {
-        return {
-            success: false,
-            error: {
-                code: 'PROJECT_NOT_FOUND',
-                message: 'No project associated with this session',
-            },
+    const validated = params;
+    const sessionCtxResult = await (0, session_context_helpers_1.resolveSessionContext)(ctx, validated.sessionId);
+    const projectResult = (0, require_project_1.requireProject)(sessionCtxResult);
+    if (!('project' in projectResult))
+        return projectResult;
+    const { project } = projectResult;
+    try {
+        const result = await ctx.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 };
     }
-    if (!ctx.reviewsService) {
-        return {
-            success: false,
-            error: {
-                code: 'SERVICE_UNAVAILABLE',
-                message: 'ReviewsService is not available',
-            },
-        };
+    catch (error) {
+        if (error instanceof service_unavailable_error_1.ServiceUnavailableError) {
+            return {
+                success: false,
+                error: {
+                    code: 'SERVICE_UNAVAILABLE',
+                    message: 'ReviewsService is not available',
+                },
+            };
+        }
+        throw error;
     }
-    const result = await ctx.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 function handleGetReview(ctx, params) {
-    const validated = mcp_dto_1.GetReviewParamsSchema.parse(params);
-    const sessionCtxResult = await resolveSessionContext(ctx, validated.sessionId);
-    if (!sessionCtxResult.success)
-        return sessionCtxResult;
-    const { project } = sessionCtxResult.data;
-    if (!project) {
-        return {
-            success: false,
-            error: {
-                code: 'PROJECT_NOT_FOUND',
-                message: 'No project associated with this session',
-            },
-        };
-    }
-    if (!ctx.reviewsService) {
-        return {
-            success: false,
-            error: {
-                code: 'SERVICE_UNAVAILABLE',
-                message: 'ReviewsService is not available',
-            },
-        };
-    }
+    const validated = params;
+    const sessionCtxResult = await (0, session_context_helpers_1.resolveSessionContext)(ctx, validated.sessionId);
+    const projectResult = (0, require_project_1.requireProject)(sessionCtxResult);
+    if (!('project' in projectResult))
+        return projectResult;
+    const { project } = projectResult;
     try {
         const reviewWithFiles = await ctx.reviewsService.getReview(validated.reviewId);
         if (reviewWithFiles.projectId !== project.id) {
@@ -168,15 +90,7 @@ async function handleGetReview(ctx, params) {
             if (comment.authorAgentId)
                 agentIds.add(comment.authorAgentId);
         }
-        const agentNameById = new Map();
-        for (const agentId of agentIds) {
-            try {
-                const agent = await ctx.storage.getAgent(agentId);
-                agentNameById.set(agentId, agent.name);
-            }
-            catch {
-            }
-        }
+        const agentNameById = await (0, agent_name_resolver_1.resolveAgentNames)(ctx.storage, agentIds);
         const comments = commentsResult.items.map((comment) => ({
             id: comment.id,
             filePath: comment.filePath,
@@ -224,6 +138,15 @@ async function handleGetReview(ctx, params) {
         return { success: true, data: response };
     }
     catch (error) {
+        if (error instanceof service_unavailable_error_1.ServiceUnavailableError) {
+            return {
+                success: false,
+                error: {
+                    code: 'SERVICE_UNAVAILABLE',
+                    message: 'ReviewsService is not available',
+                },
+            };
+        }
         if (error instanceof error_types_1.NotFoundError) {
             return {
                 success: false,
@@ -237,29 +160,12 @@ async function handleGetReview(ctx, params) {
     }
 }
 async function handleGetReviewComments(ctx, params) {
-    const validated = mcp_dto_1.GetReviewCommentsParamsSchema.parse(params);
-    const sessionCtxResult = await resolveSessionContext(ctx, validated.sessionId);
-    if (!sessionCtxResult.success)
-        return sessionCtxResult;
-    const { project } = sessionCtxResult.data;
-    if (!project) {
-        return {
-            success: false,
-            error: {
-                code: 'PROJECT_NOT_FOUND',
-                message: 'No project associated with this session',
-            },
-        };
-    }
-    if (!ctx.reviewsService) {
-        return {
-            success: false,
-            error: {
-                code: 'SERVICE_UNAVAILABLE',
-                message: 'ReviewsService is not available',
-            },
-        };
-    }
+    const validated = params;
+    const sessionCtxResult = await (0, session_context_helpers_1.resolveSessionContext)(ctx, validated.sessionId);
+    const projectResult = (0, require_project_1.requireProject)(sessionCtxResult);
+    if (!('project' in projectResult))
+        return projectResult;
+    const { project } = projectResult;
     try {
         const review = await ctx.storage.getReview(validated.reviewId);
         if (review.projectId !== project.id) {
@@ -282,15 +188,7 @@ async function handleGetReviewComments(ctx, params) {
             if (comment.authorAgentId)
                 agentIds.add(comment.authorAgentId);
         }
-        const agentNameById = new Map();
-        for (const agentId of agentIds) {
-            try {
-                const agent = await ctx.storage.getAgent(agentId);
-                agentNameById.set(agentId, agent.name);
-            }
-            catch {
-            }
-        }
+        const agentNameById = await (0, agent_name_resolver_1.resolveAgentNames)(ctx.storage, agentIds);
         const comments = result.items.map((comment) => ({
             id: comment.id,
             filePath: comment.filePath,
@@ -317,6 +215,15 @@ async function handleGetReviewComments(ctx, params) {
         return { success: true, data: response };
     }
     catch (error) {
+        if (error instanceof service_unavailable_error_1.ServiceUnavailableError) {
+            return {
+                success: false,
+                error: {
+                    code: 'SERVICE_UNAVAILABLE',
+                    message: 'ReviewsService is not available',
+                },
+            };
+        }
         if (error instanceof error_types_1.NotFoundError) {
             return {
                 success: false,
@@ -330,13 +237,13 @@ async function handleGetReviewComments(ctx, params) {
     }
 }
 async function handleReplyComment(ctx, params) {
-    const validated = mcp_dto_1.ReplyCommentParamsSchema.parse(params);
-    const sessionCtxResult = await resolveSessionContext(ctx, validated.sessionId);
+    const validated = params;
+    const sessionCtxResult = await (0, session_context_helpers_1.resolveSessionContext)(ctx, validated.sessionId);
     if (!sessionCtxResult.success)
         return sessionCtxResult;
     const sessionCtx = sessionCtxResult.data;
     const { project } = sessionCtx;
-    const actor = getActorFromContext(sessionCtx);
+    const actor = (0, session_context_helpers_1.getActorFromContext)(sessionCtx);
     if (!project) {
         return {
             success: false,
@@ -346,15 +253,6 @@ async function handleReplyComment(ctx, params) {
             },
         };
     }
-    if (!ctx.reviewsService) {
-        return {
-            success: false,
-            error: {
-                code: 'SERVICE_UNAVAILABLE',
-                message: 'ReviewsService is not available',
-            },
-        };
-    }
     try {
         const review = await ctx.storage.getReview(validated.reviewId);
         if (review.projectId !== project.id) {
@@ -408,33 +306,25 @@ async function handleReplyComment(ctx, params) {
                 },
             };
         }
+        if (error instanceof service_unavailable_error_1.ServiceUnavailableError) {
+            return {
+                success: false,
+                error: {
+                    code: 'SERVICE_UNAVAILABLE',
+                    message: 'ReviewsService is not available',
+                },
+            };
+        }
         throw error;
     }
 }
 async function handleResolveComment(ctx, params) {
-    const validated = mcp_dto_1.ResolveCommentParamsSchema.parse(params);
-    const sessionCtxResult = await resolveSessionContext(ctx, validated.sessionId);
-    if (!sessionCtxResult.success)
-        return sessionCtxResult;
-    const { project } = sessionCtxResult.data;
-    if (!project) {
-        return {
-            success: false,
-            error: {
-                code: 'PROJECT_NOT_FOUND',
-                message: 'No project associated with this session',
-            },
-        };
-    }
-    if (!ctx.reviewsService) {
-        return {
-            success: false,
-            error: {
-                code: 'SERVICE_UNAVAILABLE',
-                message: 'ReviewsService is not available',
-            },
-        };
-    }
+    const validated = params;
+    const sessionCtxResult = await (0, session_context_helpers_1.resolveSessionContext)(ctx, validated.sessionId);
+    const projectResult = (0, require_project_1.requireProject)(sessionCtxResult);
+    if (!('project' in projectResult))
+        return projectResult;
+    const { project } = projectResult;
     try {
         const comment = await ctx.storage.getReviewComment(validated.commentId);
         const review = await ctx.storage.getReview(comment.reviewId);
@@ -448,15 +338,7 @@ async function handleResolveComment(ctx, params) {
             };
         }
         const updatedComment = await ctx.reviewsService.resolveComment(comment.reviewId, validated.commentId, validated.resolution, validated.version);
-        let authorAgentName;
-        if (updatedComment.authorAgentId) {
-            try {
-                const agent = await ctx.storage.getAgent(updatedComment.authorAgentId);
-                authorAgentName = agent.name;
-            }
-            catch {
-            }
-        }
+        const agentNameById = await (0, agent_name_resolver_1.resolveAgentNames)(ctx.storage, updatedComment.authorAgentId ? new Set([updatedComment.authorAgentId]) : new Set());
         const response = {
             comment: {
                 id: updatedComment.id,
@@ -469,7 +351,9 @@ async function handleResolveComment(ctx, params) {
                 status: updatedComment.status,
                 authorType: updatedComment.authorType,
                 authorAgentId: updatedComment.authorAgentId,
-                authorAgentName,
+                authorAgentName: updatedComment.authorAgentId
+                    ? agentNameById.get(updatedComment.authorAgentId)
+                    : undefined,
                 parentId: updatedComment.parentId,
                 version: updatedComment.version,
                 createdAt: updatedComment.createdAt,
@@ -479,6 +363,15 @@ async function handleResolveComment(ctx, params) {
         return { success: true, data: response };
     }
     catch (error) {
+        if (error instanceof service_unavailable_error_1.ServiceUnavailableError) {
+            return {
+                success: false,
+                error: {
+                    code: 'SERVICE_UNAVAILABLE',
+                    message: 'ReviewsService is not available',
+                },
+            };
+        }
         if (error instanceof error_types_1.NotFoundError) {
             return {
                 success: false,
@@ -492,162 +385,71 @@ async function handleResolveComment(ctx, params) {
     }
 }
 async function handleApplySuggestion(ctx, params) {
-    const validated = mcp_dto_1.ApplySuggestionParamsSchema.parse(params);
-    const sessionCtxResult = await resolveSessionContext(ctx, validated.sessionId);
-    if (!sessionCtxResult.success)
-        return sessionCtxResult;
-    const { project } = sessionCtxResult.data;
-    if (!project) {
-        return {
-            success: false,
-            error: {
-                code: 'PROJECT_NOT_FOUND',
-                message: 'No project associated with this session',
+    const validated = params;
+    const sessionCtxResult = await (0, session_context_helpers_1.resolveSessionContext)(ctx, validated.sessionId);
+    const projectResult = (0, require_project_1.requireProject)(sessionCtxResult);
+    if (!('project' in projectResult))
+        return projectResult;
+    const { project } = projectResult;
+    try {
+        const result = await ctx.reviewSuggestionApplier.apply({
+            commentId: validated.commentId,
+            projectId: project.id,
+            projectRootPath: project.rootPath,
+            version: validated.version,
+        });
+        const agentNameById = await (0, agent_name_resolver_1.resolveAgentNames)(ctx.storage, result.updatedComment.authorAgentId
+            ? new Set([result.updatedComment.authorAgentId])
+            : new Set());
+        const response = {
+            comment: {
+                id: result.updatedComment.id,
+                filePath: result.updatedComment.filePath,
+                lineStart: result.updatedComment.lineStart,
+                lineEnd: result.updatedComment.lineEnd,
+                side: result.updatedComment.side,
+                content: result.updatedComment.content,
+                commentType: result.updatedComment.commentType,
+                status: result.updatedComment.status,
+                authorType: result.updatedComment.authorType,
+                authorAgentId: result.updatedComment.authorAgentId,
+                authorAgentName: result.updatedComment.authorAgentId
+                    ? agentNameById.get(result.updatedComment.authorAgentId)
+                    : undefined,
+                parentId: result.updatedComment.parentId,
+                version: result.updatedComment.version,
+                createdAt: result.updatedComment.createdAt,
+                updatedAt: result.updatedComment.updatedAt,
             },
-        };
-    }
-    if (!ctx.reviewsService) {
-        return {
-            success: false,
-            error: {
-                code: 'SERVICE_UNAVAILABLE',
-                message: 'ReviewsService is not available',
+            applied: {
+                filePath: result.filePath,
+                lineStart: result.lineStart,
+                lineEnd: result.lineEnd,
+                suggestedCode: result.suggestedCode,
             },
         };
+        return { success: true, data: response };
     }
-    try {
-        const comment = await ctx.storage.getReviewComment(validated.commentId);
-        const review = await ctx.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) {
+    catch (error) {
+        if (error instanceof service_unavailable_error_1.ServiceUnavailableError) {
             return {
                 success: false,
                 error: {
-                    code: 'INVALID_SUGGESTION',
-                    message: 'Comment does not have file path or line information',
+                    code: 'SERVICE_UNAVAILABLE',
+                    message: 'ReviewSuggestionApplier is not available',
                 },
             };
         }
-        const suggestionMatch = comment.content.match(/```suggestion\s*\n([\s\S]*?)```/);
-        if (!suggestionMatch) {
+        if (error instanceof review_suggestion_applier_service_1.SuggestionApplicationError) {
             return {
                 success: false,
                 error: {
-                    code: 'NO_SUGGESTION',
-                    message: 'Comment does not contain a suggestion block',
+                    code: error.code,
+                    message: error.message,
+                    ...(error.details && { data: error.details }),
                 },
             };
         }
-        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 ctx.reviewsService.resolveComment(comment.reviewId, validated.commentId, 'resolved', validated.version);
-        let authorAgentName;
-        if (updatedComment.authorAgentId) {
-            try {
-                const agent = await ctx.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,