edsger 0.76.0 → 0.78.0

package/dist/phases/pr-resolve/index.js

@@ -1,272 +0,0 @@
-/**
- * Standalone PR Resolve
- * Evaluates unresolved review comments, fixes what's genuinely better,
- * replies to every comment on GitHub explaining the decision.
- */
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import { Octokit } from '@octokit/rest';
-import { execSync } from 'child_process';
-import { DEFAULT_MODEL } from '../../constants.js';
-import { logError, logInfo, logSuccess } from '../../utils/logger.js';
-import { cleanupIssueRepo } from '../../workspace/workspace-manager.js';
-import { fetchUnresolvedReviewThreads } from '../code-refine-verification/github.js';
-import { createPromptGenerator, extractTextFromContent, tryExtractResult, } from '../pr-shared/agent-utils.js';
-import { parsePullRequestUrl } from '../pr-shared/context.js';
-import { updatePullRequestStatus } from '../pr-shared/status.js';
-import { learnFromReviewFeedback } from './checklist-learner.js';
-import { hasResolveMarker, replyToReviewThread, resolveReviewThread, } from './github-reply.js';
-import { createResolveSystemPrompt, createResolveUserPrompt, } from './prompts.js';
-import { isResolveResult } from './types.js';
-import { hasNewCommits, hasUncommittedChanges, prepareWorkspace, pushChanges, } from './workspace.js';
-export { isResolveResult } from './types.js';
-/**
- * Resolve PR change requests: evaluate each comment, fix or explain.
- */
-// eslint-disable-next-line complexity
-export async function resolveStandalonePR(options) {
-    const { pullRequestUrl, githubToken, owner, repo, verbose, prId } = options;
-    logInfo(`Starting PR resolve: ${pullRequestUrl}`);
-    try {
-        // Parse PR URL
-        const prInfo = parsePullRequestUrl(pullRequestUrl);
-        if (!prInfo) {
-            throw new Error(`Invalid PR URL: ${pullRequestUrl}`);
-        }
-        const octokit = new Octokit({ auth: githubToken });
-        // Fetch unresolved review threads
-        logInfo('Fetching unresolved review threads...');
-        const allUnresolvedThreads = await fetchUnresolvedReviewThreads(octokit, owner, repo, prInfo.prNumber, verbose);
-        // Skip threads whose last comment already carries our marker — they were
-        // handled in a previous pr-resolve run and replying again would just spam.
-        // If a human has commented after our reply, the last comment will no
-        // longer be ours and the thread will be picked up again.
-        const unresolvedThreads = allUnresolvedThreads.filter((thread) => {
-            const lastComment = thread.comments.nodes[thread.comments.nodes.length - 1];
-            return !hasResolveMarker(lastComment?.body);
-        });
-        const alreadyHandled = allUnresolvedThreads.length - unresolvedThreads.length;
-        if (alreadyHandled > 0) {
-            logInfo(`Skipping ${alreadyHandled} thread(s) already addressed in a previous resolve run`);
-        }
-        if (unresolvedThreads.length === 0) {
-            logSuccess('No unresolved review threads found.');
-            return {
-                status: 'success',
-                message: alreadyHandled > 0
-                    ? `All ${alreadyHandled} unresolved thread(s) were already addressed in a previous resolve run`
-                    : 'No unresolved review threads to resolve',
-                threadsAddressed: 0,
-                threadsSkipped: 0,
-            };
-        }
-        logInfo(`Found ${unresolvedThreads.length} unresolved threads to evaluate`);
-        // Get PR details for head branch
-        // Note: workspace will be preserved on failure for manual inspection
-        const { data: prData } = await octokit.pulls.get({
-            owner,
-            repo,
-            pull_number: prInfo.prNumber,
-        });
-        const headRef = prData.head.ref;
-        // Determine clone source: fork PRs need to clone from the fork repo.
-        // head.repo is null when the fork has been deleted — treat as fork with deleted source.
-        const isFork = !prData.head.repo ||
-            prData.head.repo.full_name !== prData.base.repo.full_name;
-        const forkDeleted = !prData.head.repo;
-        const cloneOwner = isFork && !forkDeleted ? prData.head.repo.owner.login : owner;
-        const cloneRepo = isFork && !forkDeleted ? prData.head.repo.name : repo;
-        if (isFork && verbose) {
-            logInfo(forkDeleted
-                ? `Fork PR detected but fork repo has been deleted, will use PR ref from ${owner}/${repo}`
-                : `Fork PR detected: cloning from ${cloneOwner}/${cloneRepo} instead of ${owner}/${repo}`);
-        }
-        // Clone repo and checkout PR branch.
-        // For fork PRs, pass fallback info so prepareWorkspace can fetch the PR ref
-        // from upstream if the fork branch is unavailable.
-        // For deleted forks, clone upstream directly and always use PR ref fallback.
-        const repoPath = prepareWorkspace({
-            owner: cloneOwner,
-            repo: cloneRepo,
-            headRef,
-            prNumber: prInfo.prNumber,
-            token: githubToken,
-            verbose,
-            forkFallback: isFork
-                ? { upstreamOwner: owner, upstreamRepo: repo }
-                : undefined,
-        });
-        try {
-            // Run Claude Agent SDK to evaluate and fix comments
-            const systemPrompt = createResolveSystemPrompt();
-            const { prompt: resolvePrompt, commentIdToThreadId } = createResolveUserPrompt(unresolvedThreads);
-            let lastAssistantResponse = '';
-            let resolveResult = null;
-            logInfo('Starting Claude agent to evaluate and resolve comments...');
-            for await (const message of query({
-                prompt: createPromptGenerator(resolvePrompt),
-                options: {
-                    systemPrompt: {
-                        type: 'preset',
-                        preset: 'claude_code',
-                        append: systemPrompt,
-                    },
-                    model: DEFAULT_MODEL,
-                    maxTurns: 2000,
-                    permissionMode: 'bypassPermissions',
-                    cwd: repoPath,
-                },
-            })) {
-                if (message.type === 'assistant') {
-                    lastAssistantResponse += extractTextFromContent(message.message?.content ?? [], verbose);
-                    continue;
-                }
-                if (message.type !== 'result') {
-                    continue;
-                }
-                if (message.subtype === 'success') {
-                    logInfo('Agent completed, parsing results...');
-                    const responseText = message.result || lastAssistantResponse;
-                    const parsed = tryExtractResult(responseText, 'resolve_result');
-                    // eslint-disable-next-line max-depth
-                    if (isResolveResult(parsed)) {
-                        resolveResult = parsed;
-                    }
-                    else {
-                        logError('Failed to parse resolve result JSON');
-                    }
-                }
-                else {
-                    logError(`Agent incomplete: ${message.subtype}`);
-                    // Try to salvage partial results from last response
-                    // eslint-disable-next-line max-depth
-                    if (lastAssistantResponse) {
-                        const salvaged = tryExtractResult(lastAssistantResponse, 'resolve_result');
-                        // eslint-disable-next-line max-depth
-                        if (isResolveResult(salvaged)) {
-                            resolveResult = salvaged;
-                        }
-                    }
-                }
-            }
-            // Fallback: commit any leftover uncommitted changes the agent didn't commit itself
-            if (hasUncommittedChanges(repoPath)) {
-                logInfo('Committing remaining uncommitted changes...');
-                execSync('git add -A', { cwd: repoPath, stdio: 'pipe' });
-                execSync('git commit -m "Resolve PR review comments\n\nAutomated resolution by Edsger AI"', { cwd: repoPath, stdio: 'pipe' });
-            }
-            // Check if there are commits to push (agent may have made its own commits)
-            const newCommitsExist = hasNewCommits(repoPath, headRef);
-            if (newCommitsExist) {
-                pushChanges(repoPath, headRef, githubToken, verbose);
-            }
-            // Reply to each comment on GitHub
-            let threadsAddressed = 0;
-            let threadsSkipped = 0;
-            let threadsErrored = 0;
-            if (resolveResult?.comments) {
-                const { comments } = resolveResult;
-                for (const comment of comments) {
-                    // Map comment_id back to real GraphQL thread ID
-                    const threadId = commentIdToThreadId.get(comment.comment_id);
-                    // eslint-disable-next-line max-depth
-                    if (!threadId) {
-                        logError(`Unknown comment_id "${comment.comment_id}", skipping reply`);
-                        threadsErrored++;
-                        continue;
-                    }
-                    // eslint-disable-next-line max-depth
-                    try {
-                        const replied = await replyToReviewThread(octokit, threadId, comment.reply, comment.action, verbose);
-                        // eslint-disable-next-line max-depth
-                        if (replied && comment.action === 'changed') {
-                            // Resolve the thread since the change was made
-                            await resolveReviewThread(octokit, threadId, verbose);
-                            threadsAddressed++;
-                        }
-                        else if (replied && comment.action === 'skipped') {
-                            // Don't resolve - leave open for human to review the explanation
-                            threadsSkipped++;
-                        }
-                        else {
-                            threadsErrored++;
-                        }
-                    }
-                    catch (error) {
-                        logError(`Failed to process ${comment.comment_id}: ${error}`);
-                        threadsErrored++;
-                    }
-                }
-            }
-            else {
-                // No structured result - check if agent made changes and reply generically
-                logInfo('No structured resolve result. Replying with generic status to each thread.');
-                const agentMadeChanges = newCommitsExist;
-                for (const thread of unresolvedThreads) {
-                    try {
-                        const genericReply = agentMadeChanges
-                            ? 'Changes were made to address review feedback. Please re-review.'
-                            : 'Reviewed this comment. No changes were made at this time.';
-                        const replied = await replyToReviewThread(octokit, thread.id, genericReply, agentMadeChanges ? 'changed' : 'skipped', verbose);
-                        // eslint-disable-next-line max-depth
-                        if (replied) {
-                            threadsSkipped++;
-                        }
-                        else {
-                            threadsErrored++;
-                        }
-                    }
-                    catch {
-                        threadsErrored++;
-                    }
-                }
-            }
-            logSuccess(`PR resolve completed: ${threadsAddressed} addressed, ${threadsSkipped} skipped, ${threadsErrored} errors`);
-            // Learn from addressed comments to update code-review checklists.
-            // Product-scoped only — repo-only mode passes learn=false.
-            if (options.learn !== false &&
-                options.productId &&
-                threadsAddressed > 0 &&
-                resolveResult) {
-                await learnFromReviewFeedback({
-                    productId: options.productId,
-                    unresolvedThreads,
-                    resolveResult,
-                    commentIdToThreadId,
-                    verbose,
-                });
-            }
-            if (prId) {
-                await updatePullRequestStatus({
-                    prId,
-                    status: 'in_review',
-                    repositoryId: options.repositoryId,
-                });
-            }
-            // Clean up workspace on success
-            cleanupIssueRepo(repoPath);
-            return {
-                status: 'success',
-                message: `Resolved ${threadsAddressed} threads, skipped ${threadsSkipped}, ${threadsErrored} errors`,
-                threadsAddressed,
-                threadsSkipped,
-                threadsErrored,
-                filesModified: resolveResult?.files_modified,
-                summary: resolveResult?.summary,
-            };
-        }
-        catch (innerError) {
-            // On failure, keep workspace for inspection
-            logError(`Error during resolve: ${innerError instanceof Error ? innerError.message : String(innerError)}`);
-            logInfo(`Workspace preserved for inspection: ${repoPath}`);
-            throw innerError;
-        }
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`PR resolve failed: ${errorMessage}`);
-        return {
-            status: 'error',
-            message: `PR resolve failed: ${errorMessage}`,
-        };
-    }
-}

