@ariso-ai/ivan 1.0.0

package/dist/services/address-task-executor.js

@@ -0,0 +1,736 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { execSync } from 'child_process';
+import { JobManager } from './job-manager.js';
+import { GitManager } from './git-manager.js';
+import { ExecutorFactory } from './executor-factory.js';
+import { OpenAIService } from './openai-service.js';
+import { ConfigManager } from '../config.js';
+import { PRService } from './pr-service.js';
+export class AddressTaskExecutor {
+    jobManager;
+    gitManager = null;
+    claudeExecutor = null;
+    openaiService = null;
+    configManager;
+    prService = null;
+    workingDir;
+    repoInstructions;
+    constructor() {
+        this.jobManager = new JobManager();
+        this.configManager = new ConfigManager();
+        this.workingDir = '';
+    }
+    getClaudeExecutor() {
+        if (!this.claudeExecutor) {
+            this.claudeExecutor = ExecutorFactory.getExecutor();
+        }
+        return this.claudeExecutor;
+    }
+    getOpenAIService() {
+        if (!this.openaiService) {
+            this.openaiService = new OpenAIService();
+        }
+        return this.openaiService;
+    }
+    async executeAddressTasks(tasks) {
+        try {
+            console.log(chalk.blue.bold('🚀 Starting address task workflow'));
+            console.log('');
+            // Validate dependencies
+            await this.getClaudeExecutor().validateClaudeCodeInstallation();
+            console.log(chalk.green('✅ Claude Code SDK configured'));
+            // Get working directory from first task's job
+            const db = this.jobManager['dbManager'].getKysely();
+            const job = await db
+                .selectFrom('jobs')
+                .selectAll()
+                .where('uuid', '=', tasks[0].job_uuid)
+                .executeTakeFirst();
+            if (!job) {
+                throw new Error('Job not found');
+            }
+            this.workingDir = job.directory;
+            this.gitManager = new GitManager(this.workingDir);
+            this.prService = new PRService(this.workingDir);
+            this.gitManager.validateGitHubCliInstallation();
+            console.log(chalk.green('✅ GitHub CLI is installed'));
+            this.gitManager.validateGitHubCliAuthentication();
+            console.log(chalk.green('✅ GitHub CLI is authenticated'));
+            // Load repository instructions
+            this.repoInstructions = await this.configManager.getRepoInstructions(this.workingDir);
+            // Group tasks by branch
+            const tasksByBranch = new Map();
+            for (const task of tasks) {
+                const branch = task.branch || 'unknown';
+                if (!tasksByBranch.has(branch)) {
+                    tasksByBranch.set(branch, []);
+                }
+                const tasks = tasksByBranch.get(branch);
+                if (tasks) {
+                    tasks.push(task);
+                }
+            }
+            // Execute tasks grouped by branch
+            for (const [branch, branchTasks] of tasksByBranch) {
+                if (branch === 'unknown') {
+                    console.log(chalk.yellow('⚠️  Skipping tasks without branch information'));
+                    continue;
+                }
+                console.log('');
+                console.log(chalk.cyan.bold(`🔄 Creating worktree for branch: ${branch}`));
+                let spinner = ora('Creating worktree...').start();
+                let worktreePath = null;
+                try {
+                    // Create worktree for the branch
+                    if (!this.gitManager) {
+                        throw new Error('GitManager not initialized');
+                    }
+                    worktreePath = await this.gitManager.createWorktree(branch);
+                    this.gitManager.switchToWorktree(worktreePath);
+                    spinner.succeed(`Worktree created: ${worktreePath}`);
+                }
+                catch (error) {
+                    spinner.fail(`Failed to create worktree for branch: ${branch}`);
+                    console.error(error);
+                    continue;
+                }
+                // Handle lint_and_test tasks separately
+                const lintAndTestTasks = branchTasks.filter(t => t.type === 'lint_and_test');
+                const addressTasks = branchTasks.filter(t => t.type === 'address');
+                // Process lint_and_test tasks first
+                for (const task of lintAndTestTasks) {
+                    console.log('');
+                    console.log(chalk.blue('🔧 Fixing test and lint failures'));
+                    await this.jobManager.updateTaskStatus(task.uuid, 'active');
+                    // Extract PR number from task description
+                    const prNumberMatch = task.description.match(/PR #(\d+)/);
+                    const taskPrNumber = prNumberMatch ? parseInt(prNumberMatch[1]) : null;
+                    spinner = ora('Fetching GitHub Actions logs...').start();
+                    let actionLogs = '';
+                    if (taskPrNumber && this.prService) {
+                        try {
+                            actionLogs = await this.prService.getFailingActionLogs(taskPrNumber);
+                            if (actionLogs) {
+                                spinner.succeed('GitHub Actions logs fetched');
+                            }
+                            else {
+                                spinner.info('No failing action logs found');
+                            }
+                        }
+                        catch (error) {
+                            spinner.warn('Could not fetch GitHub Actions logs');
+                            console.error(error);
+                        }
+                    }
+                    spinner = ora('Running Claude Code to fix test and lint failures...').start();
+                    // Prepare the prompt for Claude
+                    let prompt = 'Fix the failing tests and linting issues in this PR.\n\n';
+                    prompt += 'The following GitHub Actions checks are failing:\n';
+                    prompt += task.description.replace(/^Fix test and lint failures in PR #\d+: /, '') + '\n\n';
+                    // Include the actual failing logs if available
+                    if (actionLogs) {
+                        prompt += '=== GitHub Actions Failure Logs ===\n';
+                        prompt += actionLogs;
+                        prompt += '\n=== End of Logs ===\n\n';
+                    }
+                    prompt += 'Please run the tests and linting locally, identify what is failing based on the logs above, and fix all issues.';
+                    prompt += ' Make sure to run the tests again after fixing to verify they pass.';
+                    if (this.repoInstructions) {
+                        prompt += `\n\nRepository-specific instructions:\n${this.repoInstructions}`;
+                    }
+                    try {
+                        const result = await this.getClaudeExecutor().executeTask(prompt, worktreePath || this.workingDir);
+                        spinner.succeed('Claude Code execution completed');
+                        await this.jobManager.updateTaskExecutionLog(task.uuid, result.log);
+                        if (!this.gitManager) {
+                            throw new Error('GitManager not initialized');
+                        }
+                        const changedFiles = this.gitManager.getChangedFiles();
+                        if (changedFiles.length === 0) {
+                            console.log(chalk.yellow('⚠️  No changes made'));
+                            await this.jobManager.updateTaskStatus(task.uuid, 'completed');
+                            continue;
+                        }
+                        // Create commit with co-author
+                        spinner = ora('Creating commit...').start();
+                        const commitMessage = 'Fix test and lint failures\n\nCo-authored-by: ivan-agent <ivan-agent@users.noreply.github.com>';
+                        if (!this.gitManager) {
+                            throw new Error('GitManager not initialized');
+                        }
+                        // Try to commit, handling pre-commit hook failures
+                        const commitResult = await this.tryCommitWithFixes(commitMessage, task, worktreePath || this.workingDir, spinner);
+                        if (commitResult.succeeded) {
+                            spinner.succeed('Changes committed');
+                        }
+                        else {
+                            spinner.fail('Failed to commit after multiple attempts');
+                            throw new Error('Pre-commit hook failures could not be fixed');
+                        }
+                        // Get the commit hash
+                        const commitHash = execSync('git rev-parse HEAD', {
+                            cwd: worktreePath || this.workingDir,
+                            encoding: 'utf-8'
+                        }).trim();
+                        // Save commit hash to task
+                        await this.jobManager.updateTaskCommit(task.uuid, commitHash);
+                        // Push the commit immediately
+                        spinner = ora('Pushing commit...').start();
+                        try {
+                            if (!this.gitManager) {
+                                throw new Error('GitManager not initialized');
+                            }
+                            await this.gitManager.pushBranch(branch);
+                            spinner.succeed('Commit pushed successfully');
+                        }
+                        catch (error) {
+                            spinner.fail('Failed to push commit');
+                            console.error(error);
+                        }
+                        // Add review comment for lint_and_test task
+                        if (taskPrNumber) {
+                            spinner = ora('Adding review request comment...').start();
+                            try {
+                                const reviewComment = '@codex please review the test and lint fixes that were applied to address the failing CI checks';
+                                execSync(`gh pr comment ${taskPrNumber} --body "${reviewComment}"`, {
+                                    cwd: worktreePath || this.workingDir,
+                                    stdio: 'pipe'
+                                });
+                                spinner.succeed('Review request comment added');
+                            }
+                            catch (error) {
+                                spinner.fail('Failed to add review comment');
+                                console.error(error);
+                            }
+                        }
+                        await this.jobManager.updateTaskStatus(task.uuid, 'completed');
+                    }
+                    catch (error) {
+                        spinner.fail('Failed to fix test and lint failures');
+                        console.error(error);
+                        const errorLog = error instanceof Error ? error.message : String(error);
+                        await this.jobManager.updateTaskExecutionLog(task.uuid, `ERROR: ${errorLog}`);
+                        await this.jobManager.updateTaskStatus(task.uuid, 'not_started');
+                    }
+                }
+                // Get PR number from branch name or task description
+                const prMatch = branchTasks[0].description.match(/PR #(\d+)/);
+                if (!prMatch && addressTasks.length > 0) {
+                    console.log(chalk.yellow('⚠️  Could not extract PR number from task'));
+                    continue;
+                }
+                const prNumber = prMatch ? prMatch[1] : null;
+                // Skip comment processing if there are no address tasks
+                if (addressTasks.length === 0) {
+                    continue;
+                }
+                // Get all unaddressed comments for this PR
+                spinner = ora('Fetching PR comments...').start();
+                if (!prNumber) {
+                    throw new Error('PR number not found');
+                }
+                const comments = await this.getUnaddressedComments(parseInt(prNumber));
+                spinner.succeed(`Found ${comments.length} unaddressed comments`);
+                if (comments.length === 0 && addressTasks.some(t => t.description.includes('comment'))) {
+                    console.log(chalk.yellow('⚠️  No unaddressed comments found'));
+                    continue;
+                }
+                // Process each comment
+                for (const comment of comments) {
+                    console.log('');
+                    console.log(chalk.blue(`📝 Addressing comment from @${comment.author}:`));
+                    console.log(chalk.gray(`   "${comment.body.substring(0, 100)}${comment.body.length > 100 ? '...' : ''}"`));
+                    // Find the corresponding task
+                    const task = addressTasks.find(t => t.description.includes(comment.author) &&
+                        t.description.includes(comment.body.substring(0, 50)));
+                    if (!task) {
+                        console.log(chalk.yellow('⚠️  No task found for this comment'));
+                        continue;
+                    }
+                    await this.jobManager.updateTaskStatus(task.uuid, 'active');
+                    // Save comment URL
+                    if (comment.id) {
+                        const repoInfo = execSync('gh repo view --json owner,name', {
+                            cwd: worktreePath || this.workingDir,
+                            encoding: 'utf-8'
+                        });
+                        const { owner, name: repoName } = JSON.parse(repoInfo);
+                        if (!prNumber) {
+                            throw new Error('PR number not found');
+                        }
+                        const commentUrl = `https://github.com/${owner.login}/${repoName}/pull/${prNumber}#discussion_r${comment.id}`;
+                        await this.jobManager.updateTaskCommentUrl(task.uuid, commentUrl);
+                    }
+                    spinner = ora('Running Claude Code to address comment...').start();
+                    // Prepare the prompt for Claude
+                    let prompt = 'Address the following PR review comment:\n\n';
+                    prompt += `Comment from @${comment.author}:\n"${comment.body}"\n\n`;
+                    if (comment.path) {
+                        prompt += `File: ${comment.path}`;
+                        if (comment.line) {
+                            prompt += ` (line ${comment.line})`;
+                        }
+                        prompt += '\n\n';
+                    }
+                    prompt += 'Please make the necessary changes to address this comment.';
+                    if (this.repoInstructions) {
+                        prompt += `\n\nRepository-specific instructions:\n${this.repoInstructions}`;
+                    }
+                    try {
+                        const result = await this.getClaudeExecutor().executeTask(prompt, worktreePath || this.workingDir);
+                        spinner.succeed('Claude Code execution completed');
+                        await this.jobManager.updateTaskExecutionLog(task.uuid, result.log);
+                        // Use the last message from Claude's response
+                        const lastMessage = result.lastMessage;
+                        if (!this.gitManager) {
+                            throw new Error('GitManager not initialized');
+                        }
+                        const changedFiles = this.gitManager.getChangedFiles();
+                        if (changedFiles.length === 0) {
+                            console.log(chalk.yellow('⚠️  No changes made - Claude determined no changes were needed'));
+                            // Reply to the comment explaining why no changes were made
+                            spinner = ora('Replying to comment...').start();
+                            try {
+                                // Truncate the message if it's too long (GitHub has a 65536 character limit)
+                                const maxLength = 60000;
+                                let replyBody = `Ivan: ${lastMessage || 'After reviewing, no code changes were necessary to address this comment.'}`;
+                                if (replyBody.length > maxLength) {
+                                    replyBody = replyBody.substring(0, maxLength) + '\n\n... (message truncated)';
+                                }
+                                // Use a temporary file to avoid shell escaping issues
+                                const { writeFileSync, unlinkSync } = await import('fs');
+                                const { join } = await import('path');
+                                const { tmpdir } = await import('os');
+                                const tempFile = join(tmpdir(), `ivan-comment-${Date.now()}.txt`);
+                                writeFileSync(tempFile, replyBody);
+                                try {
+                                    // Use GraphQL mutation to add a reply to the review thread
+                                    const repoInfo = execSync('gh repo view --json owner,name', {
+                                        cwd: worktreePath || this.workingDir,
+                                        encoding: 'utf-8'
+                                    });
+                                    const { owner, name: repoName } = JSON.parse(repoInfo);
+                                    // Get the review thread ID from the comment
+                                    const threadQuery = `
+                    query {
+                      repository(owner: "${owner.login}", name: "${repoName}") {
+                        pullRequest(number: ${prNumber}) {
+                          reviewThreads(first: 100) {
+                            nodes {
+                              id
+                              comments(first: 100) {
+                                nodes {
+                                  databaseId
+                                }
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  `;
+                                    const threadResult = execSync(`gh api graphql -f query='${threadQuery.replace(/'/g, "'\\''")}'`, {
+                                        cwd: worktreePath || this.workingDir,
+                                        encoding: 'utf-8'
+                                    });
+                                    const threadData = JSON.parse(threadResult);
+                                    const threads = threadData.data?.repository?.pullRequest?.reviewThreads?.nodes || [];
+                                    // Find the thread containing this comment
+                                    let threadId = null;
+                                    for (const thread of threads) {
+                                        const comments = thread.comments?.nodes || [];
+                                        if (comments.some((c) => c.databaseId?.toString() === comment.id)) {
+                                            threadId = thread.id;
+                                            break;
+                                        }
+                                    }
+                                    if (!threadId) {
+                                        throw new Error('Could not find review thread for comment');
+                                    }
+                                    // Add reply using GraphQL mutation
+                                    const mutation = `
+                    mutation {
+                      addPullRequestReviewThreadReply(input: {
+                        pullRequestReviewThreadId: "${threadId}"
+                        body: ${JSON.stringify(replyBody)}
+                      }) {
+                        comment {
+                          id
+                        }
+                      }
+                    }
+                  `;
+                                    execSync(`gh api graphql -f query='${mutation.replace(/'/g, "'\\''")}'`, {
+                                        cwd: worktreePath || this.workingDir,
+                                        stdio: 'pipe'
+                                    });
+                                    spinner.succeed('Reply added to comment');
+                                }
+                                finally {
+                                    unlinkSync(tempFile);
+                                }
+                            }
+                            catch (error) {
+                                spinner.fail('Failed to reply to comment');
+                                console.error(error);
+                            }
+                            await this.jobManager.updateTaskStatus(task.uuid, 'completed');
+                            continue;
+                        }
+                        // Create commit with co-author
+                        spinner = ora('Creating commit...').start();
+                        const commitMessage = `Address review comment from @${comment.author}
+
+${comment.body.substring(0, 200)}${comment.body.length > 200 ? '...' : ''}
+
+Co-authored-by: ivan-agent <ivan-agent@users.noreply.github.com}`;
+                        if (!this.gitManager) {
+                            throw new Error('GitManager not initialized');
+                        }
+                        // Try to commit, handling pre-commit hook failures
+                        const commitResult = await this.tryCommitWithFixes(commitMessage, task, worktreePath || this.workingDir, spinner);
+                        if (commitResult.succeeded) {
+                            spinner.succeed('Changes committed');
+                        }
+                        else {
+                            spinner.fail('Failed to commit after multiple attempts');
+                            throw new Error('Pre-commit hook failures could not be fixed');
+                        }
+                        // Get the commit hash
+                        const commitHash = execSync('git rev-parse HEAD', {
+                            cwd: worktreePath || this.workingDir,
+                            encoding: 'utf-8'
+                        }).trim();
+                        // Save commit hash to task
+                        await this.jobManager.updateTaskCommit(task.uuid, commitHash);
+                        // Push the commit immediately
+                        spinner = ora('Pushing commit...').start();
+                        try {
+                            if (!this.gitManager) {
+                                throw new Error('GitManager not initialized');
+                            }
+                            await this.gitManager.pushBranch(branch);
+                            spinner.succeed('Commit pushed successfully');
+                        }
+                        catch (error) {
+                            spinner.fail('Failed to push commit');
+                            console.error(error);
+                        }
+                        // Reply to the comment with the fix
+                        spinner = ora('Replying to comment...').start();
+                        try {
+                            // Truncate the message if it's too long (GitHub has a 65536 character limit)
+                            const maxLength = 60000;
+                            let replyBody = lastMessage
+                                ? `Ivan: ${lastMessage}\n\nThis has been addressed in commit ${commitHash.substring(0, 7)}`
+                                : `Ivan: This has been addressed in commit ${commitHash.substring(0, 7)}`;
+                            if (replyBody.length > maxLength) {
+                                replyBody = replyBody.substring(0, maxLength) + '\n\n... (message truncated)\n\n' +
+                                    `This has been addressed in commit ${commitHash.substring(0, 7)}`;
+                            }
+                            // Use GraphQL mutation to add a reply to the review thread
+                            const repoInfo = execSync('gh repo view --json owner,name', {
+                                cwd: worktreePath || this.workingDir,
+                                encoding: 'utf-8'
+                            });
+                            const { owner, name: repoName } = JSON.parse(repoInfo);
+                            // Get the review thread ID from the comment
+                            const threadQuery = `
+                query {
+                  repository(owner: "${owner.login}", name: "${repoName}") {
+                    pullRequest(number: ${prNumber}) {
+                      reviewThreads(first: 100) {
+                        nodes {
+                          id
+                          comments(first: 100) {
+                            nodes {
+                              databaseId
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              `;
+                            const threadResult = execSync(`gh api graphql -f query='${threadQuery.replace(/'/g, "'\\''")}'`, {
+                                cwd: worktreePath || this.workingDir,
+                                encoding: 'utf-8'
+                            });
+                            const threadData = JSON.parse(threadResult);
+                            const threads = threadData.data?.repository?.pullRequest?.reviewThreads?.nodes || [];
+                            // Find the thread containing this comment
+                            let threadId = null;
+                            for (const thread of threads) {
+                                const comments = thread.comments?.nodes || [];
+                                if (comments.some((c) => c.databaseId?.toString() === comment.id)) {
+                                    threadId = thread.id;
+                                    break;
+                                }
+                            }
+                            if (!threadId) {
+                                throw new Error('Could not find review thread for comment');
+                            }
+                            // Add reply using GraphQL mutation
+                            const mutation = `
+                mutation {
+                  addPullRequestReviewThreadReply(input: {
+                    pullRequestReviewThreadId: "${threadId}"
+                    body: ${JSON.stringify(replyBody)}
+                  }) {
+                    comment {
+                      id
+                    }
+                  }
+                }
+              `;
+                            execSync(`gh api graphql -f query='${mutation.replace(/'/g, "'\\''")}'`, {
+                                cwd: worktreePath || this.workingDir,
+                                stdio: 'pipe'
+                            });
+                            spinner.succeed('Reply added to comment');
+                        }
+                        catch (error) {
+                            spinner.fail('Failed to reply to comment');
+                            console.error(error);
+                        }
+                        await this.jobManager.updateTaskStatus(task.uuid, 'completed');
+                    }
+                    catch (error) {
+                        spinner.fail('Failed to address comment');
+                        console.error(error);
+                        const errorLog = error instanceof Error ? error.message : String(error);
+                        await this.jobManager.updateTaskExecutionLog(task.uuid, `ERROR: ${errorLog}`);
+                        await this.jobManager.updateTaskStatus(task.uuid, 'not_started');
+                    }
+                }
+                // Generate and add specific review comment (only if we have a PR number and made changes)
+                if (prNumber && (addressTasks.length > 0 || lintAndTestTasks.length > 0)) {
+                    spinner = ora('Generating review request...').start();
+                    try {
+                        // Get the latest commit changes
+                        const latestCommit = execSync('git rev-parse HEAD', {
+                            cwd: worktreePath || this.workingDir,
+                            encoding: 'utf-8'
+                        }).trim();
+                        const commitDiff = execSync(`git show ${latestCommit} --format="" --unified=3`, {
+                            cwd: worktreePath || this.workingDir,
+                            encoding: 'utf-8'
+                        });
+                        const changedFiles = execSync(`git show --name-only --format="" ${latestCommit}`, {
+                            cwd: worktreePath || this.workingDir,
+                            encoding: 'utf-8'
+                        }).trim().split('\n').filter(Boolean);
+                        // Generate specific review instructions using OpenAI
+                        const reviewInstructions = await this.generateReviewInstructions(commitDiff, changedFiles, parseInt(prNumber));
+                        spinner.succeed('Review request generated');
+                        // Add the review comment
+                        spinner = ora('Adding review request comment...').start();
+                        const reviewComment = `@codex ${reviewInstructions}`;
+                        execSync(`gh pr comment ${prNumber} --body "${reviewComment.replace(/"/g, '\\"')}"`, {
+                            cwd: worktreePath || this.workingDir,
+                            stdio: 'pipe'
+                        });
+                        spinner.succeed('Review request comment added');
+                    }
+                    catch (error) {
+                        spinner.fail('Failed to add review comment');
+                        console.error(error);
+                    }
+                }
+                // Clean up worktree after processing branch
+                if (this.gitManager && worktreePath) {
+                    try {
+                        this.gitManager.switchToOriginalDir();
+                        await this.gitManager.removeWorktree(branch);
+                    }
+                    catch (error) {
+                        console.log(chalk.yellow(`⚠️ Could not clean up worktree: ${error}`));
+                    }
+                }
+            }
+            console.log('');
+            console.log(chalk.green.bold('🎉 All address tasks completed!'));
+        }
+        catch (error) {
+            console.error(chalk.red.bold('❌ Address workflow failed:'), error);
+            throw error;
+        }
+    }
+    async getUnaddressedComments(prNumber) {
+        try {
+            // Get PR owner and repo name
+            const repoInfo = execSync('gh repo view --json owner,name', {
+                cwd: this.gitManager?.['originalWorkingDir'] || this.workingDir,
+                encoding: 'utf-8'
+            });
+            const { owner, name: repoName } = JSON.parse(repoInfo);
+            // Use GraphQL to get review threads with resolved status
+            const graphqlQuery = `
+        query {
+          repository(owner: "${owner.login}", name: "${repoName}") {
+            pullRequest(number: ${prNumber}) {
+              reviewThreads(first: 100) {
+                nodes {
+                  isResolved
+                  comments(first: 100) {
+                    nodes {
+                      id
+                      databaseId
+                      body
+                      author {
+                        login
+                      }
+                      createdAt
+                      path
+                      line
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      `;
+            const graphqlResult = execSync(`gh api graphql -f query='${graphqlQuery}'`, {
+                cwd: this.gitManager?.['originalWorkingDir'] || this.workingDir,
+                encoding: 'utf-8'
+            });
+            const result = JSON.parse(graphqlResult);
+            const threads = result.data?.repository?.pullRequest?.reviewThreads?.nodes || [];
+            const unaddressedComments = [];
+            // Process each thread
+            for (const thread of threads) {
+                // Skip resolved threads
+                if (thread.isResolved) {
+                    continue;
+                }
+                const comments = thread.comments?.nodes || [];
+                if (comments.length === 0) {
+                    continue;
+                }
+                // Get the first comment (the main review comment)
+                const firstComment = comments[0];
+                // Check if there are replies (more than one comment in thread)
+                const hasReplies = comments.length > 1;
+                if (!hasReplies && firstComment.path) {
+                    // Only include if it's an inline code comment (has a path) and has no replies
+                    unaddressedComments.push({
+                        id: firstComment.databaseId ? firstComment.databaseId.toString() : firstComment.id,
+                        author: firstComment.author.login,
+                        body: firstComment.body,
+                        createdAt: firstComment.createdAt,
+                        path: firstComment.path,
+                        line: firstComment.line
+                    });
+                }
+            }
+            return unaddressedComments;
+        }
+        catch (error) {
+            console.error('Error fetching comments:', error);
+            return [];
+        }
+    }
+    async generateReviewInstructions(diff, changedFiles, _prNumber) {
+        try {
+            const openaiService = this.getOpenAIService();
+            const client = await openaiService.getClient();
+            const prompt = `You are reviewing code changes that were made to address PR review comments. 
+Based on the following diff and changed files, generate a concise, specific review request that tells the reviewer what to focus on.
+
+Changed files:
+${changedFiles.join('\n')}
+
+Diff (last commit):
+${diff.substring(0, 8000)}${diff.length > 8000 ? '\n... (diff truncated)' : ''}
+
+Generate a brief (1-2 sentences) review request that:
+1. Mentions the key changes made
+2. Asks the reviewer to verify specific aspects that were addressed
+3. Is conversational and clear
+
+Example format: "please review the updates to the reflection service integration and verify that the null checks properly handle missing configuration objects"
+
+Return ONLY the review request text, without any prefix like "Please review" since @codex will already be prepended.`;
+            const completion = await client.chat.completions.create({
+                model: 'gpt-4o-mini',
+                messages: [
+                    {
+                        role: 'system',
+                        content: 'You are a helpful assistant that generates specific code review requests based on git diffs.'
+                    },
+                    {
+                        role: 'user',
+                        content: prompt
+                    }
+                ],
+                temperature: 0.3,
+                max_tokens: 150
+            });
+            const reviewRequest = completion.choices[0]?.message?.content?.trim();
+            if (!reviewRequest) {
+                return 'please review the latest changes and verify all review comments have been properly addressed';
+            }
+            return reviewRequest;
+        }
+        catch (error) {
+            console.error('Error generating review instructions:', error);
+            // Fallback to a generic message if OpenAI fails
+            return 'please review the latest changes and verify all review comments have been properly addressed';
+        }
+    }
+    async tryCommitWithFixes(commitMessage, task, workingDir, spinner) {
+        let commitAttempts = 0;
+        const maxCommitAttempts = 3;
+        let commitSucceeded = false;
+        while (commitAttempts < maxCommitAttempts && !commitSucceeded) {
+            try {
+                if (!this.gitManager) {
+                    throw new Error('GitManager not initialized');
+                }
+                await this.gitManager.commitChanges(commitMessage);
+                commitSucceeded = true;
+                // Stop the spinner if we're retrying
+                if (commitAttempts > 0 && spinner.isSpinning) {
+                    spinner.succeed('Commit successful after retry');
+                }
+            }
+            catch (commitError) {
+                commitAttempts++;
+                const errorMessage = commitError instanceof Error ? commitError.message : String(commitError);
+                // Check if this is a pre-commit hook failure
+                if (errorMessage.includes('pre-commit') && commitAttempts < maxCommitAttempts) {
+                    spinner.fail(`Pre-commit hook failed (attempt ${commitAttempts}/${maxCommitAttempts})`);
+                    console.log(chalk.yellow('🔧 Running Claude to fix pre-commit errors...'));
+                    // Extract the error details from the commit error
+                    const errorDetails = errorMessage;
+                    // Prepare prompt for Claude to fix the errors
+                    const fixPrompt = `Fix the following pre-commit hook errors:\n\n${errorDetails}\n\nPlease fix all TypeScript errors, linting issues, and any other problems preventing the commit.`;
+                    spinner = ora('Running Claude to fix pre-commit errors...').start();
+                    try {
+                        // Run Claude to fix the errors
+                        const fixResult = await this.getClaudeExecutor().executeTask(fixPrompt, workingDir);
+                        spinner.succeed('Claude attempted to fix the errors');
+                        // Update the execution log with the fix attempt
+                        const previousLog = await this.jobManager.getTaskExecutionLog(task.uuid);
+                        await this.jobManager.updateTaskExecutionLog(task.uuid, `${previousLog}\n\n--- Pre-commit Fix Attempt ${commitAttempts} ---\n${fixResult.log}`);
+                        // Try to commit again on the next iteration
+                        spinner = ora('Retrying commit...').start();
+                    }
+                    catch (fixError) {
+                        spinner.fail('Failed to run Claude to fix errors');
+                        console.error(chalk.red('Claude fix attempt failed:'), fixError);
+                        throw commitError; // Re-throw the original error
+                    }
+                }
+                else {
+                    // Not a pre-commit error or max attempts reached
+                    throw commitError;
+                }
+            }
+        }
+        return { succeeded: commitSucceeded };
+    }
+}
+//# sourceMappingURL=address-task-executor.js.map