edsger 0.77.0 → 0.78.0

package/dist/phases/code-refine/refine-iteration.js

@@ -1,166 +0,0 @@
-/**
- * Code Refine Iteration
- * Executes a single refine iteration using Claude Code SDK
- */
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import { DEFAULT_MODEL } from '../../constants.js';
-import { formatFeedbacksForContext, getFeedbacksForPhase, } from '../../services/feedbacks.js';
-import { extractJsonFromResponse } from '../../utils/json-extractor.js';
-import { logDebug, logError, logInfo } from '../../utils/logger.js';
-import { fetchCodeRefineContext } from './context.js';
-import { createCodeRefinePrompt, createSystemPrompt } from './prompts.js';
-function userMessage(content) {
-    return {
-        type: 'user',
-        message: { role: 'user', content },
-    };
-}
-async function* prompt(refinePrompt) {
-    yield userMessage(refinePrompt);
-    await new Promise((res) => {
-        setTimeout(res, 10000);
-    });
-}
-// eslint-disable-next-line complexity -- agent loop with message processing and result extraction
-export async function executeRefineIteration(opts) {
-    const { issueId, githubToken, config: _config, pullRequestUrl, currentBranch, verificationFailureContext, checklistContext, verbose, } = opts;
-    // Fetch code refine context (PR reviews and comments)
-    const context = await fetchCodeRefineContext(issueId, githubToken, verbose, pullRequestUrl);
-    // Fetch additional feedbacks for code-refine phase
-    let feedbacksInfo;
-    try {
-        const feedbacksContext = await getFeedbacksForPhase({ issueId, verbose }, 'code_refine', currentBranch?.id);
-        if (feedbacksContext.feedbacks.length > 0) {
-            feedbacksInfo = await formatFeedbacksForContext(feedbacksContext);
-            if (verbose) {
-                logInfo(`Added ${feedbacksContext.feedbacks.length} human feedbacks to code refine context${currentBranch ? ` (including branch-specific for "${currentBranch.name}")` : ''}`);
-            }
-        }
-    }
-    catch (error) {
-        if (verbose) {
-            logInfo(`Note: Could not fetch feedbacks (${error instanceof Error ? error.message : String(error)})`);
-        }
-    }
-    // Create prompt for code refine
-    const systemPrompt = await createSystemPrompt(checklistContext);
-    const refinePrompt = createCodeRefinePrompt(issueId, context, feedbacksInfo, verificationFailureContext, checklistContext);
-    let lastAssistantResponse = '';
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    let structuredRefineResult = null;
-    let executionSessionId = '';
-    if (verbose) {
-        logInfo('Starting Claude Code query for code refine...');
-    }
-    // Use Claude Code SDK to refine the code
-    for await (const message of query({
-        prompt: prompt(refinePrompt),
-        options: {
-            systemPrompt: {
-                type: 'preset',
-                preset: 'claude_code',
-                append: systemPrompt,
-            },
-            model: DEFAULT_MODEL,
-            maxTurns: 2000,
-            permissionMode: 'bypassPermissions',
-        },
-    })) {
-        if (verbose) {
-            logInfo(`Received message type: ${message.type}`);
-        }
-        // Stream the code refine process
-        if (message.type === 'assistant') {
-            for (const content of message.message?.content ?? []) {
-                if (content.type === 'text') {
-                    lastAssistantResponse += `${content.text}\n`;
-                    logDebug(`🔧 ${content.text}`, verbose);
-                }
-                else if (content.type === 'tool_use') {
-                    const input = (content.input ?? {});
-                    logDebug(`🛠️ ${content.name}: ${input.description ?? 'Running...'}`, verbose);
-                }
-            }
-            continue;
-        }
-        if (message.type === 'result') {
-            executionSessionId = message.session_id || executionSessionId;
-            if (message.subtype === 'success') {
-                logInfo('\n🛠️ Code refine completed, parsing results...');
-                try {
-                    const responseText = message.result || lastAssistantResponse;
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    let jsonResult = null;
-                    const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
-                    if (jsonBlockMatch) {
-                        jsonResult = JSON.parse(jsonBlockMatch[1]);
-                    }
-                    else {
-                        jsonResult = JSON.parse(responseText);
-                    }
-                    if (jsonResult && jsonResult.refine_result) {
-                        structuredRefineResult = jsonResult.refine_result;
-                    }
-                    else {
-                        throw new Error('Invalid JSON structure');
-                    }
-                }
-                catch (error) {
-                    logError(`Failed to parse structured refine result: ${error}`);
-                    structuredRefineResult = parseCodeRefineResponse(message.result || lastAssistantResponse);
-                }
-            }
-            else {
-                logError(`\n⚠️  Code refine incomplete: ${message.subtype}`);
-                if (message.subtype === 'error_max_turns') {
-                    logError('💡 Try simplifying the changes or reducing scope');
-                }
-                if (lastAssistantResponse) {
-                    const fallbackJson = extractJsonFromResponse(lastAssistantResponse, '"refine_result"');
-                    if (fallbackJson?.refine_result) {
-                        structuredRefineResult =
-                            fallbackJson.refine_result;
-                    }
-                    else {
-                        structuredRefineResult = parseCodeRefineResponse(lastAssistantResponse);
-                    }
-                }
-            }
-        }
-    }
-    if (structuredRefineResult) {
-        return {
-            status: 'success',
-            summary: structuredRefineResult.summary,
-            files_modified: structuredRefineResult.files_modified,
-            commits_created: structuredRefineResult.commits_created,
-            checklist_item_results: structuredRefineResult.checklist_item_results,
-            execution_session_id: executionSessionId || undefined,
-        };
-    }
-    return {
-        status: 'error',
-        message: 'Code refine failed or incomplete',
-    };
-}
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function parseCodeRefineResponse(response) {
-    const summaryMatch = response.match(/## Refine Summary\n([\s\S]*?)(?=\n##|\n\n|$)/);
-    const summary = summaryMatch
-        ? summaryMatch[1].trim()
-        : 'Code refined based on PR feedback';
-    const filesMatch = response.match(/## Files Modified\n([\s\S]*?)(?=\n##|\n\n|$)/);
-    let filesModified = [];
-    if (filesMatch) {
-        filesModified = filesMatch[1]
-            .split('\n')
-            .filter((line) => line.trim().startsWith('-'))
-            .map((line) => line.replace(/^-\s*/, '').trim());
-    }
-    return {
-        summary,
-        files_modified: filesModified,
-        commits_created: 1,
-        feedback_addressed: [],
-    };
-}

package/dist/phases/code-refine/retry-handler.d.ts

@@ -1,17 +0,0 @@
-/**
- * Code refine retry handler for pipeline execution
- * Handles verification failures and retries code refine with suggestions
- */
-import { type EdsgerConfig } from '../../types/index.js';
-import { type PipelinePhaseOptions, type PipelineResult } from '../../types/pipeline.js';
-export declare const MAX_REFINE_ATTEMPTS = 10;
-export interface CodeRefineRetryOptions {
-    options: PipelinePhaseOptions;
-    config: EdsgerConfig;
-    results: PipelineResult[];
-    verbose?: boolean;
-}
-/**
- * Handle code refine verification failures with automatic retry
- */
-export declare function handleCodeRefineWithRetry({ options, config, results, verbose, }: CodeRefineRetryOptions): Promise<PipelineResult>;

package/dist/phases/code-refine/retry-handler.js

@@ -1,87 +0,0 @@
-/**
- * Code refine retry handler for pipeline execution
- * Handles verification failures and retries code refine with suggestions
- */
-import { updateIssueStatusForPhase } from '../../api/issues/index.js';
-import { runCodeRefinePhase, runCodeRefineVerificationPhase, } from '../../commands/workflow/executors/phase-executor.js';
-import { logDebug, logInfo, logRaw } from '../../utils/logger.js';
-import { logPhaseResult } from '../../utils/pipeline-logger.js';
-export const MAX_REFINE_ATTEMPTS = 10;
-/**
- * Handle code refine verification failures with automatic retry
- */
-// eslint-disable-next-line complexity -- retry loop with multiple outcome branches
-export async function handleCodeRefineWithRetry({ options, config, results, verbose, }) {
-    let verificationResult;
-    let refineAttempt = 0;
-    let verificationFailureContext;
-    do {
-        // 1. Run code refine phase (with verification context if this is a retry)
-        const enhancedOptions = verificationFailureContext
-            ? { ...options, verificationFailureContext }
-            : options;
-        const codeRefineResult = await runCodeRefinePhase(enhancedOptions, config);
-        results.push(logPhaseResult(codeRefineResult, verbose));
-        // If code refine failed, stop immediately
-        if (codeRefineResult.status === 'error') {
-            logDebug(`Code refine failed: ${codeRefineResult.message}. Cannot proceed to verification.`, verbose);
-            return codeRefineResult;
-        }
-        // 2. Run code refine verification
-        verificationResult = await runCodeRefineVerificationPhase(options, config);
-        results.push(logPhaseResult(verificationResult, verbose));
-        // If verification passed, we're done
-        if (verificationResult.status === 'success') {
-            logDebug('Code refine verification passed. All PR comments have been addressed.', verbose);
-            break;
-        }
-        // Verification failed - check if we should retry
-        if (refineAttempt < MAX_REFINE_ATTEMPTS) {
-            refineAttempt++;
-            logDebug(`Code refine verification failed. Retrying... (Attempt ${refineAttempt}/${MAX_REFINE_ATTEMPTS})`, verbose);
-            // Extract verification failure details
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const verificationData = verificationResult.data;
-            const _unresolvedComments = verificationData?.unresolvedComments ||
-                verificationData?.unresolved_comments ||
-                0;
-            const suggestions = verificationData?.suggestions || [];
-            const unresolvedCommentDetails = verificationData?.unresolvedCommentDetails ||
-                verificationData?.unresolved_comment_details ||
-                [];
-            const unresolvedReviewDetails = verificationData?.unresolvedReviewDetails ||
-                verificationData?.unresolved_review_details;
-            // Prepare verification failure context for next code-refine attempt
-            verificationFailureContext = {
-                attempt: refineAttempt + 1, // Next attempt number
-                suggestions,
-                unresolvedCommentDetails,
-                unresolvedReviewDetails,
-            };
-            // Note: phase-executor already logged phase_failed event, so we don't log it again here
-            // to avoid duplicate audit logs
-            if (verbose && suggestions.length > 0) {
-                logRaw('');
-                logInfo('Suggestions for next iteration:');
-                suggestions.forEach((suggestion) => {
-                    logRaw(`   ${suggestion}`);
-                });
-                logRaw('');
-            }
-            // Remove the failed verification result - we'll add the new one after retry
-            results.pop();
-            // Update status to indicate we're retrying code refine
-            await updateIssueStatusForPhase(options.issueId, 'code-refine', verbose);
-            // Also remove the code refine result so it can be retried
-            results.pop();
-        }
-        else {
-            // Max attempts reached
-            logDebug(`Maximum refine attempts (${MAX_REFINE_ATTEMPTS}) reached. Verification still failing.`, verbose);
-            // Note: phase-executor already logged phase_failed event with all details
-            // No need to log again here to avoid duplicates
-            break;
-        }
-    } while (refineAttempt <= MAX_REFINE_ATTEMPTS);
-    return verificationResult;
-}

package/dist/phases/code-refine-verification/github.d.ts

@@ -1,54 +0,0 @@
-/**
- * GitHub API operations for Code Refine Verification
- * Handles file fetching, review threads, and resolution
- */
-import { type Octokit } from '@octokit/rest';
-import { type PRReview } from '../code-refine/context.js';
-import { type PRFileChange, type ReviewThread } from './types.js';
-/**
- * Fetch complete file content from a specific ref (branch/commit)
- */
-export interface FetchFileContentOptions {
-    octokit: Octokit;
-    owner: string;
-    repo: string;
-    ref: string;
-    path: string;
-    verbose?: boolean;
-}
-export declare function fetchFileContent(opts: FetchFileContentOptions): Promise<string | undefined>;
-/**
- * Fetch PR file changes (diff information and full content)
- */
-export declare function fetchPRFileChanges(octokit: Octokit, owner: string, repo: string, prNumber: number, verbose?: boolean): Promise<PRFileChange[]>;
-export interface GraphQLClient {
-    graphql: <ResponseData>(query: string, variables?: Record<string, unknown>) => Promise<ResponseData>;
-}
-/**
- * Page through every `reviewThreads` connection, following `pageInfo.endCursor`
- * until GitHub reports `hasNextPage: false`. Exported for tests.
- */
-export declare function fetchAllReviewThreads(octokit: GraphQLClient, owner: string, repo: string, prNumber: number, verbose?: boolean): Promise<ReviewThread[]>;
-/**
- * Fetch unresolved review threads using GitHub GraphQL API
- * This provides accurate resolution status unlike REST API
- */
-export declare function fetchUnresolvedReviewThreads(octokit: Octokit, owner: string, repo: string, prNumber: number, verbose?: boolean): Promise<ReviewThread[]>;
-/**
- * For any thread whose `comments` connection was truncated (>100 comments),
- * page through the remaining comments and append them to the thread in place.
- * Each thread is hydrated concurrently; the per-thread loop is still
- * sequential because each page depends on the previous cursor. Exported for
- * tests.
- */
-export declare function hydrateThreadComments(octokit: GraphQLClient, threads: ReviewThread[], verbose?: boolean): Promise<void>;
-/**
- * Mark review threads as resolved using GraphQL API
- */
-export declare function resolveReviewThreads(octokit: Octokit, threads: ReviewThread[], verbose?: boolean): Promise<number>;
-/**
- * Dismiss pull request reviews using GraphQL API
- * This is used to automatically dismiss "CHANGES_REQUESTED" reviews
- * after all feedback has been addressed by code refine
- */
-export declare function dismissReviews(octokit: Octokit, reviews: PRReview[], resolvedCommentsCount: number, verbose?: boolean): Promise<number>;

package/dist/phases/code-refine-verification/github.js

@@ -1,328 +0,0 @@
-/**
- * GitHub API operations for Code Refine Verification
- * Handles file fetching, review threads, and resolution
- */
-import { logError, logInfo } from '../../utils/logger.js';
-export async function fetchFileContent(opts) {
-    const { octokit, owner, repo, ref, path, verbose } = opts;
-    try {
-        const { data } = await octokit.repos.getContent({
-            owner,
-            repo,
-            ref,
-            path,
-        });
-        // Handle file content (not directory)
-        if ('content' in data && !Array.isArray(data)) {
-            // Content is base64 encoded
-            return Buffer.from(data.content, 'base64').toString('utf-8');
-        }
-        return undefined;
-    }
-    catch (error) {
-        if (verbose) {
-            logError(`Failed to fetch content for ${path} at ref ${ref}: ${error}`);
-        }
-        return undefined;
-    }
-}
-/**
- * Fetch PR file changes (diff information and full content)
- */
-export async function fetchPRFileChanges(octokit, owner, repo, prNumber, verbose) {
-    try {
-        if (verbose) {
-            logInfo('📂 Fetching PR file changes and content...');
-        }
-        // Get PR details to get the head ref
-        const { data: pr } = await octokit.pulls.get({
-            owner,
-            repo,
-            pull_number: prNumber,
-        });
-        const headRef = pr.head.sha;
-        // Get list of changed files
-        const { data: files } = await octokit.pulls.listFiles({
-            owner,
-            repo,
-            pull_number: prNumber,
-            per_page: 100,
-        });
-        if (verbose) {
-            logInfo(`✅ Found ${files.length} changed files`);
-            logInfo(`📥 Fetching full content for changed files from ${headRef.substring(0, 7)}...`);
-        }
-        // Fetch full content for each file in parallel
-        const fileChanges = await Promise.all(files.map(async (file) => {
-            let fullContent;
-            // Only fetch content for files that were not deleted
-            if (file.status !== 'removed') {
-                fullContent = await fetchFileContent({
-                    octokit,
-                    owner,
-                    repo,
-                    ref: headRef,
-                    path: file.filename,
-                    verbose,
-                });
-            }
-            return {
-                filename: file.filename,
-                status: file.status,
-                additions: file.additions,
-                deletions: file.deletions,
-                changes: file.changes,
-                patch: file.patch,
-                fullContent,
-            };
-        }));
-        if (verbose) {
-            const filesWithContent = fileChanges.filter((f) => f.fullContent).length;
-            logInfo(`✅ Retrieved full content for ${filesWithContent}/${fileChanges.length} files`);
-        }
-        return fileChanges;
-    }
-    catch (error) {
-        logError(`Failed to fetch PR file changes: ${error}`);
-        return [];
-    }
-}
-const REVIEW_THREADS_QUERY = `
-  query($owner: String!, $repo: String!, $prNumber: Int!, $threadCursor: String) {
-    repository(owner: $owner, name: $repo) {
-      pullRequest(number: $prNumber) {
-        reviewThreads(first: 100, after: $threadCursor) {
-          pageInfo {
-            hasNextPage
-            endCursor
-          }
-          nodes {
-            id
-            isResolved
-            isOutdated
-            comments(first: 100) {
-              totalCount
-              pageInfo {
-                hasNextPage
-                endCursor
-              }
-              nodes {
-                id
-                author {
-                  login
-                }
-                body
-                path
-                line
-                url
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-`;
-const THREAD_COMMENTS_QUERY = `
-  query($threadId: ID!, $cursor: String) {
-    node(id: $threadId) {
-      ... on PullRequestReviewThread {
-        comments(first: 100, after: $cursor) {
-          pageInfo {
-            hasNextPage
-            endCursor
-          }
-          nodes {
-            id
-            author {
-              login
-            }
-            body
-            path
-            line
-            url
-          }
-        }
-      }
-    }
-  }
-`;
-/**
- * Page through every `reviewThreads` connection, following `pageInfo.endCursor`
- * until GitHub reports `hasNextPage: false`. Exported for tests.
- */
-export async function fetchAllReviewThreads(octokit, owner, repo, prNumber, verbose) {
-    const allThreads = [];
-    let threadCursor = null;
-    let threadPage = 0;
-    while (true) {
-        threadPage += 1;
-        const result = await octokit.graphql(REVIEW_THREADS_QUERY, {
-            owner,
-            repo,
-            prNumber,
-            threadCursor,
-        });
-        const page = result.repository?.pullRequest?.reviewThreads;
-        const pageThreads = page?.nodes ?? [];
-        allThreads.push(...pageThreads);
-        if (verbose) {
-            logInfo(`   · page ${threadPage}: fetched ${pageThreads.length} thread(s) (total so far: ${allThreads.length})`);
-        }
-        const pageInfo = page?.pageInfo;
-        if (!pageInfo?.hasNextPage || !pageInfo.endCursor) {
-            break;
-        }
-        threadCursor = pageInfo.endCursor;
-    }
-    return allThreads;
-}
-/**
- * Fetch unresolved review threads using GitHub GraphQL API
- * This provides accurate resolution status unlike REST API
- */
-export async function fetchUnresolvedReviewThreads(octokit, owner, repo, prNumber, verbose) {
-    try {
-        if (verbose) {
-            logInfo('🔍 Fetching review threads via GraphQL API...');
-        }
-        const allThreads = await fetchAllReviewThreads(octokit, owner, repo, prNumber, verbose);
-        // Fill in any threads whose comments were truncated at 100
-        await hydrateThreadComments(octokit, allThreads, verbose);
-        // Filter for truly unresolved threads
-        // - Exclude resolved threads (isResolved = true)
-        // - Exclude outdated threads (isOutdated = true) - these mean code has changed, should auto-resolve
-        const unresolvedThreads = allThreads.filter((thread) => !thread.isResolved && !thread.isOutdated);
-        // Separate outdated threads that should be auto-resolved
-        const outdatedThreads = allThreads.filter((thread) => !thread.isResolved && thread.isOutdated);
-        if (verbose) {
-            logInfo(`📊 Found ${unresolvedThreads.length} unresolved review threads (out of ${allThreads.length} total)`);
-            if (outdatedThreads.length > 0) {
-                logInfo(`📊 Found ${outdatedThreads.length} outdated threads (code changed, will auto-resolve)`);
-            }
-        }
-        // Auto-resolve outdated threads
-        if (outdatedThreads.length > 0) {
-            const markedCount = await resolveReviewThreads(octokit, outdatedThreads, verbose);
-            if (verbose) {
-                logInfo(`✅ Auto-resolved ${markedCount} outdated threads`);
-            }
-        }
-        return unresolvedThreads;
-    }
-    catch (error) {
-        logError(`Failed to fetch review threads via GraphQL: ${error}`);
-        // Fallback to empty array if GraphQL fails
-        return [];
-    }
-}
-/**
- * For any thread whose `comments` connection was truncated (>100 comments),
- * page through the remaining comments and append them to the thread in place.
- * Each thread is hydrated concurrently; the per-thread loop is still
- * sequential because each page depends on the previous cursor. Exported for
- * tests.
- */
-export async function hydrateThreadComments(octokit, threads, verbose) {
-    await Promise.all(threads.map((thread) => hydrateOneThreadComments(octokit, thread, verbose)));
-}
-async function hydrateOneThreadComments(octokit, thread, verbose) {
-    let { pageInfo } = thread.comments;
-    let cursor = pageInfo?.endCursor ?? null;
-    while (pageInfo?.hasNextPage && cursor) {
-        const result = await octokit.graphql(THREAD_COMMENTS_QUERY, {
-            threadId: thread.id,
-            cursor,
-        });
-        const page = result.node?.comments;
-        const pageComments = page?.nodes ?? [];
-        thread.comments.nodes.push(...pageComments);
-        if (verbose) {
-            logInfo(`   · thread ${thread.id}: fetched ${pageComments.length} extra comment(s)`);
-        }
-        pageInfo = page?.pageInfo;
-        cursor = pageInfo?.endCursor ?? null;
-    }
-}
-/**
- * Mark review threads as resolved using GraphQL API
- */
-export async function resolveReviewThreads(octokit, threads, verbose) {
-    let markedCount = 0;
-    for (const thread of threads) {
-        try {
-            if (verbose) {
-                logInfo(`✅ Marking thread ${thread.id} as resolved...`);
-            }
-            const mutation = `
-        mutation($threadId: ID!) {
-          resolveReviewThread(input: {threadId: $threadId}) {
-            thread {
-              id
-              isResolved
-            }
-          }
-        }
-      `;
-            await octokit.graphql(mutation, {
-                threadId: thread.id,
-            });
-            markedCount++;
-            if (verbose) {
-                logInfo(`✅ Thread ${thread.id} marked as resolved`);
-            }
-        }
-        catch (error) {
-            if (verbose) {
-                logError(`Failed to resolve thread ${thread.id}: ${error}`);
-            }
-        }
-    }
-    return markedCount;
-}
-/**
- * Dismiss pull request reviews using GraphQL API
- * This is used to automatically dismiss "CHANGES_REQUESTED" reviews
- * after all feedback has been addressed by code refine
- */
-export async function dismissReviews(octokit, reviews, resolvedCommentsCount, verbose) {
-    let dismissedCount = 0;
-    for (const review of reviews) {
-        try {
-            if (verbose) {
-                logInfo(`🔄 Dismissing review ${review.id} by @${review.user.login}...`);
-            }
-            // Build dismiss message explaining what was resolved
-            const message = `All feedback has been addressed by automated code refine.\n\n` +
-                `✅ Resolved ${resolvedCommentsCount} review comment(s).\n\n` +
-                `Please re-review if you disagree with any changes.`;
-            const mutation = `
-        mutation($pullRequestReviewId: ID!, $message: String!) {
-          dismissPullRequestReview(input: {
-            pullRequestReviewId: $pullRequestReviewId
-            message: $message
-          }) {
-            pullRequestReview {
-              id
-              state
-            }
-          }
-        }
-      `;
-            await octokit.graphql(mutation, {
-                pullRequestReviewId: review.node_id,
-                message,
-            });
-            dismissedCount++;
-            if (verbose) {
-                logInfo(`✅ Dismissed review ${review.id} by @${review.user.login}`);
-            }
-        }
-        catch (error) {
-            if (verbose) {
-                logError(`Failed to dismiss review ${review.id} by @${review.user.login}: ${error}`);
-            }
-        }
-    }
-    return dismissedCount;
-}

package/dist/phases/code-refine-verification/index.d.ts

@@ -1,11 +0,0 @@
-/**
- * Code Refine Verification
- * Verifies that all PR review comments have been addressed and resolves them
- * Uses GitHub GraphQL API to accurately detect unresolved review threads
- */
-import { type CodeRefineVerificationOptions, type CodeRefineVerificationResult } from './types.js';
-export * from './types.js';
-/**
- * Verify and resolve PR review comments using GraphQL API and LLM analysis
- */
-export declare function verifyAndResolveComments(options: CodeRefineVerificationOptions): Promise<CodeRefineVerificationResult>;