package/dist/phases/pr-resolve/prompts.d.ts

@@ -1,17 +0,0 @@
-/**
- * Prompts for standalone PR resolve.
- * The agent evaluates each review comment, fixes what's genuinely better, and explains what it won't change.
- *
- * Uses simple numeric IDs (comment_1, comment_2...) instead of opaque GraphQL thread IDs
- * to make it easier for the agent to produce correct output. The caller maps back to real IDs.
- */
-import { type ReviewThread } from '../code-refine-verification/types.js';
-export declare function createResolveSystemPrompt(): string;
-/**
- * Build the user prompt with numbered comment IDs.
- * Returns the prompt string and a mapping from comment_id to real thread ID.
- */
-export declare function createResolveUserPrompt(unresolvedThreads: ReviewThread[]): {
-    prompt: string;
-    commentIdToThreadId: Map<string, string>;
-};

package/dist/phases/pr-resolve/prompts.js

@@ -1,107 +0,0 @@
-/**
- * Prompts for standalone PR resolve.
- * The agent evaluates each review comment, fixes what's genuinely better, and explains what it won't change.
- *
- * Uses simple numeric IDs (comment_1, comment_2...) instead of opaque GraphQL thread IDs
- * to make it easier for the agent to produce correct output. The caller maps back to real IDs.
- */
-export function createResolveSystemPrompt() {
-    return `You are an expert software engineer resolving code review feedback on a pull request.
-
-**Your Goal**: For each review comment, make the change unless the reviewer is factually wrong or has misunderstood the code. The default is to accept the feedback.
-
-**Make the change when** (this is the default — apply it broadly):
-- The suggestion would improve the code in any way: correctness, security, error handling, clarity, maintainability, performance, design, naming, structure, tests, docs
-- The suggestion aligns with best practices for the language or framework
-- Apply the change even if it is large, touches many files, or requires non-trivial refactoring — workload is not a reason to skip
-
-**Skip the change ONLY when** (the bar is high — be conservative about skipping):
-- The reviewer is factually wrong (e.g., claims the code does X when it actually does Y, or asserts a behavior that does not exist)
-- The reviewer has misunderstood the code's purpose, the surrounding context, or how this piece interacts with other parts of the system
-- Following the suggestion would actually make the code worse or introduce a regression
-
-Personal preference, "I'd prefer a different style", "this is more complex than I'd like", or "this conflicts with a pattern I prefer" are NOT valid reasons to skip. If the change would make the code better, do it.
-
-**Process**:
-1. Read all the review comments carefully
-2. For each comment, examine the relevant code so you actually understand what it does
-3. Default: make the change in the file. Only skip if you can articulate a specific factual error or misunderstanding by the reviewer.
-4. After making all changes, commit them with a descriptive message summarizing what was resolved (do NOT push)
-5. After committing, output a JSON summary
-
-**CRITICAL - Result Format**:
-After making all changes, you MUST output a JSON result. Use the exact comment_id from each comment (comment_1, comment_2, etc.):
-
-\`\`\`json
-{
-  "resolve_result": {
-    "comments": [
-      {
-        "comment_id": "comment_1",
-        "action": "changed",
-        "reply": "Brief description of what was changed"
-      },
-      {
-        "comment_id": "comment_2",
-        "action": "skipped",
-        "reply": "Technical explanation of why not changing"
-      }
-    ],
-    "files_modified": ["list of modified file paths"],
-    "summary": "Overall summary of what was done"
-  }
-}
-\`\`\`
-
-**Reply Guidelines**:
-- For "changed": briefly describe what was changed (1-2 sentences)
-- For "skipped": clearly explain the specific factual error or misunderstanding — point to the exact line, behavior, or invariant the reviewer got wrong (2-3 sentences). Do not skip with a vague "I disagree" — name the misunderstanding.
-- Be professional and constructive in all replies
-- You MUST include an entry for EVERY comment_id`;
-}
-/**
- * Build the user prompt with numbered comment IDs.
- * Returns the prompt string and a mapping from comment_id to real thread ID.
- */
-export function createResolveUserPrompt(unresolvedThreads) {
-    const sections = [];
-    const commentIdToThreadId = new Map();
-    sections.push('# PR Review Comments to Resolve');
-    sections.push('');
-    sections.push(`There are ${unresolvedThreads.length} unresolved review comment(s) to evaluate.`);
-    sections.push('');
-    let commentIndex = 0;
-    for (const thread of unresolvedThreads) {
-        const firstComment = thread.comments.nodes[0];
-        if (!firstComment) {
-            continue;
-        }
-        commentIndex++;
-        const commentId = `comment_${commentIndex}`;
-        commentIdToThreadId.set(commentId, thread.id);
-        sections.push(`## ${commentId}`);
-        sections.push(`**File**: ${firstComment.path}`);
-        if (firstComment.line) {
-            sections.push(`**Line**: ${firstComment.line}`);
-        }
-        sections.push(`**Author**: @${firstComment.author.login}`);
-        sections.push(`**Comment**:`);
-        sections.push(firstComment.body);
-        // Include follow-up comments in the thread
-        if (thread.comments.nodes.length > 1) {
-            sections.push('');
-            sections.push('**Follow-up comments**:');
-            for (const comment of thread.comments.nodes.slice(1)) {
-                sections.push(`- @${comment.author.login}: ${comment.body}`);
-            }
-        }
-        sections.push('');
-    }
-    sections.push('## Instructions');
-    sections.push('');
-    sections.push('For each comment above, read the referenced file and evaluate the suggestion.');
-    sections.push('Default to making the change — even if it is large or touches many files. Only skip when the reviewer is factually wrong or has misunderstood the code, and explain the specific misunderstanding in your reply.');
-    sections.push('After processing all comments, output the JSON resolve_result with your decisions and reply messages.');
-    sections.push(`Use the exact comment IDs: ${Array.from(commentIdToThreadId.keys()).join(', ')}`);
-    return { prompt: sections.join('\n'), commentIdToThreadId };
-}

