@renfeng/kiro-code-review 1.9.0

package/dist/services/review-tools.service.js

@@ -0,0 +1,902 @@
+/**
+ * Review Tools Service
+ *
+ * Implements business logic for the code review and todo triage MCP tools.
+ */
+import { GitLabAPI } from '../api/gitlab-api.js';
+import { Logger } from '../logging/logger.service.js';
+import { readFileSync } from 'fs';
+import { resolveAnchorInDiff } from './anchor-resolver.js';
+import { GitToolsService } from './git-tools.service.js';
+/** HTML comment marker to identify the non-blocking checklist draft */
+const CHECKLIST_MARKER = '<!-- non-blocking-checklist -->';
+export class ReviewToolsService {
+    logger;
+    gitTools;
+    constructor(logger) {
+        this.logger = logger || new Logger('ReviewToolsService');
+    }
+    createApi(gitlabUrl, token) {
+        return new GitLabAPI({ baseUrl: gitlabUrl, token }, this.logger.child('GitLabAPI'));
+    }
+    async getProjectSettings(params, gitlabUrl, token) {
+        const api = this.createApi(gitlabUrl, token);
+        return api.getProjectSettings(String(params.project));
+    }
+    async extractMrMetadata(params, gitlabUrl, token) {
+        const api = this.createApi(gitlabUrl, token);
+        return api.getMergeRequestMetadata(String(params.project), params.mergeRequestIid);
+    }
+    async extractVersionRefs(params, gitlabUrl, token) {
+        const api = this.createApi(gitlabUrl, token);
+        const versions = await api.getMergeRequestVersions(String(params.project), params.mergeRequestIid);
+        if (!versions.length)
+            throw new Error(`No versions found for MR !${params.mergeRequestIid}`);
+        const latest = versions[0];
+        return { head_sha: latest.head_commit_sha, base_sha: latest.base_commit_sha, start_sha: latest.start_commit_sha };
+    }
+    async extractPriorDiscussions(params, gitlabUrl, token) {
+        const api = this.createApi(gitlabUrl, token);
+        const discussions = await api.getDiscussions(String(params.project), params.mergeRequestIid);
+        const result = [];
+        for (const d of discussions) {
+            const notes = d.notes || [];
+            if (!notes.length)
+                continue;
+            const first = notes[0];
+            if (!first.resolvable || first.system)
+                continue;
+            result.push({
+                discussionId: d.id,
+                file: first.position?.new_path ?? null,
+                line: first.position?.new_line ?? null,
+                resolved: !!first.resolved,
+                topic: (first.body || '').slice(0, 300),
+                replies: notes.slice(1).filter(n => !n.system).map(n => ({
+                    author: n.author?.username || 'unknown',
+                    body: (n.body || '').slice(0, 300),
+                })),
+            });
+        }
+        return result;
+    }
+    async extractDraftNotes(params, gitlabUrl, token) {
+        const api = this.createApi(gitlabUrl, token);
+        const drafts = await api.getDraftNotes(String(params.project), params.mergeRequestIid);
+        return drafts.map(d => ({
+            id: d.id,
+            note: (d.note || '').slice(0, 500),
+            file: d.position?.new_path ?? d.position?.old_path ?? null,
+            line: d.position?.new_line ?? null,
+            old_line: d.position?.old_line ?? null,
+        }));
+    }
+    async postDraftNotes(params, gitlabUrl, token) {
+        const api = this.createApi(gitlabUrl, token);
+        const project = String(params.project);
+        const mr = params.mergeRequestIid;
+        const { headSha, baseSha, startSha, findings } = params;
+        const comments = findings.comments || [];
+        // Resolve anchor-based findings to line numbers when repo context is available
+        if (params.repoDir && params.mergeBase) {
+            if (!this.gitTools)
+                this.gitTools = new GitToolsService(this.logger.child('GitTools'));
+            const diffCache = new Map();
+            for (const c of comments) {
+                if (!c.file || !c.anchor || c.changed === 'general')
+                    continue;
+                if (c.line != null || c.old_line != null)
+                    continue; // already resolved
+                let fileDiff = diffCache.get(c.file);
+                if (fileDiff === undefined) {
+                    try {
+                        fileDiff = await this.gitTools.runGit(params.repoDir, ['diff', params.mergeBase, 'HEAD', '--', c.file]);
+                        diffCache.set(c.file, fileDiff);
+                    }
+                    catch {
+                        diffCache.set(c.file, null);
+                        c.changed = 'general';
+                        continue;
+                    }
+                }
+                if (!fileDiff) {
+                    c.changed = 'general';
+                    continue;
+                }
+                const result = resolveAnchorInDiff(fileDiff, c);
+                if (result) {
+                    c.changed = result.changed;
+                    c.line = result.line;
+                    c.old_line = result.old_line;
+                }
+                else {
+                    c.changed = 'general';
+                }
+            }
+            this.logger.info('Anchor resolution complete (inline)', {
+                total: comments.length,
+                resolved: comments.filter((c) => c.line != null || c.old_line != null).length,
+            });
+        }
+        let posted = 0, blockingCount = 0, nonBlockingCount = 0;
+        const errors = [];
+        for (let i = 0; i < comments.length; i++) {
+            const c = comments[i];
+            const note = c.note || '';
+            const filePath = c.file;
+            const line = c.line;
+            const oldLine = c.old_line;
+            const changed = c.changed || 'new';
+            if (c.blocking !== false)
+                blockingCount++;
+            else {
+                nonBlockingCount++;
+                continue; // Non-blocking findings are compiled into a checklist draft at the end
+            }
+            let bodyDict;
+            if (!filePath || (line == null && oldLine == null) || changed === 'general') {
+                // Prepend a file link when file context is available (e.g. anchor on unchanged line)
+                if (filePath) {
+                    const fileUrl = `${gitlabUrl}/${project}/-/blob/${headSha}/${filePath}`;
+                    const lineNum = line ?? oldLine;
+                    const linkText = lineNum ? `([L${lineNum}](${fileUrl}#L${lineNum}))` : `([link](${fileUrl}))`;
+                    bodyDict = { note: `**\`${filePath}\`** ${linkText}\n\n${note}` };
+                }
+                else {
+                    bodyDict = { note };
+                }
+            }
+            else {
+                const position = {
+                    position_type: 'text', base_sha: baseSha, start_sha: startSha, head_sha: headSha,
+                    old_path: filePath, new_path: filePath,
+                };
+                if (changed === 'new') {
+                    position.old_line = null;
+                    position.new_line = line;
+                }
+                else if (changed === 'old') {
+                    position.old_line = oldLine;
+                    position.new_line = null;
+                }
+                else if (changed === 'context') {
+                    position.old_line = oldLine ?? line;
+                    position.new_line = line;
+                }
+                else {
+                    position.new_line = line;
+                }
+                bodyDict = { note, position };
+            }
+            try {
+                const result = await api.postDraftNote(project, mr, bodyDict);
+                this.logger.debug(`OK: comment ${i} draft=${result.id} line_code=${result.line_code}`);
+                // GitLab bug: deleted-line inline comments (old_line only) often get
+                // line_code=null, causing ghost duplication or invisible comments.
+                // Detect and repost as a general note with file context in the body.
+                if (changed === 'old' && !result.line_code) {
+                    this.logger.warn(`comment ${i}: line_code=null on deleted line, reposting as general note`);
+                    try {
+                        await api.deleteDraftNote(project, mr, result.id);
+                    }
+                    catch { /* best effort */ }
+                    const prefix = `**\`${filePath}\`** (removed line ~${oldLine})\n\n`;
+                    const fallback = await api.postDraftNote(project, mr, { note: prefix + note });
+                    this.logger.debug(`OK: comment ${i} reposted as general draft=${fallback.id}`);
+                }
+                posted++;
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                errors.push({ index: i, error: msg });
+                this.logger.warn(`FAIL: comment ${i}: ${msg}`);
+            }
+        }
+        // Post non-blocking findings as a single general checklist draft
+        if (nonBlockingCount > 0) {
+            const nonBlocking = comments.filter(c => c.blocking === false && c.note);
+            const lines = ['### Suggestions', ''];
+            for (const nb of nonBlocking) {
+                const firstLine = nb.note.split('\n')[0];
+                const noteOneLine = nb.note.includes('\n') ? firstLine + ' …' : firstLine;
+                if (!nb.file) {
+                    lines.push(`- [ ] **General**: ${noteOneLine}`);
+                }
+                else {
+                    const fileUrl = `${gitlabUrl}/${project}/-/blob/${headSha}/${nb.file}`;
+                    const lineNum = nb.line ?? nb.old_line;
+                    if (lineNum) {
+                        lines.push(`- [ ] **${nb.file}** ([L${lineNum}](${fileUrl}#L${lineNum})): ${noteOneLine}`);
+                    }
+                    else {
+                        lines.push(`- [ ] **${nb.file}** ([link](${fileUrl})): ${noteOneLine}`);
+                    }
+                }
+            }
+            try {
+                const checklistBody = lines.join('\n');
+                await api.postDraftNote(project, mr, { note: CHECKLIST_MARKER + '\n' + checklistBody });
+                posted++;
+                this.logger.info('Non-blocking checklist posted as general draft');
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                errors.push({ index: -1, error: `checklist draft: ${msg}` });
+                this.logger.warn(`FAIL: checklist draft: ${msg}`);
+            }
+        }
+        this.logger.info('Draft notes posted', { posted, blocking: blockingCount, non_blocking: nonBlockingCount, errors: errors.length });
+        return { posted, blocking: blockingCount, non_blocking: nonBlockingCount, errors };
+    }
+    async deleteDraftNotes(params, gitlabUrl, token) {
+        const api = this.createApi(gitlabUrl, token);
+        const project = String(params.project);
+        const mr = params.mergeRequestIid;
+        let draftsToDelete;
+        if (params.draftNoteIds?.length) {
+            draftsToDelete = params.draftNoteIds.map(id => ({ id }));
+        }
+        else {
+            draftsToDelete = await api.getDraftNotes(project, mr);
+        }
+        if (draftsToDelete.length === 0)
+            return { deleted: 0, errors: [] };
+        let deleted = 0;
+        const errors = [];
+        for (const draft of draftsToDelete) {
+            try {
+                await api.deleteDraftNote(project, mr, draft.id);
+                deleted++;
+            }
+            catch (err) {
+                errors.push(`Failed to delete draft ${draft.id}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        this.logger.info('Draft notes deleted', { deleted, total: draftsToDelete.length, errors: errors.length });
+        return { deleted, errors };
+    }
+    async publishReview(params, gitlabUrl, token) {
+        const api = this.createApi(gitlabUrl, token);
+        const project = String(params.project);
+        const mr = params.mergeRequestIid;
+        // Step 1: Read actual drafts — the user may have edited or deleted some
+        const drafts = await api.getDraftNotes(project, mr);
+        // Extract checklist draft (non-blocking) before bulk publish
+        let checklistBody = null;
+        let blockingDraftCount = 0;
+        for (const draft of drafts) {
+            if (draft.note.includes(CHECKLIST_MARKER)) {
+                checklistBody = draft.note.slice(draft.note.indexOf(CHECKLIST_MARKER) + CHECKLIST_MARKER.length).trim();
+                try {
+                    await api.deleteDraftNote(project, mr, draft.id);
+                    this.logger.info(`Extracted checklist draft ${draft.id} for plain comment repost`);
+                }
+                catch (err) {
+                    this.logger.warn(`Failed to delete checklist draft ${draft.id}, it will be bulk-published as resolvable: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+            else {
+                blockingDraftCount++;
+            }
+        }
+        // Step 2: Bulk publish remaining drafts (blocking only now)
+        this.logger.info('Publishing draft notes...');
+        const publishOk = await api.bulkPublishDraftNotes(project, mr);
+        // Step 3: Re-post checklist as a plain (non-resolvable) comment
+        if (checklistBody) {
+            try {
+                await api.postNote(project, mr, checklistBody);
+                this.logger.info('Non-blocking checklist posted as plain comment');
+            }
+            catch (err) {
+                this.logger.warn(`Failed to post non-blocking checklist as plain comment: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        // Step 4: Award emoji on published notes (best-effort)
+        // Lazy-load username — only needed here and for reviewer assignment
+        let username;
+        const getUsername = async () => {
+            if (!username) {
+                const currentUser = await api.getCurrentUser();
+                username = currentUser.username || 'me';
+            }
+            return username;
+        };
+        const emojiResult = await this.awardEmojiOnPublishedNotes(api, project, mr, await getUsername(), params.emojiName);
+        // Step 5: Determine and apply verdict from actual drafts (unless opted out)
+        const applyVerdict = params.applyVerdict !== false;
+        const threadsBlockMerge = params.threadsBlockMerge === true;
+        let action = blockingDraftCount > 0 ? 'request_changes' : 'approve';
+        let actionSuccess = true;
+        if (!applyVerdict) {
+            this.logger.info(`Verdict skipped (applyVerdict=false). Determined verdict: ${action}`);
+            action = 'comment_only';
+        }
+        else if (action === 'request_changes') {
+            if (threadsBlockMerge) {
+                this.logger.info('Skipping /request_changes — project requires all threads resolved before merge (unresolved blocking threads already prevent merging)');
+                action = 'comment_only';
+            }
+            else {
+                this.logger.info('Requesting changes...');
+                try {
+                    const resp = await api.postNote(project, mr, '/request_changes');
+                    const respText = typeof resp === 'string' ? resp : JSON.stringify(resp || '');
+                    if (respText.includes('Could not apply') || respText.toLowerCase().includes('error')) {
+                        this.logger.warn('/request_changes failed — falling back to comment-only');
+                        action = 'comment_only';
+                        actionSuccess = false;
+                    }
+                }
+                catch {
+                    action = 'comment_only';
+                    actionSuccess = false;
+                }
+            }
+        }
+        else if (action === 'approve') {
+            this.logger.info('Approving MR...');
+            await api.postNote(project, mr, '/approve');
+        }
+        else {
+            this.logger.info('Comment-only review — no action applied');
+        }
+        // Step 6: Self-assign as reviewer only when /request_changes was actually applied
+        let reviewerUsername = '';
+        if (action === 'request_changes') {
+            const uname = await getUsername();
+            this.logger.info(`Assigning ${uname} as reviewer (request_changes)...`);
+            await api.postNote(project, mr, `/assign_reviewer @${uname}`);
+            reviewerUsername = uname;
+        }
+        else {
+            this.logger.info('Skipping reviewer assignment — not requesting changes');
+        }
+        return { publish_ok: publishOk, resolved_threads: 0, reviewer_assigned: reviewerUsername, action, action_success: actionSuccess, emojis: emojiResult };
+    }
+    async postComment(params, gitlabUrl, token) {
+        const api = this.createApi(gitlabUrl, token);
+        const project = String(params.project);
+        const mr = params.mergeRequestIid;
+        // Unescape double-escaped newlines from MCP JSON serialization round-trip
+        const body = params.body.replace(/\\n/g, '\n');
+        const result = await api.postNote(project, mr, body);
+        const noteUrl = `${gitlabUrl}/${project}/-/merge_requests/${mr}#note_${result.id}`;
+        this.logger.info('Comment posted', { noteId: result.id, mr });
+        return { id: result.id, url: noteUrl };
+    }
+    async editNote(params, gitlabUrl, token) {
+        const api = this.createApi(gitlabUrl, token);
+        const project = String(params.project);
+        const mr = params.mergeRequestIid;
+        // Unescape double-escaped newlines from MCP JSON serialization round-trip
+        const body = params.body.replace(/\\n/g, '\n');
+        const result = await api.editNote(project, mr, params.noteId, body);
+        const noteUrl = `${gitlabUrl}/${project}/-/merge_requests/${mr}#note_${result.id}`;
+        this.logger.info('Note edited', { noteId: result.id, mr });
+        return { id: result.id, body: result.body, url: noteUrl };
+    }
+    isRenovate(title, sourceBranch = '') {
+        const t = title.toLowerCase();
+        return t.startsWith('[renovate') || title.includes('chore(deps):') || title.includes('fix(deps):') || sourceBranch.startsWith('renovate/');
+    }
+    async fetchAndCategorizeTodos(_params, gitlabUrl, token) {
+        const api = this.createApi(gitlabUrl, token);
+        const todos = await api.getTodos('pending');
+        const done = [];
+        const review = [];
+        const skip = [];
+        for (const t of todos) {
+            const target = (t.target || {});
+            const targetType = String(t.target_type || '');
+            const action = String(t.action_name || '');
+            const state = String(target.state || '');
+            const title = String(target.title || '');
+            const mrIid = target.iid || '';
+            const projectObj = (t.project || {});
+            const projectPath = String(projectObj.path_with_namespace || '');
+            const todoId = t.id;
+            const webUrl = String(target.web_url || '');
+            const sourceBranch = String(target.source_branch || '');
+            const item = { todo_id: todoId, target_type: targetType, action, state, title, mr_iid: mrIid, project: projectPath, web_url: webUrl };
+            if (targetType !== 'MergeRequest') {
+                item.reason = 'not a merge request';
+                skip.push(item);
+                continue;
+            }
+            const isDraft = title.startsWith('Draft:');
+            const isRenovate = this.isRenovate(title, sourceBranch);
+            if (state === 'merged' || state === 'closed' || isDraft || isRenovate) {
+                if (state === 'merged' || state === 'closed')
+                    item.reason = state;
+                else if (isDraft)
+                    item.reason = 'draft';
+                else
+                    item.reason = 'renovate';
+                done.push(item);
+                continue;
+            }
+            if (state === 'opened' && ['review_requested', 'marked', 'mentioned'].includes(action)) {
+                review.push(item);
+                continue;
+            }
+            item.reason = `action=${action}, not a review request or mention`;
+            skip.push(item);
+        }
+        // Deduplicate review list by MR — keep the highest-priority action per unique MR
+        const actionPriority = { marked: 0, review_requested: 1, mentioned: 2 };
+        const reviewByMr = new Map();
+        for (const item of review) {
+            const key = `${item.project}:${item.mr_iid}`;
+            const existing = reviewByMr.get(key);
+            if (!existing || (actionPriority[item.action] ?? 99) < (actionPriority[existing.action] ?? 99)) {
+                if (existing) {
+                    existing.reason = 'duplicate';
+                    done.push(existing);
+                }
+                reviewByMr.set(key, item);
+            }
+            else {
+                item.reason = 'duplicate';
+                done.push(item);
+            }
+        }
+        const deduplicatedReview = [...reviewByMr.values()];
+        const dupeCount = review.length - deduplicatedReview.length;
+        if (dupeCount > 0)
+            this.logger.info(`Deduplicated ${dupeCount} duplicate MR todos`);
+        this.logger.info(`Categorized ${todos.length} todos`, { done: done.length, review: deduplicatedReview.length, skip: skip.length });
+        return { done, review: deduplicatedReview, skip };
+    }
+    async markTodosDone(params, gitlabUrl, token) {
+        const api = this.createApi(gitlabUrl, token);
+        const results = [];
+        for (const todoId of params.todoIds) {
+            try {
+                const resp = await api.markTodoDone(todoId);
+                results.push({ todo_id: todoId, state: resp.state || 'done' });
+            }
+            catch (err) {
+                results.push({ todo_id: todoId, error: err instanceof Error ? err.message : String(err) });
+            }
+        }
+        const succeeded = results.filter(r => r.state).length;
+        this.logger.info(`Marked ${succeeded}/${params.todoIds.length} todos as done`);
+        return results;
+    }
+    // --- Author workflow tools ---
+    async listNotes(params, gitlabUrl, token) {
+        const api = this.createApi(gitlabUrl, token);
+        const project = String(params.project);
+        const sort = params.sort ?? 'desc';
+        const perPage = params.perPage ?? 20;
+        this.logger.info('Listing notes', { project, mr: params.mergeRequestIid, sort, perPage });
+        const notes = await api.getNotes(project, params.mergeRequestIid, sort, perPage);
+        return notes.map(n => ({
+            id: n.id,
+            author: n.author.username,
+            body: n.body,
+            system: n.system,
+            created_at: n.created_at,
+        }));
+    }
+    async replyToDiscussion(params, gitlabUrl, token) {
+        const api = this.createApi(gitlabUrl, token);
+        const project = String(params.project);
+        this.logger.info('Replying to discussion', { project, mr: params.mergeRequestIid, discussionId: params.discussionId });
+        const result = await api.replyToDiscussion(project, params.mergeRequestIid, params.discussionId, params.body);
+        return { id: result.id, body: result.body };
+    }
+    async resolveDiscussion(params, gitlabUrl, token) {
+        const api = this.createApi(gitlabUrl, token);
+        const project = String(params.project);
+        const resolved = params.resolved ?? true;
+        this.logger.info('Setting discussion resolved', { project, mr: params.mergeRequestIid, discussionId: params.discussionId, resolved });
+        await api.setDiscussionResolved(project, params.mergeRequestIid, params.discussionId, resolved);
+        return { discussionId: params.discussionId, resolved };
+    }
+    // --- Checklist compilation (moved from review-utils — GitLab-specific) ---
+    async compileChecklist(params, gitlabUrl, token) {
+        // token unused — checklist reads from local findings file and constructs URLs
+        void token;
+        this.logger.info('Compiling checklist', { findingsPath: params.findingsPath, project: params.project });
+        const raw = readFileSync(params.findingsPath, 'utf-8');
+        const findings = JSON.parse(raw);
+        // Normalize 'comment' → 'note' alias
+        for (const c of findings.comments) {
+            const r = c;
+            if (!c.note && r['comment']) {
+                c.note = r['comment'];
+                delete r['comment'];
+            }
+        }
+        const baseUrl = gitlabUrl.replace(/\/+$/, '');
+        const nonBlocking = findings.comments.filter(c => !c.blocking);
+        if (nonBlocking.length === 0) {
+            return { markdown: '', itemCount: 0 };
+        }
+        const lines = ['### Suggestions', ''];
+        for (const comment of nonBlocking) {
+            if (!comment.note)
+                continue;
+            const firstLine = comment.note.split('\n')[0];
+            const noteOneLine = comment.note.includes('\n') ? firstLine + ' …' : firstLine;
+            if (!comment.file) {
+                lines.push(`- [ ] **General**: ${noteOneLine}`);
+                continue;
+            }
+            const fileUrl = `${baseUrl}/${params.project}/-/blob/${params.headSha}/${comment.file}`;
+            const lineNum = comment.line ?? comment.old_line;
+            if (lineNum) {
+                lines.push(`- [ ] **${comment.file}** ([L${lineNum}](${fileUrl}#L${lineNum})): ${noteOneLine}`);
+            }
+            else {
+                lines.push(`- [ ] **${comment.file}** ([link](${fileUrl})): ${noteOneLine}`);
+            }
+        }
+        const markdown = lines.join('\n');
+        const itemCount = lines.length - 2;
+        this.logger.info('Checklist compiled', { itemCount });
+        return { markdown, itemCount };
+    }
+    // --- Emoji Attribution ---
+    /**
+     * Award emoji on all non-system notes authored by the current user.
+     * Best-effort: failures are logged but don't break the publish flow.
+     */
+    async awardEmojiOnPublishedNotes(api, project, mr, username, emojiName) {
+        const emoji = emojiName || 'robot';
+        let awarded = 0;
+        let failed = 0;
+        try {
+            // getNotes fetches at most 100 notes (GitLab's per-page cap). On MRs with >100
+            // notes, older bot notes beyond the first page won't receive emoji. Acceptable
+            // for a best-effort feature since newest notes (desc order) are fetched first.
+            const notes = await api.getNotes(project, mr, 'desc', 100);
+            const myNotes = notes.filter(n => n.author.username === username && !n.system);
+            // Only award emoji on notes that don't already have it (avoids 409 on re-runs)
+            this.logger.info(`Awarding :${emoji}: on ${myNotes.length} notes`);
+            for (const note of myNotes) {
+                try {
+                    await api.awardEmoji(project, mr, emoji, note.id);
+                    awarded++;
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    // 409 Conflict = emoji already awarded — skip silently
+                    if (msg.includes('409 Conflict')) {
+                        this.logger.debug(`Emoji already awarded on note ${note.id}`);
+                    }
+                    else {
+                        this.logger.debug(`Failed to award emoji on note ${note.id}: ${msg}`);
+                        failed++;
+                    }
+                }
+            }
+        }
+        catch (err) {
+            this.logger.warn(`Failed to award emoji (best-effort): ${err instanceof Error ? err.message : String(err)}`);
+        }
+        return { awarded, failed, emoji_used: emoji };
+    }
+    // --- Custom Emoji ---
+    async checkCustomEmoji(params, gitlabUrl, token) {
+        const api = this.createApi(gitlabUrl, token);
+        const name = params.emojiName || 'kiro';
+        if (!params.groupPath)
+            return { existed: false, name };
+        // Build group paths from closest to root: org/team/frontend → org/team → org
+        const segments = params.groupPath.split('/');
+        const groupPaths = [];
+        for (let i = segments.length; i >= 1; i--) {
+            groupPaths.push(segments.slice(0, i).join('/'));
+        }
+        this.logger.info('Checking if custom emoji exists', { name, groupPaths });
+        for (const groupPath of groupPaths) {
+            try {
+                const existing = await api.getCustomEmoji(groupPath, name);
+                if (existing) {
+                    this.logger.info('Custom emoji found', { name, groupPath });
+                    return { existed: true, name, groupPath };
+                }
+                this.logger.debug('Custom emoji not found at this level', { name, groupPath });
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                this.logger.debug('Cannot query group (permission or API issue), trying parent', { name, groupPath, error: msg });
+            }
+        }
+        this.logger.info('Custom emoji not found at any group level', { name, groupPaths });
+        return { existed: false, name };
+    }
+    async awardEmoji(params, gitlabUrl, token) {
+        const api = this.createApi(gitlabUrl, token);
+        const project = String(params.project);
+        this.logger.info('Awarding emoji', {
+            project, mr: params.mergeRequestIid, noteId: params.noteId, emoji: params.emojiName,
+        });
+        try {
+            return await api.awardEmoji(project, params.mergeRequestIid, params.emojiName, params.noteId);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            // 409 Conflict = emoji already awarded — treat as success (best-effort)
+            if (msg.includes('409 Conflict')) {
+                this.logger.debug('Emoji already awarded (409 conflict)', { project, mr: params.mergeRequestIid, noteId: params.noteId });
+                return { id: 0, name: params.emojiName };
+            }
+            this.logger.warn('Failed to award emoji (best-effort)', { project, mr: params.mergeRequestIid, noteId: params.noteId, error: msg });
+            return { id: 0, name: params.emojiName, error: msg };
+        }
+    }
+    // --- Review Retro ---
+    async listMergeRequests(params, gitlabUrl, token) {
+        const api = this.createApi(gitlabUrl, token);
+        const queryParams = {
+            state: params.state || 'merged',
+            scope: params.scope || 'all',
+            order_by: params.orderBy || 'updated_at',
+            sort: params.sort || 'desc',
+        };
+        if (params.reviewerUsername)
+            queryParams.reviewer_username = params.reviewerUsername;
+        if (params.authorUsername)
+            queryParams.author_username = params.authorUsername;
+        if (params.updatedAfter)
+            queryParams.updated_after = params.updatedAfter;
+        if (params.updatedBefore)
+            queryParams.updated_before = params.updatedBefore;
+        if (params.perPage)
+            queryParams.per_page = String(Math.min(params.perPage, 100));
+        this.logger.info('Listing merge requests', queryParams);
+        const raw = await api.listMergeRequests(queryParams);
+        // Return a compact summary for each MR
+        const results = raw.map(mr => ({
+            project: mr.references?.full?.replace(/!.*$/, '').replace(/^!/, '')
+                || mr.web_url?.match(/^https?:\/\/[^/]+\/(.+)\/-\/merge_requests/)?.[1]
+                || null,
+            mrIid: mr.iid,
+            title: mr.title,
+            state: mr.state,
+            author: mr.author?.username || null,
+            mergedAt: mr.merged_at || null,
+            updatedAt: mr.updated_at || null,
+            webUrl: mr.web_url || null,
+        }));
+        this.logger.info(`Found ${results.length} merge requests`);
+        return { count: results.length, mergeRequests: results };
+    }
+    async batchReviewRetro(params, gitlabUrl, token) {
+        // Step 1: Resolve MR list — either explicit or discovered
+        let mrList;
+        if (params.mergeRequests?.length) {
+            mrList = params.mergeRequests.map(mr => ({
+                project: mr.project, mrIid: mr.mergeRequestIid, title: null, author: null,
+            }));
+        }
+        else if (params.reviewerUsername) {
+            const listResult = await this.listMergeRequests({
+                state: 'merged',
+                reviewerUsername: params.reviewerUsername,
+                updatedAfter: params.updatedAfter,
+                updatedBefore: params.updatedBefore,
+                perPage: 100,
+            }, gitlabUrl, token);
+            mrList = listResult.mergeRequests
+                .filter(mr => mr.project) // skip entries with null project
+                .map(mr => ({ project: mr.project, mrIid: mr.mrIid, title: mr.title, author: mr.author }));
+        }
+        else {
+            throw new Error('Either mergeRequests or reviewerUsername is required');
+        }
+        // Step 2: Filter out excluded authors
+        if (params.excludeAuthors?.length) {
+            const excluded = new Set(params.excludeAuthors.map(a => a.toLowerCase()));
+            mrList = mrList.filter(mr => !mr.author || !excluded.has(mr.author.toLowerCase()));
+        }
+        this.logger.info(`Batch retro: ${mrList.length} MRs to analyze`);
+        // Step 3: Run review_retro on each MR (sequentially to avoid rate limits)
+        const perMr = [];
+        const errors = [];
+        const allCategories = {
+            code_changed: 0, author_explained: 0, reviewer_self_resolved: 0,
+            wont_fix: 0, duplicate: 0, still_open: 0, unknown: 0,
+        };
+        let totalDiscussions = 0;
+        let totalCodeChanged = 0;
+        let totalWithReply = 0;
+        for (const mr of mrList) {
+            try {
+                const result = await this.reviewRetro({
+                    project: mr.project,
+                    mergeRequestIid: mr.mrIid,
+                    reviewer: params.reviewer,
+                }, gitlabUrl, token);
+                perMr.push({
+                    project: mr.project,
+                    mrIid: mr.mrIid,
+                    title: mr.title,
+                    author: mr.author,
+                    total: result.stats.total,
+                    stats: result.stats,
+                });
+                totalDiscussions += result.stats.total;
+                for (const [cat, count] of Object.entries(result.stats.byCategory)) {
+                    allCategories[cat] += count;
+                }
+                totalCodeChanged += result.discussions.filter(d => d.codeChanged).length;
+                totalWithReply += result.discussions.filter(d => d.authorReply !== null).length;
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                errors.push({ project: mr.project, mrIid: mr.mrIid, error: msg });
+                this.logger.warn(`Retro failed for ${mr.project}!${mr.mrIid}: ${msg}`);
+            }
+        }
+        const aggregateStats = {
+            total: totalDiscussions,
+            byCategory: allCategories,
+            codeChangeRate: totalDiscussions > 0 ? totalCodeChanged / totalDiscussions : 0,
+            responseRate: totalDiscussions > 0 ? totalWithReply / totalDiscussions : 0,
+        };
+        const mrsWithDiscussions = perMr.filter(m => m.total > 0).length;
+        this.logger.info('Batch retro complete', {
+            mrCount: mrList.length,
+            mrsWithDiscussions,
+            totalDiscussions,
+            errors: errors.length,
+        });
+        return {
+            mrCount: mrList.length,
+            mrsWithDiscussions,
+            mrsWithZeroDiscussions: mrList.length - mrsWithDiscussions - errors.length,
+            totalDiscussions,
+            aggregateStats,
+            perMr: perMr.filter(m => m.total > 0), // Only include MRs with discussions
+            errors,
+        };
+    }
+    async reviewRetro(params, gitlabUrl, token) {
+        const api = this.createApi(gitlabUrl, token);
+        const project = String(params.project);
+        const mr = params.mergeRequestIid;
+        this.logger.info('Running review retro', { project, mr, reviewer: params.reviewer });
+        // Fetch MR metadata (for author), discussions, and versions in parallel
+        const [mrData, rawDiscussions, versions] = await Promise.all([
+            api.getMergeRequest(project, mr),
+            api.getDiscussions(project, mr),
+            api.getMergeRequestVersions(project, mr),
+        ]);
+        const mrAuthor = mrData?.author?.username ?? null;
+        // Build version timeline: map head_sha → version index (newest = 0)
+        // Versions are returned newest-first by the API
+        const versionBySha = new Map();
+        for (let i = 0; i < versions.length; i++) {
+            versionBySha.set(versions[i].head_commit_sha, i);
+        }
+        // For each version, fetch the changed files (to detect inter-round changes)
+        // Cache to avoid duplicate fetches
+        const versionDiffsCache = new Map();
+        const getVersionDiffs = async (versionId) => {
+            if (versionDiffsCache.has(versionId))
+                return versionDiffsCache.get(versionId);
+            const files = await api.getMergeRequestVersionDiffs(project, mr, versionId);
+            const fileSet = new Set(files);
+            versionDiffsCache.set(versionId, fileSet);
+            return fileSet;
+        };
+        // Collect files changed in versions AFTER a given version index
+        const getFilesChangedAfterVersion = async (versionIndex) => {
+            const changedFiles = new Set();
+            // Versions newer than versionIndex have lower indices (0 = newest)
+            for (let i = 0; i < versionIndex; i++) {
+                const diffs = await getVersionDiffs(versions[i].id);
+                for (const f of diffs)
+                    changedFiles.add(f);
+            }
+            return changedFiles;
+        };
+        const discussions = [];
+        for (const d of rawDiscussions) {
+            const notes = d.notes || [];
+            if (!notes.length)
+                continue;
+            const first = notes[0];
+            if (!first.resolvable || first.system)
+                continue;
+            // Filter by reviewer if specified
+            const reviewerUsername = first.author?.username || 'unknown';
+            if (params.reviewer && reviewerUsername !== params.reviewer)
+                continue;
+            const file = first.position?.new_path ?? null;
+            const line = first.position?.new_line ?? null;
+            const resolved = !!first.resolved;
+            const topic = (first.body || '').slice(0, 300);
+            const commentHeadSha = first.position?.head_sha ?? null;
+            // Detect author replies: replies from the MR author (not the reviewer)
+            const nonSystemReplies = notes.slice(1).filter(n => !n.system);
+            let authorReply = null;
+            if (mrAuthor && mrAuthor !== reviewerUsername) {
+                // Normal case: reviewer != MR author
+                const mrAuthorReplies = nonSystemReplies.filter(n => n.author?.username === mrAuthor);
+                if (mrAuthorReplies.length > 0) {
+                    authorReply = (mrAuthorReplies[0].body || '').slice(0, 300);
+                }
+            }
+            else {
+                // Self-review: reviewer == MR author, any reply counts
+                if (nonSystemReplies.length > 0) {
+                    authorReply = (nonSystemReplies[0].body || '').slice(0, 300);
+                }
+            }
+            // Detect inter-round code changes for the commented file
+            let codeChanged = false;
+            if (file && commentHeadSha) {
+                const commentVersionIndex = versionBySha.get(commentHeadSha);
+                if (commentVersionIndex !== undefined && commentVersionIndex > 0) {
+                    // There are newer versions after this comment was posted
+                    const laterChangedFiles = await getFilesChangedAfterVersion(commentVersionIndex);
+                    codeChanged = laterChangedFiles.has(file);
+                }
+                // If comment is on the latest version (index 0), no later changes exist
+            }
+            const category = this.classifyDiscussion(resolved, authorReply, codeChanged, nonSystemReplies, topic);
+            discussions.push({
+                file, line, topic, resolved, category,
+                authorReply, codeChanged, replyCount: nonSystemReplies.length,
+            });
+        }
+        const stats = this.computeRetroStats(discussions);
+        this.logger.info('Review retro complete', {
+            total: stats.total,
+            codeChangeRate: stats.codeChangeRate,
+            responseRate: stats.responseRate,
+        });
+        return {
+            project,
+            mergeRequestIid: mr,
+            reviewer: params.reviewer ?? null,
+            discussions,
+            stats,
+        };
+    }
+    classifyDiscussion(resolved, authorReply, codeChanged, replies, topic) {
+        if (!resolved)
+            return 'still_open';
+        // Check for duplicate markers in replies
+        const allText = replies.map(r => (r.body || '').toLowerCase()).join(' ');
+        if (allText.includes('duplicate') || topic.toLowerCase().includes('duplicate')) {
+            return 'duplicate';
+        }
+        // Check for won't fix signals
+        const wontFixSignals = ['won\'t fix', 'wontfix', 'not going to', 'out of scope', 'by design', 'intentional'];
+        const allTextWithTopic = allText + ' ' + topic.toLowerCase();
+        if (wontFixSignals.some(s => allTextWithTopic.includes(s))) {
+            return 'wont_fix';
+        }
+        // Code changed after comment was posted = addressed with code
+        if (codeChanged)
+            return 'code_changed';
+        // Author replied but code didn't change = explained
+        if (authorReply)
+            return 'author_explained';
+        // Resolved without reply and no code change = self-resolved
+        return 'reviewer_self_resolved';
+    }
+    computeRetroStats(discussions) {
+        const total = discussions.length;
+        const categories = [
+            'code_changed', 'author_explained', 'reviewer_self_resolved',
+            'wont_fix', 'duplicate', 'still_open', 'unknown',
+        ];
+        const byCategory = Object.fromEntries(categories.map(c => [c, discussions.filter(d => d.category === c).length]));
+        const codeChangeRate = total > 0
+            ? discussions.filter(d => d.codeChanged).length / total
+            : 0;
+        const responseRate = total > 0
+            ? discussions.filter(d => d.authorReply !== null).length / total
+            : 0;
+        return { total, byCategory, codeChangeRate, responseRate };
+    }
+}
+//# sourceMappingURL=review-tools.service.js.map