wiggum-cli 0.13.2 → 0.14.0

package/dist/tui/screens/RunScreen.d.ts

@@ -13,8 +13,98 @@
  */
 import React from 'react';
 import type { SessionState } from '../../repl/session-state.js';
+/**
+ * Phase execution status and timing
+ */
+export interface PhaseInfo {
+    /** Unique phase identifier (e.g., 'planning', 'implementation') */
+    id: string;
+    /** Human-readable phase label */
+    label: string;
+    /** Phase completion status */
+    status: 'success' | 'skipped' | 'failed';
+    /** Duration in milliseconds, if available */
+    durationMs?: number;
+    /** Number of iterations in this phase (e.g., for implementation) */
+    iterations?: number;
+}
+/**
+ * Iteration breakdown across different contexts
+ */
+export interface IterationBreakdown {
+    /** Total iterations across all runs */
+    total: number;
+    /** Iterations during implementation phase */
+    implementation?: number;
+    /** Iterations during resume operations */
+    resumes?: number;
+}
+/**
+ * File change statistics from git diff
+ */
+export interface FileChangeStat {
+    /** Relative path from project root */
+    path: string;
+    /** Lines added */
+    added: number;
+    /** Lines removed */
+    removed: number;
+}
+/**
+ * Changes summary with git diff stats
+ */
+export interface ChangesSummary {
+    /** Total number of files changed */
+    totalFilesChanged?: number;
+    /** Per-file diff statistics */
+    files?: FileChangeStat[];
+    /** Whether git diff information was available */
+    available: boolean;
+}
+/**
+ * Commit information from git
+ */
+export interface CommitsSummary {
+    /** Starting commit hash (short) */
+    fromHash?: string;
+    /** Ending commit hash (short) */
+    toHash?: string;
+    /** Merge type if applicable */
+    mergeType?: 'squash' | 'normal' | 'none';
+    /** Whether git commit information was available */
+    available: boolean;
+}
+/**
+ * Pull request metadata
+ */
+export interface PrSummary {
+    /** PR number if created */
+    number?: number;
+    /** PR URL if created */
+    url?: string;
+    /** Whether PR information was available to query */
+    available: boolean;
+    /** Whether a PR was created as part of this loop */
+    created: boolean;
+}
+/**
+ * Issue metadata
+ */
+export interface IssueSummary {
+    /** Issue number if linked */
+    number?: number;
+    /** Issue URL if available */
+    url?: string;
+    /** Issue status (e.g., 'Closed') */
+    status?: string;
+    /** Whether issue information was available to query */
+    available: boolean;
+    /** Whether an issue was linked/closed as part of this loop */
+    linked: boolean;
+}
 export interface RunSummary {
     feature: string;
+    /** Legacy field: total iterations (deprecated, use iterationBreakdown.total) */
     iterations: number;
     maxIterations: number;
     tasksDone: number;
@@ -27,6 +117,29 @@ export interface RunSummary {
     branch?: string;
     logPath?: string;
     errorTail?: string;
+    /** Loop start timestamp (ISO 8601 or epoch ms) */
+    startedAt?: string | number;
+    /** Loop end timestamp (ISO 8601 or epoch ms) */
+    endedAt?: string | number;
+    /** Total duration across all runs/resumes in milliseconds */
+    totalDurationMs?: number;
+    /** Detailed iteration breakdown */
+    iterationBreakdown?: IterationBreakdown;
+    /** Task completion counts */
+    tasks?: {
+        completed: number | null;
+        total: number | null;
+    };
+    /** Phase execution details */
+    phases?: PhaseInfo[];
+    /** Git diff changes summary */
+    changes?: ChangesSummary;
+    /** Git commit information */
+    commits?: CommitsSummary;
+    /** Pull request metadata */
+    pr?: PrSummary;
+    /** Issue metadata */
+    issue?: IssueSummary;
 }
 export interface RunScreenProps {
     /** Pre-built header element from App */
@@ -36,9 +149,11 @@ export interface RunScreenProps {
     sessionState: SessionState;
     /** Monitor-only mode: don't spawn, just poll status */
     monitorOnly?: boolean;
+    /** Override review mode from CLI flags (takes precedence over config) */
+    reviewMode?: 'manual' | 'auto';
     onComplete: (summary: RunSummary) => void;
     /** Called when user presses Esc to background the run */
     onBackground?: (featureName: string) => void;
     onCancel: () => void;
 }
-export declare function RunScreen({ header, featureName, projectRoot, sessionState, monitorOnly, onComplete, onBackground, onCancel, }: RunScreenProps): React.ReactElement;
+export declare function RunScreen({ header, featureName, projectRoot, sessionState, monitorOnly, reviewMode: reviewModeProp, onComplete, onBackground, onCancel, }: RunScreenProps): React.ReactElement;

package/dist/tui/screens/RunScreen.js

@@ -22,6 +22,8 @@ import { AppShell } from '../components/AppShell.js';
 import { RunCompletionSummary } from '../components/RunCompletionSummary.js';
 import { colors, theme } from '../theme.js';
 import { readLoopStatus, parseImplementationPlan, getGitBranch, formatNumber, getLoopLogPath, } from '../utils/loop-status.js';
+import { buildEnhancedRunSummary } from '../utils/build-run-summary.js';
+import { writeRunSummaryFile } from '../../utils/summary-file.js';
 import { loadConfigWithDefaults } from '../../utils/config.js';
 import { logger } from '../../utils/logger.js';
 const POLL_INTERVAL_MS = 2500;
@@ -80,7 +82,7 @@ function readLogTail(logPath, maxLines) {
         return `[Unable to read log: ${err instanceof Error ? err.message : String(err)}]`;
     }
 }
-export function RunScreen({ header, featureName, projectRoot, sessionState, monitorOnly = false, onComplete, onBackground, onCancel, }) {
+export function RunScreen({ header, featureName, projectRoot, sessionState, monitorOnly = false, reviewMode: reviewModeProp, onComplete, onBackground, onCancel, }) {
     const [status, setStatus] = useState(() => {
         try {
             return readLoopStatus(featureName);
@@ -159,7 +161,7 @@ export function RunScreen({ header, featureName, projectRoot, sessionState, moni
             const tasksDone = nextTasks.tasksDone + nextTasks.e2eDone;
             const tasksTotal = tasksDone + nextTasks.tasksPending + nextTasks.e2ePending;
             const errorTail = exitCode !== 0 ? readLogTail(logPath, ERROR_TAIL_LINES) || undefined : undefined;
-            setCompletionSummary({
+            const basicSummary = {
                 feature: featureName,
                 iterations: nextStatus.iteration,
                 maxIterations: nextStatus.maxIterations,
@@ -172,6 +174,19 @@ export function RunScreen({ header, featureName, projectRoot, sessionState, moni
                 branch: getGitBranch(projectRoot),
                 logPath,
                 errorTail,
+            };
+            let enhancedSummary;
+            try {
+                enhancedSummary = buildEnhancedRunSummary(basicSummary, projectRoot, featureName);
+            }
+            catch (err) {
+                logger.error(`Failed to build enhanced summary for ${featureName}: ${err instanceof Error ? err.message : String(err)}`);
+                enhancedSummary = basicSummary;
+            }
+            setCompletionSummary(enhancedSummary);
+            // Persist summary to JSON file (non-blocking)
+            writeRunSummaryFile(featureName, enhancedSummary).catch((err) => {
+                logger.error(`Failed to persist summary file for ${featureName}: ${err instanceof Error ? err.message : String(err)}`);
             });
         }
     }, [featureName, projectRoot, monitorOnly]);
@@ -272,7 +287,7 @@ export function RunScreen({ header, featureName, projectRoot, sessionState, moni
                     setIsStarting(false);
                     return;
                 }
-                const reviewMode = config.loop.reviewMode ?? 'manual';
+                const reviewMode = reviewModeProp ?? config.loop.reviewMode ?? 'manual';
                 if (reviewMode !== 'manual' && reviewMode !== 'auto') {
                     setError(`Invalid reviewMode '${reviewMode}'. Allowed values are 'manual' or 'auto'.`);
                     setIsStarting(false);
@@ -348,7 +363,7 @@ export function RunScreen({ header, featureName, projectRoot, sessionState, moni
                         const tasksTotal = tasksDone + latestTasks.tasksPending + latestTasks.e2ePending;
                         const exitCode = typeof code === 'number' ? code : 1;
                         const errorTail = exitCode === 0 ? undefined : readLogTail(logPath, ERROR_TAIL_LINES) || undefined;
-                        const summary = {
+                        const basicSummary = {
                             feature: featureName,
                             iterations: latestStatus.iteration,
                             maxIterations: latestStatus.maxIterations || config.loop.maxIterations,
@@ -361,8 +376,21 @@ export function RunScreen({ header, featureName, projectRoot, sessionState, moni
                             logPath,
                             errorTail,
                         };
+                        // Build enhanced summary with phases, git stats, PR/issue metadata
+                        let enhancedSummary;
+                        try {
+                            enhancedSummary = buildEnhancedRunSummary(basicSummary, projectRoot, featureName);
+                        }
+                        catch (err) {
+                            logger.error(`Failed to build enhanced summary for ${featureName}: ${err instanceof Error ? err.message : String(err)}`);
+                            enhancedSummary = basicSummary;
+                        }
                         // Show completion summary inline
-                        setCompletionSummary(summary);
+                        setCompletionSummary(enhancedSummary);
+                        // Persist summary to JSON file (non-blocking)
+                        writeRunSummaryFile(featureName, enhancedSummary).catch((err) => {
+                            logger.error(`Failed to persist summary file for ${featureName}: ${err instanceof Error ? err.message : String(err)}`);
+                        });
                     });
                 }
                 catch (spawnErr) {

package/dist/tui/utils/build-run-summary.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Build enhanced run summary from loop state and external data sources.
+ */
+import type { RunSummary } from '../screens/RunScreen.js';
+/**
+ * Build enhanced run summary from loop completion state.
+ *
+ * This function aggregates data from:
+ * - Basic loop state (iterations, tasks, tokens, exit code)
+ * - Phase timing file (/tmp/ralph-loop-<feature>.phases)
+ * - Baseline commit file (/tmp/ralph-loop-<feature>.baseline)
+ * - Git diff stats (via git-summary utilities)
+ * - PR/issue metadata (via pr-summary utilities)
+ *
+ * @param basicSummary - The minimal RunSummary constructed by RunScreen
+ * @param projectRoot - Root directory of the project
+ * @param feature - Feature name
+ * @returns Enhanced RunSummary with all available metadata
+ *
+ * Note: This function performs synchronous I/O and subprocess execution,
+ * which blocks the event loop. Callers should wrap in try-catch to handle
+ * failures gracefully.
+ */
+export declare function buildEnhancedRunSummary(basicSummary: RunSummary, projectRoot: string, feature: string): RunSummary;

package/dist/tui/utils/build-run-summary.js

@@ -0,0 +1,241 @@
+/**
+ * Build enhanced run summary from loop state and external data sources.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { logger } from '../../utils/logger.js';
+import { getCurrentCommitHash, getDiffStats } from './git-summary.js';
+import { getPrForBranch, getLinkedIssue } from './pr-summary.js';
+/**
+ * Phase ID to human-readable label mapping
+ */
+const PHASE_LABELS = {
+    planning: 'Planning',
+    implementation: 'Implementation',
+    e2e_testing: 'E2E Testing',
+    verification: 'Verification',
+    pr_review: 'PR & Review',
+};
+const VALID_PHASE_STATUSES = new Set(['success', 'skipped', 'failed']);
+/**
+ * Parse phase information from the phases file written by feature-loop.sh.
+ *
+ * Format: phase_id|status|start_timestamp|end_timestamp
+ * The parser handles duplicate phase entries defensively (last status wins,
+ * durations aggregate), though feature-loop.sh normally writes one final
+ * line per phase.
+ *
+ * @param phasesFilePath - Path to the phases file
+ * @returns Array of phase info objects
+ */
+function parsePhases(phasesFilePath) {
+    if (!existsSync(phasesFilePath)) {
+        logger.debug(`Phases file not found: ${phasesFilePath}`);
+        return [];
+    }
+    try {
+        const content = readFileSync(phasesFilePath, 'utf-8').trim();
+        if (!content) {
+            return [];
+        }
+        const lines = content.split('\n');
+        const phaseMap = new Map();
+        for (const line of lines) {
+            const parts = line.split('|');
+            if (parts.length < 4) {
+                logger.warn(`Skipping malformed phase line: ${line}`);
+                continue;
+            }
+            const [id, status, startStr, endStr] = parts;
+            // Validate status
+            if (!VALID_PHASE_STATUSES.has(status)) {
+                logger.warn(`Unknown phase status "${status}" for phase "${id}", treating as failed`);
+            }
+            const validatedStatus = VALID_PHASE_STATUSES.has(status)
+                ? status
+                : 'failed';
+            // Parse timestamps
+            const startTime = parseInt(startStr, 10) || 0;
+            const endTime = parseInt(endStr, 10) || 0;
+            // Calculate duration (end - start) in milliseconds
+            const durationMs = endTime > 0 && startTime > 0 ? (endTime - startTime) * 1000 : undefined;
+            // Get or create phase entry
+            let phase = phaseMap.get(id);
+            if (!phase) {
+                phase = {
+                    id,
+                    label: PHASE_LABELS[id] || id,
+                    status: validatedStatus,
+                    durationMs: 0,
+                };
+                phaseMap.set(id, phase);
+            }
+            // Update status (last status wins)
+            phase.status = validatedStatus;
+            // Aggregate duration
+            if (durationMs !== undefined) {
+                phase.durationMs = (phase.durationMs || 0) + durationMs;
+            }
+        }
+        return Array.from(phaseMap.values());
+    }
+    catch (err) {
+        logger.warn(`Failed to parse phases file: ${err instanceof Error ? err.message : String(err)}`);
+        return [];
+    }
+}
+/**
+ * Read baseline commit hash from the baseline file.
+ *
+ * @param baselineFilePath - Path to the baseline file
+ * @returns Short commit hash, or null if not available
+ */
+function readBaselineCommit(baselineFilePath) {
+    if (!existsSync(baselineFilePath)) {
+        logger.debug(`Baseline file not found: ${baselineFilePath}`);
+        return null;
+    }
+    try {
+        const content = readFileSync(baselineFilePath, 'utf-8').trim();
+        // Validate content looks like a hex commit hash
+        if (!/^[0-9a-f]{7,40}$/i.test(content)) {
+            logger.warn(`Baseline file ${baselineFilePath} contains invalid content: "${content.substring(0, 20)}"`);
+            return null;
+        }
+        return content.substring(0, 7) || null;
+    }
+    catch (err) {
+        logger.warn(`Failed to read baseline file: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}
+/**
+ * Build enhanced run summary from loop completion state.
+ *
+ * This function aggregates data from:
+ * - Basic loop state (iterations, tasks, tokens, exit code)
+ * - Phase timing file (/tmp/ralph-loop-<feature>.phases)
+ * - Baseline commit file (/tmp/ralph-loop-<feature>.baseline)
+ * - Git diff stats (via git-summary utilities)
+ * - PR/issue metadata (via pr-summary utilities)
+ *
+ * @param basicSummary - The minimal RunSummary constructed by RunScreen
+ * @param projectRoot - Root directory of the project
+ * @param feature - Feature name
+ * @returns Enhanced RunSummary with all available metadata
+ *
+ * Note: This function performs synchronous I/O and subprocess execution,
+ * which blocks the event loop. Callers should wrap in try-catch to handle
+ * failures gracefully.
+ */
+export function buildEnhancedRunSummary(basicSummary, projectRoot, feature) {
+    const phasesFilePath = `/tmp/ralph-loop-${feature}.phases`;
+    const baselineFilePath = `/tmp/ralph-loop-${feature}.baseline`;
+    // Parse phases and set implementation iterations from actual loop count
+    const phases = parsePhases(phasesFilePath);
+    const implPhase = phases.find((p) => p.id === 'implementation');
+    if (implPhase) {
+        implPhase.iterations = basicSummary.iterations;
+    }
+    // Calculate total duration from phases
+    let totalDurationMs;
+    if (phases.length > 0) {
+        const totalMs = phases.reduce((sum, phase) => sum + (phase.durationMs || 0), 0);
+        totalDurationMs = totalMs > 0 ? totalMs : undefined;
+    }
+    // Build iteration breakdown
+    const iterationBreakdown = {
+        total: basicSummary.iterations,
+        implementation: phases.find((p) => p.id === 'implementation')?.iterations,
+        // TODO: Detect resumes from multiple phase entries (future enhancement)
+    };
+    // Build task summary
+    const tasks = {
+        completed: basicSummary.tasksDone,
+        total: basicSummary.tasksTotal,
+    };
+    // Git changes and commits
+    const baselineCommit = readBaselineCommit(baselineFilePath);
+    const currentCommit = getCurrentCommitHash(projectRoot);
+    let changes = { available: false };
+    let commits = { available: false };
+    if (baselineCommit && currentCommit) {
+        commits = {
+            fromHash: baselineCommit,
+            toHash: currentCommit,
+            mergeType: 'none', // TODO: Detect merge type from git history
+            available: true,
+        };
+        // Get diff stats
+        const diffStats = getDiffStats(projectRoot, baselineCommit, currentCommit);
+        if (diffStats !== null) {
+            changes = {
+                totalFilesChanged: diffStats.length,
+                files: diffStats.map((stat) => ({
+                    path: stat.path,
+                    added: stat.added,
+                    removed: stat.removed,
+                })),
+                available: true,
+            };
+        }
+        else {
+            changes = { available: true }; // Git is available but diff failed
+        }
+    }
+    else if (currentCommit) {
+        // Only current commit available (no baseline)
+        commits = {
+            toHash: currentCommit,
+            available: true,
+        };
+    }
+    // PR and issue metadata
+    let pr = { available: false, created: false };
+    let issue = { available: false, linked: false };
+    if (basicSummary.branch) {
+        try {
+            const prInfo = getPrForBranch(projectRoot, basicSummary.branch);
+            if (prInfo) {
+                pr = {
+                    number: prInfo.number,
+                    url: prInfo.url,
+                    available: true,
+                    created: true,
+                };
+                // Try to get linked issue, passing prInfo to avoid redundant gh call
+                const issueInfo = getLinkedIssue(projectRoot, basicSummary.branch, prInfo);
+                if (issueInfo) {
+                    issue = {
+                        number: issueInfo.number,
+                        url: issueInfo.url,
+                        status: issueInfo.state,
+                        available: true,
+                        linked: true,
+                    };
+                }
+                else {
+                    issue = { available: true, linked: false };
+                }
+            }
+            else {
+                pr = { available: true, created: false };
+                issue = { available: true, linked: false };
+            }
+        }
+        catch (err) {
+            logger.warn(`gh CLI query failed: ${err instanceof Error ? err.message : String(err)}`);
+            // pr and issue remain { available: false } from defaults above
+        }
+    }
+    return {
+        ...basicSummary,
+        totalDurationMs,
+        iterationBreakdown,
+        tasks,
+        phases,
+        changes,
+        commits,
+        pr,
+        issue,
+    };
+}

package/dist/tui/utils/git-summary.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Git utilities for enhanced run summary.
+ */
+export interface FileDiffStat {
+    path: string;
+    added: number;
+    removed: number;
+}
+/**
+ * Get the current commit hash (HEAD).
+ *
+ * @param projectRoot - Root directory of the git repository
+ * @returns Short commit hash, or null if not available
+ */
+export declare function getCurrentCommitHash(projectRoot: string): string | null;
+/**
+ * Get diff stats between two commits.
+ *
+ * @param projectRoot - Root directory of the git repository
+ * @param fromHash - Starting commit hash
+ * @param toHash - Ending commit hash
+ * @returns Array of file diff stats, or null if not available
+ */
+export declare function getDiffStats(projectRoot: string, fromHash: string, toHash: string): FileDiffStat[] | null;

package/dist/tui/utils/git-summary.js

@@ -0,0 +1,63 @@
+/**
+ * Git utilities for enhanced run summary.
+ */
+import { execFileSync } from 'node:child_process';
+import { logger } from '../../utils/logger.js';
+/**
+ * Get the current commit hash (HEAD).
+ *
+ * @param projectRoot - Root directory of the git repository
+ * @returns Short commit hash, or null if not available
+ */
+export function getCurrentCommitHash(projectRoot) {
+    try {
+        const hash = execFileSync('git', ['rev-parse', '--short', 'HEAD'], {
+            cwd: projectRoot,
+            encoding: 'utf-8',
+            timeout: 10_000,
+        }).trim();
+        return hash || null;
+    }
+    catch (err) {
+        logger.warn(`getCurrentCommitHash failed: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}
+/**
+ * Get diff stats between two commits.
+ *
+ * @param projectRoot - Root directory of the git repository
+ * @param fromHash - Starting commit hash
+ * @param toHash - Ending commit hash
+ * @returns Array of file diff stats, or null if not available
+ */
+export function getDiffStats(projectRoot, fromHash, toHash) {
+    try {
+        const output = execFileSync('git', ['diff', '--numstat', `${fromHash}..${toHash}`], {
+            cwd: projectRoot,
+            encoding: 'utf-8',
+            timeout: 10_000,
+        }).trim();
+        if (!output) {
+            return [];
+        }
+        const stats = [];
+        const lines = output.split('\n');
+        for (const line of lines) {
+            // Format: <added>\t<removed>\t<path>
+            const parts = line.split('\t');
+            if (parts.length !== 3)
+                continue;
+            const [addedStr, removedStr, path] = parts;
+            // Binary files show '-' for added/removed
+            const added = addedStr === '-' ? 0 : parseInt(addedStr, 10) || 0;
+            const removed = removedStr === '-' ? 0 : parseInt(removedStr, 10) || 0;
+            stats.push({ path, added, removed });
+        }
+        return stats;
+    }
+    catch (err) {
+        logger.warn(`getDiffStats failed: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}

package/dist/tui/utils/input-utils.d.ts

@@ -104,6 +104,26 @@ export declare function deleteCharAfter(value: string, cursorIndex: number): Cur
  * moveCursorByWordLeft("test", 0) // => 0 (no-op at start)
  * ```
  */
+/**
+ * Deletes the word before the cursor (Ctrl+W behavior)
+ *
+ * Skips trailing whitespace, then deletes the preceding word.
+ * Uses moveCursorByWordLeft to find the word boundary.
+ *
+ * @param value - Current input value
+ * @param cursorIndex - Current cursor position
+ * @returns New value and cursor index after deletion
+ *
+ * @example
+ * ```ts
+ * deleteWordBefore("hello world", 11)
+ * // => { newValue: "hello ", newCursorIndex: 6 }
+ *
+ * deleteWordBefore("hello world", 0)
+ * // => { newValue: "hello world", newCursorIndex: 0 } (no-op at start)
+ * ```
+ */
+export declare function deleteWordBefore(value: string, cursorIndex: number): CursorManipulationResult;
 export declare function moveCursorByWordLeft(value: string, cursorIndex: number): number;
 /**
  * Moves cursor to the end of the next word (word-right navigation)

package/dist/tui/utils/input-utils.js

@@ -134,6 +134,33 @@ export function deleteCharAfter(value, cursorIndex) {
  * moveCursorByWordLeft("test", 0) // => 0 (no-op at start)
  * ```
  */
+/**
+ * Deletes the word before the cursor (Ctrl+W behavior)
+ *
+ * Skips trailing whitespace, then deletes the preceding word.
+ * Uses moveCursorByWordLeft to find the word boundary.
+ *
+ * @param value - Current input value
+ * @param cursorIndex - Current cursor position
+ * @returns New value and cursor index after deletion
+ *
+ * @example
+ * ```ts
+ * deleteWordBefore("hello world", 11)
+ * // => { newValue: "hello ", newCursorIndex: 6 }
+ *
+ * deleteWordBefore("hello world", 0)
+ * // => { newValue: "hello world", newCursorIndex: 0 } (no-op at start)
+ * ```
+ */
+export function deleteWordBefore(value, cursorIndex) {
+    if (cursorIndex <= 0) {
+        return { newValue: value, newCursorIndex: 0 };
+    }
+    const newCursorIndex = moveCursorByWordLeft(value, cursorIndex);
+    const newValue = value.slice(0, newCursorIndex) + value.slice(cursorIndex);
+    return { newValue, newCursorIndex };
+}
 export function moveCursorByWordLeft(value, cursorIndex) {
     let idx = cursorIndex;
     // Skip trailing whitespace

package/dist/tui/utils/pr-summary.d.ts

@@ -0,0 +1,34 @@
+/**
+ * PR and Issue utilities for enhanced run summary.
+ */
+export interface PrInfo {
+    number: number;
+    url: string;
+    state: string;
+    title: string;
+}
+export interface IssueInfo {
+    number: number;
+    url: string;
+    state: string;
+    title: string;
+}
+/**
+ * Get PR information for a branch.
+ *
+ * @param projectRoot - Root directory of the git repository
+ * @param branchName - Branch name to look up
+ * @returns PR info object, or null if no PR exists for this branch
+ * @throws When gh CLI is unavailable or the command fails
+ */
+export declare function getPrForBranch(projectRoot: string, branchName: string): PrInfo | null;
+/**
+ * Get linked issue for a branch by parsing the PR body for closing keywords
+ * (Closes/Fixes/Resolves #N).
+ *
+ * @param projectRoot - Root directory of the git repository
+ * @param branchName - Branch name to look up
+ * @param prInfo - Optional pre-fetched PR info to avoid redundant gh call
+ * @returns Issue info object, or null if not found or gh not available
+ */
+export declare function getLinkedIssue(projectRoot: string, branchName: string, prInfo?: PrInfo | null): IssueInfo | null;