package/dist/phases/pr-resolve/types.d.ts

@@ -1,18 +0,0 @@
-/**
- * Shared type definitions for PR resolve phase.
- */
-export interface ResolveComment {
-    comment_id: string;
-    action: 'changed' | 'skipped';
-    reply: string;
-}
-export interface ResolveResult {
-    comments: ResolveComment[];
-    files_modified?: string[];
-    summary?: string;
-}
-/**
- * Runtime type guard — validates that an unknown value from tryExtractResult
- * has the shape of a ResolveResult.
- */
-export declare function isResolveResult(value: unknown): value is ResolveResult;

package/dist/phases/pr-resolve/types.js

@@ -1,14 +0,0 @@
-/**
- * Shared type definitions for PR resolve phase.
- */
-/**
- * Runtime type guard — validates that an unknown value from tryExtractResult
- * has the shape of a ResolveResult.
- */
-export function isResolveResult(value) {
-    if (!value || typeof value !== 'object') {
-        return false;
-    }
-    const obj = value;
-    return Array.isArray(obj.comments);
-}

package/dist/phases/pr-resolve/workspace.d.ts

@@ -1,45 +0,0 @@
-/**
- * Git workspace operations for PR resolve.
- * Extracted for testability.
- */
-/**
- * Build git credential helper args for GitHub token auth.
- */
-export declare function buildCredentialArgs(token: string): string[];
-/**
- * Get the workspace path for a PR resolve operation.
- * Includes owner/repo to avoid collisions when resolving PRs from different repos.
- */
-export declare function getResolveWorkspacePath(owner: string, repo: string, prNumber: number): string;
-export interface ForkFallbackInfo {
-    upstreamOwner: string;
-    upstreamRepo: string;
-}
-export interface PrepareWorkspaceOptions {
-    owner: string;
-    repo: string;
-    headRef: string;
-    prNumber: number;
-    token: string;
-    verbose?: boolean;
-    forkFallback?: ForkFallbackInfo;
-}
-/**
- * Clone or reuse a repo for PR resolve.
- * For fork PRs, clones from the fork repo. If the fork branch is unavailable,
- * falls back to fetching the PR ref from the upstream repo.
- * Returns the workspace path.
- */
-export declare function prepareWorkspace(options: PrepareWorkspaceOptions): string;
-/**
- * Push changes from workspace back to remote.
- */
-export declare function pushChanges(repoPath: string, headRef: string, token: string, _verbose?: boolean): boolean;
-/**
- * Check if there are uncommitted changes in the workspace.
- */
-export declare function hasUncommittedChanges(repoPath: string): boolean;
-/**
- * Check if there are new commits ahead of remote.
- */
-export declare function hasNewCommits(repoPath: string, headRef: string): boolean;

