edsger 0.76.0 → 0.78.0

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

@@ -1,260 +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 { Octokit } from '@octokit/rest';
-import { getReviewedBranch } from '../../services/branches.js';
-import { logError, logInfo } from '../../utils/logger.js';
-import { fetchPRReviews, parsePullRequestUrl } from '../code-refine/context.js';
-import { dismissReviews, fetchPRFileChanges, fetchUnresolvedReviewThreads, resolveReviewThreads, } from './github.js';
-import { analyzeAllThreads } from './llm-analyzer.js';
-// Re-export types for backward compatibility
-export * from './types.js';
-/**
- * Verify and resolve PR review comments using GraphQL API and LLM analysis
- */
-// eslint-disable-next-line complexity -- orchestration function with comment fetching, AI analysis, and resolution
-export async function verifyAndResolveComments(options) {
-    const { issueId, githubToken, config, verbose } = options;
-    if (verbose) {
-        logInfo(`Starting code refine verification for issue ID: ${issueId}`);
-    }
-    try {
-        // For multi-branch issues, find the branch that has been reviewed
-        // (status = 'reviewed' after code-review phase)
-        let currentBranch = null;
-        try {
-            currentBranch = await getReviewedBranch({ issueId, verbose });
-            if (currentBranch && verbose) {
-                logInfo(`📋 Found reviewed branch: ${currentBranch.name}`);
-            }
-        }
-        catch (_error) {
-            if (verbose) {
-                logInfo(`Note: Could not fetch issue branches`);
-            }
-        }
-        // Get PR URL from branch
-        let pullRequestUrl = null;
-        if (currentBranch && currentBranch.pull_request_url) {
-            pullRequestUrl = currentBranch.pull_request_url;
-            if (verbose) {
-                logInfo(`📝 Using PR URL from branch: ${pullRequestUrl}`);
-            }
-        }
-        if (!pullRequestUrl) {
-            throw new Error(`Issue ${issueId} does not have a pull request URL. Cannot perform verification.`);
-        }
-        // Parse PR URL
-        const prInfo = parsePullRequestUrl(pullRequestUrl);
-        if (!prInfo) {
-            throw new Error(`Invalid pull request URL: ${pullRequestUrl}. Expected format: https://github.com/owner/repo/pull/123`);
-        }
-        const { owner, repo, prNumber } = prInfo;
-        // Initialize Octokit with GitHub token (supports both REST and GraphQL)
-        const octokit = new Octokit({
-            auth: githubToken,
-        });
-        // Fetch unresolved review threads, reviews, and file changes
-        const [unresolvedThreads, reviews, fileChanges] = await Promise.all([
-            fetchUnresolvedReviewThreads(octokit, owner, repo, prNumber, verbose),
-            fetchPRReviews(octokit, owner, repo, prNumber, verbose),
-            fetchPRFileChanges(octokit, owner, repo, prNumber, verbose),
-        ]);
-        // Check if there's anything to verify
-        if (reviews.length === 0 && unresolvedThreads.length === 0) {
-            if (verbose) {
-                logInfo('✅ No reviews or unresolved review threads found. Verification complete.');
-            }
-            return {
-                status: 'success',
-                message: 'No reviews or review comments to verify',
-                data: {
-                    issueId,
-                    totalReviews: 0,
-                    unresolvedReviews: 0,
-                    totalComments: 0,
-                    resolvedComments: 0,
-                    unresolvedComments: 0,
-                },
-            };
-        }
-        // Use LLM to intelligently analyze unresolved threads
-        const threadAnalysisResults = await analyzeAllThreads(unresolvedThreads, fileChanges, config, verbose);
-        // Separate threads that LLM determined are addressed vs not addressed
-        const addressedThreads = threadAnalysisResults.filter((result) => result.analysis.isAddressed);
-        const trulyUnresolvedThreads = threadAnalysisResults.filter((result) => !result.analysis.isAddressed);
-        // Auto-resolve threads that LLM determined are addressed
-        let totalResolvedComments = 0;
-        if (addressedThreads.length > 0) {
-            if (verbose) {
-                logInfo(`✅ Auto-resolving ${addressedThreads.length} threads that have been addressed...`);
-            }
-            const resolvedCount = await resolveReviewThreads(octokit, addressedThreads.map((r) => r.thread), verbose);
-            totalResolvedComments = resolvedCount;
-            if (verbose) {
-                logInfo(`✅ Successfully resolved ${resolvedCount} threads`);
-            }
-        }
-        // Check reviews - they need to be dismissed if all comments are addressed
-        const changesRequestedReviews = reviews.filter((review) => review.state === 'CHANGES_REQUESTED');
-        if (verbose) {
-            logInfo(`📊 Review Threads: ${trulyUnresolvedThreads.length} still unresolved (after LLM analysis)`);
-            if (reviews.length > 0) {
-                logInfo(`📊 Reviews: ${changesRequestedReviews.length} requesting changes`);
-            }
-        }
-        // If all threads are truly resolved, dismiss the "CHANGES_REQUESTED" reviews
-        let dismissedReviewsCount = 0;
-        if (trulyUnresolvedThreads.length === 0 &&
-            changesRequestedReviews.length > 0) {
-            if (verbose) {
-                logInfo(`🔄 All comments addressed. Dismissing ${changesRequestedReviews.length} review(s) requesting changes...`);
-            }
-            dismissedReviewsCount = await dismissReviews(octokit, changesRequestedReviews, totalResolvedComments, verbose);
-            if (verbose) {
-                logInfo(`✅ Successfully dismissed ${dismissedReviewsCount} review(s)`);
-            }
-        }
-        // If all threads are truly resolved (after LLM analysis) AND reviews are dismissed, success
-        const allReviewsDismissed = changesRequestedReviews.length === 0 ||
-            dismissedReviewsCount === changesRequestedReviews.length;
-        if (trulyUnresolvedThreads.length === 0 && allReviewsDismissed) {
-            if (verbose) {
-                logInfo('✅ All comments have been addressed! All review threads are resolved.');
-            }
-            let successMessage = 'All review comments have been addressed and resolved';
-            if (dismissedReviewsCount > 0) {
-                successMessage = `All reviews and review comments have been addressed. ${dismissedReviewsCount} review(s) dismissed.`;
-            }
-            else if (reviews.length > 0) {
-                successMessage =
-                    'All reviews and review comments have been addressed and resolved';
-            }
-            return {
-                status: 'success',
-                message: successMessage,
-                data: {
-                    issueId,
-                    totalReviews: reviews.length,
-                    unresolvedReviews: 0,
-                    totalComments: unresolvedThreads.length,
-                    resolvedComments: addressedThreads.length,
-                    unresolvedComments: 0,
-                    commentsMarkedResolved: addressedThreads.length,
-                    dismissedReviews: dismissedReviewsCount,
-                },
-            };
-        }
-        // Verification failed - build detailed info with specific failure reasons from LLM analysis
-        // Calculate remaining reviews that weren't dismissed
-        const remainingReviewsCount = changesRequestedReviews.length - dismissedReviewsCount;
-        if (verbose) {
-            if (remainingReviewsCount > 0) {
-                logInfo(`⚠️  ${remainingReviewsCount} reviews still requesting changes (failed to dismiss)`);
-                changesRequestedReviews.forEach((review) => {
-                    logInfo(`  - Review ${review.id} by @${review.user.login}`);
-                    if (review.body) {
-                        logInfo(`    ${review.body.substring(0, 100)}...`);
-                    }
-                });
-            }
-            if (trulyUnresolvedThreads.length > 0) {
-                logInfo(`⚠️  ${trulyUnresolvedThreads.length} review threads still need to be addressed`);
-                trulyUnresolvedThreads.forEach((result) => {
-                    const firstComment = result.thread.comments.nodes[0];
-                    if (firstComment) {
-                        logInfo(`  - Comment by @${firstComment.author.login}`);
-                        logInfo(`    File: ${firstComment.path}:${firstComment.line || '?'}`);
-                        logInfo(`    ${firstComment.body.substring(0, 100)}...`);
-                        logInfo(`    LLM Analysis: ${result.analysis.reason}`);
-                    }
-                });
-            }
-        }
-        // Build targeted suggestions based on LLM analysis
-        const suggestions = [];
-        // Create specific suggestions for each truly unresolved comment (based on LLM analysis)
-        trulyUnresolvedThreads.forEach((result, index) => {
-            const firstComment = result.thread.comments.nodes[0];
-            if (firstComment) {
-                suggestions.push(`${index + 1}. [${firstComment.path}:${firstComment.line || '?'}] by @${firstComment.author.login}: ${result.analysis.reason}`);
-            }
-        });
-        // Add review-specific suggestions if any reviews failed to dismiss
-        if (remainingReviewsCount > 0) {
-            suggestions.push(`\n${remainingReviewsCount} review(s) requesting changes could not be automatically dismissed:`);
-            changesRequestedReviews.forEach((review) => {
-                suggestions.push(`  - @${review.user.login}: ${review.body ? review.body.substring(0, 150) : 'No details provided'}${review.body && review.body.length > 150 ? '...' : ''}`);
-            });
-        }
-        // Build detailed unresolved info with LLM-analyzed failure reasons
-        const unresolvedCommentDetails = trulyUnresolvedThreads.map((result) => {
-            const firstComment = result.thread.comments.nodes[0];
-            return {
-                commentId: firstComment.id,
-                author: firstComment.author.login,
-                file: firstComment.path,
-                line: firstComment.line,
-                body: firstComment.body,
-                failureReason: result.analysis.reason, // Use LLM analysis result
-                url: firstComment.url,
-            };
-        });
-        const unresolvedReviewDetails = changesRequestedReviews.map((review) => ({
-            reviewId: review.id,
-            author: review.user.login,
-            state: review.state,
-            body: review.body,
-            submittedAt: review.submitted_at,
-        }));
-        let errorMessage = '';
-        if (remainingReviewsCount > 0 && trulyUnresolvedThreads.length > 0) {
-            errorMessage = `${remainingReviewsCount} reviews and ${trulyUnresolvedThreads.length} review threads still need to be addressed (based on LLM analysis)`;
-        }
-        else if (remainingReviewsCount > 0) {
-            errorMessage = `${remainingReviewsCount} reviews could not be dismissed`;
-        }
-        else {
-            errorMessage = `${trulyUnresolvedThreads.length} review comments still need to be addressed (based on LLM analysis)`;
-        }
-        return {
-            status: 'error',
-            message: errorMessage,
-            data: {
-                issueId,
-                totalReviews: reviews.length,
-                unresolvedReviews: remainingReviewsCount,
-                totalComments: unresolvedThreads.length, // Original count before LLM analysis
-                resolvedComments: addressedThreads.length, // LLM determined these are addressed
-                unresolvedComments: trulyUnresolvedThreads.length, // LLM determined these still need work
-                commentsMarkedResolved: addressedThreads.length,
-                dismissedReviews: dismissedReviewsCount,
-                suggestions,
-                unresolvedReviewDetails,
-                unresolvedCommentDetails,
-            },
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Code refine verification failed: ${errorMessage}`);
-        return {
-            status: 'error',
-            message: `Verification failed: ${errorMessage}`,
-            data: {
-                issueId,
-                totalReviews: 0,
-                unresolvedReviews: 0,
-                totalComments: 0,
-                resolvedComments: 0,
-                unresolvedComments: 0,
-                suggestions: [
-                    `Verification failed with error: ${errorMessage}`,
-                    'Please check the error message and try again',
-                ],
-            },
-        };
-    }
-}

package/dist/phases/code-refine-verification/llm-analyzer.d.ts

@@ -1,22 +0,0 @@
-/**
- * LLM-based analysis for code review comment verification
- * Uses Claude to intelligently determine if feedback has been addressed
- */
-import { type EdsgerConfig } from '../../types/index.js';
-import { type PRFileChange, type ReviewThread } from './types.js';
-export interface ThreadAnalysisResult {
-    isAddressed: boolean;
-    reason: string;
-}
-/**
- * Analyze whether a review thread has been addressed by examining code changes
- * Uses LLM to intelligently determine if the feedback was addressed
- */
-export declare function analyzeThreadWithLLM(thread: ReviewThread, fileChange: PRFileChange | undefined, allFileChanges: PRFileChange[], config: EdsgerConfig, verbose?: boolean): Promise<ThreadAnalysisResult>;
-/**
- * Analyze all review threads in parallel using LLM
- */
-export declare function analyzeAllThreads(threads: ReviewThread[], fileChanges: PRFileChange[], config: EdsgerConfig, verbose?: boolean): Promise<{
-    thread: ReviewThread;
-    analysis: ThreadAnalysisResult;
-}[]>;

package/dist/phases/code-refine-verification/llm-analyzer.js

@@ -1,152 +0,0 @@
-/**
- * LLM-based analysis for code review comment verification
- * Uses Claude to intelligently determine if feedback has been addressed
- */
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import { DEFAULT_MODEL } from '../../constants.js';
-import { logError, logInfo } from '../../utils/logger.js';
-import { createThreadAnalysisPrompt } from './prompts.js';
-/**
- * Extract text from assistant message content
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function extractTextContent(content) {
-    let text = '';
-    for (const item of content) {
-        if (item.type === 'text') {
-            text += `${item.text}\n`;
-        }
-    }
-    return text;
-}
-/**
- * Parse analysis response text into a result object
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function parseAnalysisResponse(responseText) {
-    // Try to extract JSON from response
-    const jsonMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
-    if (jsonMatch) {
-        return JSON.parse(jsonMatch[1]);
-    }
-    // Try to parse directly
-    try {
-        return JSON.parse(responseText);
-    }
-    catch {
-        // Fallback: look for isAddressed boolean in text
-        const isAddressedMatch = /isAddressed["']?\s*:\s*(true|false)/i.exec(responseText);
-        if (isAddressedMatch) {
-            return {
-                isAddressed: isAddressedMatch[1].toLowerCase() === 'true',
-                reason: responseText.split('\n').find((line) => line.trim()) ||
-                    'Analysis completed',
-            };
-        }
-        return null;
-    }
-}
-/**
- * Analyze whether a review thread has been addressed by examining code changes
- * Uses LLM to intelligently determine if the feedback was addressed
- */
-export async function analyzeThreadWithLLM(thread, fileChange, allFileChanges, config, verbose) {
-    const firstComment = thread.comments.nodes[0];
-    if (!firstComment) {
-        return {
-            isAddressed: false,
-            reason: 'Comment thread exists but has no comments',
-        };
-    }
-    // If file was deleted, thread should be resolved as obsolete
-    if (fileChange?.status === 'removed') {
-        return {
-            isAddressed: true,
-            reason: 'File has been removed',
-        };
-    }
-    // Check if there are any file changes at all
-    const hasAnyChanges = allFileChanges.some((fc) => fc.patch);
-    if (!hasAnyChanges) {
-        return {
-            isAddressed: false,
-            reason: 'No code changes found in this PR',
-        };
-    }
-    try {
-        if (verbose) {
-            logInfo(`🤖 Using LLM to analyze if comment in ${firstComment.path}:${firstComment.line} has been addressed...`);
-        }
-        const analysisPrompt = createThreadAnalysisPrompt(thread, fileChange, allFileChanges, firstComment);
-        let lastResponse = '';
-        let analysisResult = null;
-        function* userMessage() {
-            yield {
-                type: 'user',
-                message: { role: 'user', content: analysisPrompt },
-            };
-        }
-        for await (const message of query({
-            prompt: userMessage(),
-            options: {
-                model: DEFAULT_MODEL,
-                maxTurns: 10,
-                permissionMode: 'bypassPermissions',
-            },
-        })) {
-            if (message.type === 'assistant') {
-                lastResponse += extractTextContent(message.message?.content ?? []);
-                continue;
-            }
-            if (message.type !== 'result') {
-                continue;
-            }
-            if (message.subtype === 'success') {
-                analysisResult = parseAnalysisResponse(message.result || lastResponse);
-            }
-        }
-        if (analysisResult) {
-            if (verbose) {
-                logInfo(`   ${analysisResult.isAddressed ? '✅' : '❌'} ${analysisResult.reason}`);
-            }
-            return analysisResult;
-        }
-        // Fallback if LLM analysis failed
-        return {
-            isAddressed: false,
-            reason: 'Unable to analyze - please review manually',
-        };
-    }
-    catch (error) {
-        if (verbose) {
-            logError(`LLM analysis failed: ${error}`);
-        }
-        return {
-            isAddressed: false,
-            reason: 'Analysis failed - please review manually',
-        };
-    }
-}
-/**
- * Analyze all review threads in parallel using LLM
- */
-export async function analyzeAllThreads(threads, fileChanges, config, verbose) {
-    if (verbose && threads.length > 0) {
-        logInfo(`🔍 Analyzing ${threads.length} unresolved threads with LLM...`);
-    }
-    const results = await Promise.all(threads.map(async (thread) => {
-        const firstComment = thread.comments.nodes[0];
-        const fileChange = fileChanges.find((fc) => fc.filename === firstComment?.path);
-        const analysis = await analyzeThreadWithLLM(thread, fileChange, fileChanges, config, verbose);
-        return {
-            thread,
-            analysis,
-        };
-    }));
-    if (verbose) {
-        const addressedCount = results.filter((r) => r.analysis.isAddressed).length;
-        const unresolvedCount = results.length - addressedCount;
-        logInfo(`📊 LLM Analysis: ${addressedCount} threads addressed, ${unresolvedCount} still need attention`);
-    }
-    return results;
-}

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

@@ -1,5 +0,0 @@
-import { type PRFileChange, type ReviewThread } from './types.js';
-/**
- * Create prompt for LLM to analyze if a comment thread has been addressed
- */
-export declare function createThreadAnalysisPrompt(thread: ReviewThread, fileChange: PRFileChange | undefined, allFileChanges: PRFileChange[], firstComment: ReviewThread['comments']['nodes'][0]): string;

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

@@ -1,119 +0,0 @@
-/**
- * Create prompt for LLM to analyze if a comment thread has been addressed
- */
-export function createThreadAnalysisPrompt(thread, fileChange, allFileChanges, firstComment) {
-    const allComments = thread.comments.nodes
-        .map((c, idx) => `Comment ${idx + 1} by @${c.author.login}:\n${c.body}`)
-        .join('\n\n');
-    // Build the code context section
-    let codeContext = '';
-    const commentFilePath = firstComment.path;
-    // Check if the comment's file was modified
-    const commentFileModified = fileChange && fileChange.patch;
-    if (commentFileModified) {
-        // Include diff for the comment's file
-        codeContext += `**Changes in ${commentFilePath} (where the comment was made):**
-\`\`\`diff
-${fileChange.patch}
-\`\`\`
-
-`;
-        // Include full file content for better context
-        if (fileChange.fullContent) {
-            const maxLength = 10000;
-            const content = fileChange.fullContent.length > maxLength
-                ? `${fileChange.fullContent.substring(0, maxLength)}\n\n... (file truncated, showing first 10000 characters)`
-                : fileChange.fullContent;
-            codeContext += `**Complete File Content of ${commentFilePath} (After Changes):**
-\`\`\`
-${content}
-\`\`\`
-
-`;
-        }
-    }
-    else {
-        codeContext += `**Note:** The file where the comment was made (${commentFilePath}) was NOT modified in this PR.
-This could be intentional - the comment may be requesting changes to a DIFFERENT file.
-
-`;
-    }
-    // Include other file changes - important for cross-file requests
-    // (e.g., "add these variables to the env example file")
-    const otherChanges = allFileChanges.filter((fc) => fc.filename !== commentFilePath && fc.patch);
-    if (otherChanges.length > 0) {
-        codeContext += `**Other Files Changed in This PR:**\n`;
-        // Show summary of all changed files first
-        codeContext += `Changed files: ${otherChanges.map((fc) => fc.filename).join(', ')}\n\n`;
-        // Include diffs for potentially relevant files (env files, config files, etc.)
-        // and a sample of other changes
-        const relevantPatterns = [
-            /\.env/i,
-            /config/i,
-            /example/i,
-            /sample/i,
-            /template/i,
-        ];
-        const relevantChanges = otherChanges.filter((fc) => relevantPatterns.some((pattern) => pattern.test(fc.filename)));
-        const otherSampleChanges = otherChanges
-            .filter((fc) => !relevantChanges.includes(fc))
-            .slice(0, 3); // Limit to avoid context overflow
-        const changesToShow = [...relevantChanges, ...otherSampleChanges];
-        for (const change of changesToShow) {
-            if (change.patch) {
-                codeContext += `**Changes in ${change.filename}:**
-\`\`\`diff
-${change.patch}
-\`\`\`
-
-`;
-            }
-        }
-        if (otherChanges.length > changesToShow.length) {
-            codeContext += `(${otherChanges.length - changesToShow.length} additional files changed but not shown)\n\n`;
-        }
-    }
-    if (!codeContext.includes('```')) {
-        codeContext = '(No code changes available)\n\n';
-    }
-    return `You are analyzing whether a code review comment has been addressed by subsequent code changes.
-
-**Review Thread Information:**
-- Comment Location: ${firstComment.path}:${firstComment.line || 'N/A'}
-- Thread has ${thread.comments.totalCount} comment(s)
-
-**Review Comments:**
-${allComments}
-
-${codeContext}
-
-**Your Task:**
-Analyze whether the code changes adequately address the feedback in the review comments.
-
-**IMPORTANT - Cross-File Requests:**
-- A comment on file A may request changes to file B (e.g., "add this to the env example file")
-- The comment may use variable names (like "clientId") that differ from the actual environment variable names (like "SPOKE_CLIENT_ID")
-- Focus on whether the **intent** of the feedback was addressed, regardless of which file was modified
-- Check ALL changed files, not just the file where the comment was made
-
-Consider:
-1. Does the feedback request a specific code change? What is the **intent**?
-2. Have those changes (or equivalent changes) been made in ANY file?
-3. If the comment mentions adding something to a config/env file, check if those files were modified
-4. Variable names in comments may not match actual implementation names
-5. Focus on whether the underlying issue was addressed, not literal string matching
-
-Return your analysis in this JSON format:
-\`\`\`json
-{
-  "isAddressed": true or false,
-  "reason": "Brief explanation of why you determined the feedback was or was not addressed"
-}
-\`\`\`
-
-Example responses:
-- {"isAddressed": true, "reason": "Null check added in the updated code"}
-- {"isAddressed": false, "reason": "No relevant changes found to address the feedback"}
-- {"isAddressed": true, "reason": "Requested changes made in the appropriate file"}
-`;
-}

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

@@ -1,74 +0,0 @@
-/**
- * Type definitions for Code Refine Verification
- */
-import { type EdsgerConfig } from '../../types/index.js';
-export interface ReviewThreadComment {
-    id: string;
-    author: {
-        login: string;
-    };
-    body: string;
-    path: string;
-    line: number | null;
-    url: string;
-}
-export interface ReviewThread {
-    id: string;
-    isResolved: boolean;
-    isOutdated: boolean;
-    comments: {
-        totalCount: number;
-        pageInfo?: {
-            hasNextPage: boolean;
-            endCursor: string | null;
-        };
-        nodes: ReviewThreadComment[];
-    };
-}
-export interface PRFileChange {
-    filename: string;
-    status: 'added' | 'modified' | 'removed' | 'renamed';
-    additions: number;
-    deletions: number;
-    changes: number;
-    patch?: string;
-    fullContent?: string;
-}
-export interface CodeRefineVerificationOptions {
-    issueId: string;
-    githubToken: string;
-    config: EdsgerConfig;
-    verbose?: boolean;
-}
-export interface CodeRefineVerificationData {
-    issueId: string;
-    totalReviews: number;
-    unresolvedReviews: number;
-    totalComments: number;
-    resolvedComments: number;
-    unresolvedComments: number;
-    commentsMarkedResolved?: number;
-    dismissedReviews?: number;
-    suggestions?: string[];
-    unresolvedReviewDetails?: {
-        reviewId: number;
-        author: string;
-        state: string;
-        body: string | null;
-        submittedAt: string | null;
-    }[];
-    unresolvedCommentDetails?: {
-        commentId: string;
-        author: string;
-        file: string;
-        line: number | null;
-        body: string;
-        failureReason: string;
-        url: string;
-    }[];
-}
-export interface CodeRefineVerificationResult {
-    status: 'success' | 'error';
-    message: string;
-    data: CodeRefineVerificationData;
-}

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

@@ -1,4 +0,0 @@
-/**
- * Type definitions for Code Refine Verification
- */
-export {};