devchain-cli 0.10.5 → 0.11.1

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

@@ -0,0 +1,672 @@
+"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;
+exports.handleGetReviewComments = handleGetReviewComments;
+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);
+}
+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',
+            },
+        };
+    }
+    if (!ctx.reviewsService) {
+        return {
+            success: false,
+            error: {
+                code: 'SERVICE_UNAVAILABLE',
+                message: 'ReviewsService is not available',
+            },
+        };
+    }
+    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',
+            },
+        };
+    }
+    try {
+        const reviewWithFiles = await ctx.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 ctx.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 ctx.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 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',
+            },
+        };
+    }
+    try {
+        const review = await ctx.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 ctx.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 ctx.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 function handleReplyComment(ctx, params) {
+    const validated = mcp_dto_1.ReplyCommentParamsSchema.parse(params);
+    const sessionCtxResult = await resolveSessionContext(ctx, validated.sessionId);
+    if (!sessionCtxResult.success)
+        return sessionCtxResult;
+    const sessionCtx = sessionCtxResult.data;
+    const { project } = sessionCtx;
+    const actor = getActorFromContext(sessionCtx);
+    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',
+            },
+        };
+    }
+    try {
+        const review = await ctx.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 ctx.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 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',
+            },
+        };
+    }
+    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`,
+                },
+            };
+        }
+        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 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 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',
+            },
+        };
+    }
+    if (!ctx.reviewsService) {
+        return {
+            success: false,
+            error: {
+                code: 'SERVICE_UNAVAILABLE',
+                message: 'ReviewsService is not available',
+            },
+        };
+    }
+    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) {
+            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 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,
+                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;
+    }
+}
+//# sourceMappingURL=review-tools.js.map