package/dist/phases/pr-resolve/workspace.js

@@ -1,174 +0,0 @@
-/**
- * Git workspace operations for PR resolve.
- * Extracted for testability.
- */
-import { execFileSync, execSync } from 'child_process';
-import { existsSync } from 'fs';
-import { homedir } from 'os';
-import { join } from 'path';
-import { logError, logInfo, logSuccess } from '../../utils/logger.js';
-/**
- * Build git credential helper args for GitHub token auth.
- */
-export function buildCredentialArgs(token) {
-    const credentialHelper = `!f() { echo "username=x-access-token"; echo "password=${token}"; }; f`;
-    return [
-        '-c',
-        'credential.helper=',
-        '-c',
-        `credential.helper=${credentialHelper}`,
-    ];
-}
-/**
- * Get the workspace path for a PR resolve operation.
- * Includes owner/repo to avoid collisions when resolving PRs from different repos.
- */
-export function getResolveWorkspacePath(owner, repo, prNumber) {
-    return join(homedir(), 'edsger', `pr-resolve-${owner}-${repo}-${prNumber}`);
-}
-/**
- * Clone or reuse a repo for PR resolve.
- * For fork PRs, clones from the fork repo. If the fork branch is unavailable,
- * falls back to fetching the PR ref from the upstream repo.
- * Returns the workspace path.
- */
-export function prepareWorkspace(options) {
-    const { owner, repo, headRef, prNumber, token, verbose, forkFallback } = options;
-    const repoPath = getResolveWorkspacePath(owner, repo, prNumber);
-    const repoUrl = `https://github.com/${owner}/${repo}.git`;
-    const gitCredentialArgs = buildCredentialArgs(token);
-    if (existsSync(join(repoPath, '.git'))) {
-        logInfo(`Reusing existing repo at ${repoPath}`);
-        try {
-            execSync(`git remote set-url origin "${repoUrl}"`, {
-                cwd: repoPath,
-                stdio: 'pipe',
-            });
-        }
-        catch {
-            // ignore
-        }
-        try {
-            execFileSync('git', [...gitCredentialArgs, 'fetch', 'origin'], {
-                cwd: repoPath,
-                stdio: 'pipe',
-            });
-        }
-        catch {
-            logError('Could not fetch latest changes');
-        }
-        try {
-            execSync(`git checkout ${headRef}`, { cwd: repoPath, stdio: 'pipe' });
-            execSync(`git reset --hard origin/${headRef}`, {
-                cwd: repoPath,
-                stdio: 'pipe',
-            });
-        }
-        catch {
-            logError(`Could not checkout branch ${headRef}`);
-        }
-    }
-    else {
-        logInfo(`Cloning ${owner}/${repo} (branch: ${headRef})...`);
-        try {
-            execFileSync('git', [
-                ...gitCredentialArgs,
-                'clone',
-                '--branch',
-                headRef,
-                '--single-branch',
-                repoUrl,
-                repoPath,
-            ], { stdio: 'pipe' });
-            logSuccess(`Cloned to ${repoPath}`);
-        }
-        catch (error) {
-            // If clone fails and this is a fork PR, fall back to upstream PR ref
-            if (forkFallback) {
-                logInfo(`Fork branch not available, falling back to PR ref from ${forkFallback.upstreamOwner}/${forkFallback.upstreamRepo}`);
-                const upstreamUrl = `https://github.com/${forkFallback.upstreamOwner}/${forkFallback.upstreamRepo}.git`;
-                execFileSync('git', [...gitCredentialArgs, 'clone', upstreamUrl, repoPath], { stdio: 'pipe' });
-                // Fetch the PR ref and check it out
-                execFileSync('git', [
-                    ...gitCredentialArgs,
-                    'fetch',
-                    'origin',
-                    `pull/${prNumber}/head:${headRef}`,
-                ], { cwd: repoPath, stdio: 'pipe' });
-                execSync(`git checkout ${headRef}`, {
-                    cwd: repoPath,
-                    stdio: 'pipe',
-                });
-                logSuccess(`Cloned via PR ref to ${repoPath}`);
-            }
-            else {
-                throw error;
-            }
-        }
-    }
-    // Configure git user for commits
-    try {
-        execSync('git config user.email "edsger-bot@edsger.ai"', {
-            cwd: repoPath,
-            stdio: 'pipe',
-        });
-        execSync('git config user.name "Edsger Bot"', {
-            cwd: repoPath,
-            stdio: 'pipe',
-        });
-    }
-    catch {
-        if (verbose) {
-            logInfo('Note: Could not set git user config');
-        }
-    }
-    return repoPath;
-}
-/**
- * Push changes from workspace back to remote.
- */
-export function pushChanges(repoPath, headRef, token, _verbose) {
-    const gitCredentialArgs = buildCredentialArgs(token);
-    try {
-        execFileSync('git', [...gitCredentialArgs, 'push', 'origin', headRef], {
-            cwd: repoPath,
-            stdio: 'pipe',
-        });
-        logSuccess('Pushed changes to remote');
-        return true;
-    }
-    catch (error) {
-        logError(`Failed to push: ${error instanceof Error ? error.message : String(error)}`);
-        return false;
-    }
-}
-/**
- * Check if there are uncommitted changes in the workspace.
- */
-export function hasUncommittedChanges(repoPath) {
-    try {
-        const result = execSync('git status --porcelain', {
-            cwd: repoPath,
-            encoding: 'utf-8',
-        });
-        return result.trim().length > 0;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Check if there are new commits ahead of remote.
- */
-export function hasNewCommits(repoPath, headRef) {
-    try {
-        const result = execSync(`git log origin/${headRef}..HEAD --oneline`, {
-            cwd: repoPath,
-            encoding: 'utf-8',
-        });
-        return result.trim().length > 0;
-    }
-    catch {
-        return false;
-    }
-}

package/dist/phases/pr-review/index.d.ts

@@ -1,27 +0,0 @@
-/**
- * Standalone PR Review
- * Reviews a GitHub PR and posts review comments, without issue lifecycle dependency.
- */
-export interface StandalonePRReviewOptions {
-    productId?: string;
-    /** Set for repo-scoped PRs — routes the status write through Supabase. */
-    repositoryId?: string;
-    pullRequestUrl: string;
-    githubToken: string;
-    owner: string;
-    repo: string;
-    prId?: string;
-    verbose?: boolean;
-}
-export interface StandalonePRReviewResult {
-    status: 'success' | 'error';
-    message: string;
-    reviewId?: number;
-    reviewUrl?: string;
-    commentsCount?: number;
-    summary?: string;
-}
-/**
- * Review a standalone PR and post comments to GitHub.
- */
-export declare function reviewStandalonePR(options: StandalonePRReviewOptions): Promise<StandalonePRReviewResult>;