@meistrari/tela-cli 0.7.0 → 0.7.4

package/src/commands/feedback.ts

@@ -1,701 +0,0 @@
-import { basename } from 'node:path'
-import type { AgentFeedbackItem, TelaCliConfig } from '../types.ts'
-import { fetchCommitFeedback, fetchRepositoryLookup } from '../agent-api.ts'
-import {
-    ensureConfigInteractive,
-    type Option,
-    type PromptModule as ConfigPromptModule,
-} from '../config.ts'
-import { createUserFacingError } from '../errors.ts'
-import { getDiffStatAgainstHead, getHeadCommitHash, getOriginUrl } from '../git.ts'
-import { CommandError, commandExists, runInteractiveCommand } from '../process.ts'
-
-export interface ConfirmOptions {
-    message: string
-    active?: string
-    inactive?: string
-    initialValue?: boolean
-}
-
-export interface GroupMultiSelectOptions<T> {
-    message: string
-    options: Record<string, Array<Option<T>>>
-    cursorAt?: T
-}
-
-export interface PromptModule extends ConfigPromptModule {
-    log: {
-        success(message: string): void
-    }
-    note(message: string, title?: string): void
-    confirm(options: ConfirmOptions): Promise<boolean | symbol>
-    groupMultiselect<T>(options: GroupMultiSelectOptions<T>): Promise<T[] | symbol>
-}
-
-export interface FeedbackCommandFlags {
-    list?: boolean
-    apply?: 'all' | 'select'
-}
-
-export interface FeedbackEntry {
-    id: string
-    number: number
-    feedback: AgentFeedbackItem
-    actionable: boolean
-}
-
-export interface FeedbackData {
-    repoRoot: string
-    organizationName: string
-    repository: string
-    commitHash: string
-    entries: FeedbackEntry[]
-    actionableEntries: FeedbackEntry[]
-}
-
-export type FeedbackEmptyState = 'none' | 'no_feedback' | 'informational_only'
-export type FeedbackSelectionMode = 'list' | 'all' | 'select' | 'default'
-
-export interface FeedbackSummary {
-    organizationName: string
-    repository: string
-    commitHash: string
-    totalFeedbacks: number
-    actionableCount: number
-    informationalCount: number
-}
-
-export interface FeedbackGroupedEntries {
-    actionable: FeedbackEntry[]
-    informational: FeedbackEntry[]
-}
-
-export interface FeedbackReviewModel {
-    summary: FeedbackSummary
-    groupedEntries: FeedbackGroupedEntries
-    emptyState: FeedbackEmptyState
-}
-
-export interface FeedbackRunResult {
-    ok: true
-    organizationName: string
-    repository: string
-    commitHash: string
-    summary: FeedbackSummary
-    emptyState: FeedbackEmptyState
-    selectionMode: FeedbackSelectionMode
-    feedbacks: Array<{
-        id: string
-        number: number
-        status: AgentFeedbackItem['status']
-        reason: string
-        suggestion: string
-        actionable: boolean
-    }>
-    selectedIds?: string[]
-    launchedClaude: boolean
-    diffStat?: string
-    nextActions: string[]
-}
-
-export interface RunFeedbackCommandOptions extends FeedbackCommandFlags {
-    cwd?: string
-    prompts: PromptModule
-    ensureConfigInteractive?: typeof ensureConfigInteractive
-    fetchRepositoryLookup?: typeof fetchRepositoryLookup
-    fetchCommitFeedback?: typeof fetchCommitFeedback
-    getOriginUrl?: typeof getOriginUrl
-    getHeadCommitHash?: typeof getHeadCommitHash
-    getDiffStatAgainstHead?: typeof getDiffStatAgainstHead
-    commandExists?: typeof commandExists
-    runInteractiveCommand?: typeof runInteractiveCommand
-}
-
-function promptValue<T>(value: T | symbol): T {
-    return value as T
-}
-
-function truncate(value: string, maxLength: number): string {
-    if (value.length <= maxLength) {
-        return value
-    }
-
-    return `${value.slice(0, Math.max(0, maxLength - 1)).trimEnd()}...`
-}
-
-function firstMeaningfulLine(value: string): string {
-    return value
-        .split(/\r?\n/)
-        .map(line => line.trim())
-        .find(Boolean) ?? ''
-}
-
-function parseRepositoryNameFromOrigin(originUrl: string): string | null {
-    const trimmed = originUrl.trim()
-    if (!trimmed) {
-        return null
-    }
-
-    if (trimmed.includes('://')) {
-        try {
-            const url = new URL(trimmed)
-            const segments = url.pathname.split('/').filter(Boolean)
-            const lastSegment = segments.at(-1)
-            return lastSegment ? lastSegment.replace(/\.git$/i, '') : null
-        }
-        catch {
-            return null
-        }
-    }
-
-    const scpMatch = trimmed.match(/^[^@]+@[^:]+:(.+)$/)
-    if (scpMatch?.[1]) {
-        return basename(scpMatch[1]).replace(/\.git$/i, '') || null
-    }
-
-    return basename(trimmed).replace(/\.git$/i, '') || null
-}
-
-async function resolveRepositoryName(
-    cwd: string,
-    getOriginUrlFn: typeof getOriginUrl,
-): Promise<string> {
-    try {
-        const originUrl = await getOriginUrlFn(cwd)
-        return parseRepositoryNameFromOrigin(originUrl) ?? basename(cwd)
-    }
-    catch {
-        return basename(cwd)
-    }
-}
-
-function buildFeedbackEntries(feedbacks: AgentFeedbackItem[]): FeedbackEntry[] {
-    return feedbacks.map((feedback, index) => ({
-        id: String(index + 1),
-        number: index + 1,
-        feedback,
-        actionable: feedback.suggestion.trim().length > 0,
-    }))
-}
-
-export function getFeedbackEntryTitle(entry: FeedbackEntry): string {
-    return firstMeaningfulLine(entry.feedback.suggestion)
-        || firstMeaningfulLine(entry.feedback.reason)
-        || `Feedback #${entry.number}`
-}
-
-export function describeFeedbackSelectionMode(mode: FeedbackSelectionMode): string {
-    switch (mode) {
-        case 'list':
-            return 'Review only'
-        case 'all':
-            return 'Apply all actionable suggestions'
-        case 'select':
-            return 'Choose actionable suggestions'
-        case 'default':
-            return 'Review and edit the actionable selection'
-    }
-}
-
-export function describeFeedbackEmptyState(emptyState: FeedbackEmptyState): string {
-    switch (emptyState) {
-        case 'no_feedback':
-            return 'No feedback was returned for this commit.'
-        case 'informational_only':
-            return 'Only informational feedback is available for this commit.'
-        case 'none':
-            return 'Actionable feedback is available.'
-    }
-}
-
-export function getFeedbackSelectionMode(options: FeedbackCommandFlags): FeedbackSelectionMode {
-    if (options.list) {
-        return 'list'
-    }
-
-    if (options.apply === 'all') {
-        return 'all'
-    }
-
-    if (options.apply === 'select') {
-        return 'select'
-    }
-
-    return 'default'
-}
-
-export function buildFeedbackReviewModel(data: FeedbackData): FeedbackReviewModel {
-    const groupedEntries: FeedbackGroupedEntries = {
-        actionable: data.entries.filter(entry => entry.actionable),
-        informational: data.entries.filter(entry => !entry.actionable),
-    }
-    const summary: FeedbackSummary = {
-        organizationName: data.organizationName,
-        repository: data.repository,
-        commitHash: data.commitHash,
-        totalFeedbacks: data.entries.length,
-        actionableCount: groupedEntries.actionable.length,
-        informationalCount: groupedEntries.informational.length,
-    }
-
-    return {
-        summary,
-        groupedEntries,
-        emptyState: summary.totalFeedbacks === 0
-            ? 'no_feedback'
-            : summary.actionableCount === 0
-                ? 'informational_only'
-                : 'none',
-    }
-}
-
-function formatFeedbackEntryLine(entry: FeedbackEntry): string {
-    return `#${entry.number} [${entry.feedback.status}] ${truncate(getFeedbackEntryTitle(entry), 88)}`
-}
-
-export function formatFeedbackSummary(summary: FeedbackSummary, emptyState: FeedbackEmptyState): string {
-    return [
-        `Organization: ${summary.organizationName}`,
-        `Repository: ${summary.repository}`,
-        `Commit: ${summary.commitHash}`,
-        `Feedbacks: ${summary.totalFeedbacks}`,
-        `Actionable suggestions: ${summary.actionableCount}`,
-        `Informational items: ${summary.informationalCount}`,
-        `Review state: ${describeFeedbackEmptyState(emptyState)}`,
-    ].join('\n')
-}
-
-export function formatFeedbackCatalog(entries: FeedbackEntry[]): string {
-    if (entries.length === 0) {
-        return 'No feedback returned for this commit.'
-    }
-
-    const groupedEntries = {
-        actionable: entries.filter(entry => entry.actionable),
-        informational: entries.filter(entry => !entry.actionable),
-    }
-    const lines: string[] = []
-
-    if (groupedEntries.actionable.length > 0) {
-        lines.push('Actionable')
-        for (const entry of groupedEntries.actionable) {
-            lines.push(`- ${formatFeedbackEntryLine(entry)}`)
-            lines.push(`  reason: ${entry.feedback.reason || '<empty>'}`)
-        }
-    }
-
-    if (groupedEntries.informational.length > 0) {
-        if (lines.length > 0) {
-            lines.push('')
-        }
-
-        lines.push('Informational')
-        for (const entry of groupedEntries.informational) {
-            lines.push(`- ${formatFeedbackEntryLine(entry)}`)
-            lines.push(`  reason: ${entry.feedback.reason || '<empty>'}`)
-        }
-    }
-
-    return lines.join('\n')
-}
-
-function buildFeedbackSelectionGroups(entries: FeedbackEntry[]): Record<string, Array<Option<string>>> {
-    const groupedEntries = {
-        actionable: entries.filter(entry => entry.actionable),
-        informational: entries.filter(entry => !entry.actionable),
-    }
-    const groups: Record<string, Array<Option<string>>> = {}
-
-    if (groupedEntries.actionable.length > 0) {
-        groups.Actionable = groupedEntries.actionable.map(entry => ({
-            value: entry.id,
-            label: `#${entry.number} ${truncate(getFeedbackEntryTitle(entry), 80)}`,
-            hint: truncate(entry.feedback.reason || '<empty>', 60),
-        }))
-    }
-
-    if (groupedEntries.informational.length > 0) {
-        groups.Informational = groupedEntries.informational.map(entry => ({
-            value: entry.id,
-            label: `#${entry.number} ${truncate(getFeedbackEntryTitle(entry), 80)}`,
-            hint: truncate(entry.feedback.reason || 'No suggestion text', 60),
-        }))
-    }
-
-    return groups
-}
-
-export function formatFeedbackSelectionSummary(input: {
-    selectionMode: FeedbackSelectionMode
-    selectedFeedbacks: FeedbackEntry[]
-}): string {
-    return [
-        `Mode: ${describeFeedbackSelectionMode(input.selectionMode)}`,
-        `Selected suggestions: ${input.selectedFeedbacks.length}`,
-        `Selected IDs: ${input.selectedFeedbacks.length > 0 ? input.selectedFeedbacks.map(entry => `#${entry.number}`).join(', ') : '<none>'}`,
-        ...input.selectedFeedbacks.map(entry => `- ${formatFeedbackEntryLine(entry)}`),
-    ].join('\n')
-}
-
-export function formatFeedbackOutcomeSummary(input: {
-    commitHash: string
-    selectionMode: FeedbackSelectionMode
-    selectedFeedbacks: FeedbackEntry[]
-}): string {
-    return [
-        `Commit: ${input.commitHash}`,
-        `Mode: ${describeFeedbackSelectionMode(input.selectionMode)}`,
-        `Selected suggestions: ${input.selectedFeedbacks.length}`,
-        ...input.selectedFeedbacks.map(entry => `- ${formatFeedbackEntryLine(entry)}`),
-    ].join('\n')
-}
-
-export function buildClaudeFeedbackPrompt(input: {
-    repoRoot: string
-    organizationName: string
-    repository: string
-    commitHash: string
-    selectedFeedbacks: FeedbackEntry[]
-}): string {
-    const feedbackBlocks = input.selectedFeedbacks
-        .map(entry => [
-            `Feedback #${entry.number}`,
-            `Status: ${entry.feedback.status}`,
-            `Reason: ${entry.feedback.reason}`,
-            `Suggestion: ${entry.feedback.suggestion}`,
-        ].join('\n'))
-        .join('\n\n')
-
-    return [
-        'You are working inside a local git repository.',
-        '',
-        `Repository root: ${input.repoRoot}`,
-        `Repository: ${input.organizationName}/${input.repository}`,
-        `Feedback commit hash: ${input.commitHash}`,
-        '',
-        'Address the selected feedback suggestions below.',
-        '- Inspect the repository and make the code changes that best address the selected suggestions.',
-        '- Run relevant verification when practical and mention what you checked.',
-        '- If a suggestion should not be implemented as written, explain why in your final summary.',
-        '- Do not create a git commit or push changes unless explicitly asked.',
-        '',
-        'Selected feedback:',
-        feedbackBlocks,
-    ].join('\n')
-}
-
-function serializeFeedbackEntries(entries: FeedbackEntry[]): FeedbackRunResult['feedbacks'] {
-    return entries.map(entry => ({
-        id: entry.id,
-        number: entry.number,
-        status: entry.feedback.status,
-        reason: entry.feedback.reason,
-        suggestion: entry.feedback.suggestion,
-        actionable: entry.actionable,
-    }))
-}
-
-export function buildFeedbackNextActions(input: {
-    launchedClaude: boolean
-    actionableCount: number
-    emptyState: FeedbackEmptyState
-}): string[] {
-    if (!input.launchedClaude) {
-        if (input.emptyState === 'no_feedback') {
-            return ['Push a feedback-producing commit or choose another checkout, then rerun `tela feedback --list`.']
-        }
-
-        if (input.emptyState === 'informational_only') {
-            return [
-                'Review the informational feedback above for context.',
-                'Rerun `tela feedback --list` after a later push if you want a fresh snapshot.',
-            ]
-        }
-
-        return input.actionableCount > 0
-            ? ['Run `tela feedback --apply all` or `tela feedback --apply select` when you are ready to address suggestions.']
-            : ['No follow-up action is required for this commit.']
-    }
-
-    return [
-        'Review the local diff before committing the Claude changes.',
-        'Run `tela push` after the feedback-driven changes look correct.',
-        'Rerun `tela feedback --list` after the next push if you want another feedback snapshot.',
-    ]
-}
-
-export function hasActionableFeedback(entries: FeedbackEntry[]): boolean {
-    return entries.some(entry => entry.actionable)
-}
-
-export function buildFeedbackRunResult(input: {
-    data: FeedbackData
-    selectionMode: FeedbackSelectionMode
-    launchedClaude: boolean
-    selectedFeedbacks?: FeedbackEntry[]
-    diffStat?: string
-}): FeedbackRunResult {
-    const review = buildFeedbackReviewModel(input.data)
-    const selectedFeedbacks = input.selectedFeedbacks ?? []
-
-    return {
-        ok: true,
-        organizationName: input.data.organizationName,
-        repository: input.data.repository,
-        commitHash: input.data.commitHash,
-        summary: review.summary,
-        emptyState: review.emptyState,
-        selectionMode: input.selectionMode,
-        feedbacks: serializeFeedbackEntries(input.data.entries),
-        selectedIds: selectedFeedbacks.length > 0 ? selectedFeedbacks.map(entry => entry.id) : undefined,
-        launchedClaude: input.launchedClaude,
-        diffStat: input.diffStat,
-        nextActions: buildFeedbackNextActions({
-            launchedClaude: input.launchedClaude,
-            actionableCount: review.summary.actionableCount,
-            emptyState: review.emptyState,
-        }),
-    }
-}
-
-export async function loadFeedbackData(options: {
-    cwd?: string
-    config: TelaCliConfig
-    fetchRepositoryLookup?: typeof fetchRepositoryLookup
-    fetchCommitFeedback?: typeof fetchCommitFeedback
-    getOriginUrl?: typeof getOriginUrl
-    getHeadCommitHash?: typeof getHeadCommitHash
-}): Promise<FeedbackData> {
-    const repoRoot = options.cwd ?? process.cwd()
-    const fetchRepositoryLookupFn = options.fetchRepositoryLookup ?? fetchRepositoryLookup
-    const fetchCommitFeedbackFn = options.fetchCommitFeedback ?? fetchCommitFeedback
-    const getOriginUrlFn = options.getOriginUrl ?? getOriginUrl
-    const getHeadCommitHashFn = options.getHeadCommitHash ?? getHeadCommitHash
-
-    const derivedRepository = await resolveRepositoryName(repoRoot, getOriginUrlFn)
-    const repoDetails = await fetchRepositoryLookupFn(derivedRepository, options.config)
-    const commitHash = await getHeadCommitHashFn(repoRoot)
-    const feedbackResponse = await fetchCommitFeedbackFn(
-        repoDetails.organization.name,
-        repoDetails.agentRepo.repository,
-        commitHash,
-        options.config,
-    )
-
-    const entries = buildFeedbackEntries(feedbackResponse.feedbacks)
-    const actionableEntries = entries.filter(entry => entry.actionable)
-
-    return {
-        repoRoot,
-        organizationName: repoDetails.organization.name,
-        repository: repoDetails.agentRepo.repository,
-        commitHash: feedbackResponse.commitHash,
-        entries,
-        actionableEntries,
-    }
-}
-
-export async function launchFeedbackClaude(options: {
-    repoRoot: string
-    prompt: string
-    runInteractiveCommand?: typeof runInteractiveCommand
-}): Promise<void> {
-    const runInteractiveCommandFn = options.runInteractiveCommand ?? runInteractiveCommand
-
-    try {
-        await runInteractiveCommandFn(['claude', options.prompt], { cwd: options.repoRoot })
-    }
-    catch (error) {
-        if (error instanceof CommandError) {
-            const stdout = error.result.stdout.trim()
-            const stderr = error.result.stderr.trim()
-            throw createUserFacingError({
-                code: 'feedback_claude_failed',
-                summary: 'Claude exited before completing the feedback review.',
-                details: stderr || stdout || `Claude exited with code ${error.result.exitCode}.`,
-                fixes: ['Review the Claude session output above, then rerun `tela feedback` when you are ready.'],
-                evidence: [
-                    `Command: ${error.result.command.join(' ')}`,
-                    stdout ? `stdout: ${stdout}` : '',
-                    stderr ? `stderr: ${stderr}` : '',
-                ].filter(Boolean),
-                cause: error,
-            })
-        }
-
-        throw error
-    }
-}
-
-export async function runFeedbackCommand(options: RunFeedbackCommandOptions): Promise<FeedbackRunResult> {
-    const repoRoot = options.cwd ?? process.cwd()
-    const prompts = options.prompts
-    const ensureConfig = options.ensureConfigInteractive ?? ensureConfigInteractive
-    const fetchRepositoryLookupFn = options.fetchRepositoryLookup ?? fetchRepositoryLookup
-    const fetchCommitFeedbackFn = options.fetchCommitFeedback ?? fetchCommitFeedback
-    const getOriginUrlFn = options.getOriginUrl ?? getOriginUrl
-    const getHeadCommitHashFn = options.getHeadCommitHash ?? getHeadCommitHash
-    const getDiffStatAgainstHeadFn = options.getDiffStatAgainstHead ?? getDiffStatAgainstHead
-    const commandExistsFn = options.commandExists ?? commandExists
-    const runInteractiveCommandFn = options.runInteractiveCommand ?? runInteractiveCommand
-    const selectionMode = getFeedbackSelectionMode(options)
-
-    const config: TelaCliConfig = await ensureConfig()
-    const data = await loadFeedbackData({
-        cwd: repoRoot,
-        config,
-        fetchRepositoryLookup: fetchRepositoryLookupFn,
-        fetchCommitFeedback: fetchCommitFeedbackFn,
-        getOriginUrl: getOriginUrlFn,
-        getHeadCommitHash: getHeadCommitHashFn,
-    })
-    const review = buildFeedbackReviewModel(data)
-    const feedbackEntries = data.entries
-    const actionableFeedbacks = data.actionableEntries
-
-    prompts.note(formatFeedbackSummary(review.summary, review.emptyState), 'Feedback summary')
-    prompts.note(formatFeedbackCatalog(feedbackEntries), 'Feedback catalog')
-
-    if (selectionMode === 'list' || review.emptyState !== 'none') {
-        return buildFeedbackRunResult({
-            data,
-            selectionMode,
-            launchedClaude: false,
-        })
-    }
-
-    if (!await commandExistsFn('claude')) {
-        throw createUserFacingError({
-            code: 'feedback_claude_missing',
-            summary: 'Claude CLI is not available on PATH.',
-            fixes: ['Install the Claude CLI before using `tela feedback --apply ...`.'],
-        })
-    }
-
-    let selectedFeedbacks = selectionMode === 'select' ? [] : actionableFeedbacks
-    if (selectionMode === 'select') {
-        const selectedIds = await prompts.groupMultiselect({
-            message: 'Select the suggestions to address with Claude',
-            options: buildFeedbackSelectionGroups(feedbackEntries),
-            cursorAt: actionableFeedbacks[0]?.id,
-        })
-
-        if (prompts.isCancel(selectedIds)) {
-            prompts.cancel('Feedback selection cancelled.')
-            return buildFeedbackRunResult({
-                data,
-                selectionMode,
-                launchedClaude: false,
-            })
-        }
-
-        const selectedIdSet = new Set(promptValue(selectedIds))
-        selectedFeedbacks = actionableFeedbacks.filter(entry => selectedIdSet.has(entry.id))
-    }
-    else if (selectionMode === 'default') {
-        const selectionChoice = await prompts.select<'all' | 'manual' | 'cancel'>({
-            message: 'Which suggestions do you want to review with Claude?',
-            options: [
-                { value: 'all', label: 'Apply all actionable suggestions' },
-                { value: 'manual', label: 'Choose suggestions individually' },
-                { value: 'cancel', label: 'Finish review without launching Claude' },
-            ],
-            initialValue: 'all',
-        })
-
-        if (prompts.isCancel(selectionChoice) || promptValue(selectionChoice) === 'cancel') {
-            prompts.cancel('Feedback application cancelled.')
-            return buildFeedbackRunResult({
-                data,
-                selectionMode,
-                launchedClaude: false,
-            })
-        }
-
-        if (promptValue(selectionChoice) === 'manual') {
-            const selectedIds = await prompts.groupMultiselect({
-                message: 'Select the suggestions to address with Claude',
-                options: buildFeedbackSelectionGroups(feedbackEntries),
-                cursorAt: actionableFeedbacks[0]?.id,
-            })
-
-            if (prompts.isCancel(selectedIds)) {
-                prompts.cancel('Feedback selection cancelled.')
-                return buildFeedbackRunResult({
-                    data,
-                    selectionMode,
-                    launchedClaude: false,
-                })
-            }
-
-            const selectedIdSet = new Set(promptValue(selectedIds))
-            selectedFeedbacks = actionableFeedbacks.filter(entry => selectedIdSet.has(entry.id))
-        }
-    }
-
-    prompts.note(formatFeedbackSelectionSummary({
-        selectionMode,
-        selectedFeedbacks,
-    }), 'Selection summary')
-
-    if (selectedFeedbacks.length === 0) {
-        prompts.cancel('Feedback review finished without launching Claude.')
-        return buildFeedbackRunResult({
-            data,
-            selectionMode,
-            launchedClaude: false,
-        })
-    }
-
-    const prompt = buildClaudeFeedbackPrompt({
-        repoRoot: data.repoRoot,
-        organizationName: data.organizationName,
-        repository: data.repository,
-        commitHash: data.commitHash,
-        selectedFeedbacks,
-    })
-
-    prompts.note(prompt, 'Claude task')
-
-    if (selectionMode === 'default') {
-        const confirmation = await prompts.confirm({
-            message: `Launch Claude to address ${selectedFeedbacks.length} suggestion${selectedFeedbacks.length === 1 ? '' : 's'}?`,
-            active: 'apply',
-            inactive: 'cancel',
-            initialValue: true,
-        })
-
-        if (prompts.isCancel(confirmation) || !promptValue(confirmation)) {
-            prompts.cancel('Feedback application cancelled.')
-            return buildFeedbackRunResult({
-                data,
-                selectionMode,
-                launchedClaude: false,
-                selectedFeedbacks,
-            })
-        }
-    }
-
-    await launchFeedbackClaude({
-        repoRoot: data.repoRoot,
-        prompt,
-        runInteractiveCommand: runInteractiveCommandFn,
-    })
-
-    const diffStat = (await getDiffStatAgainstHeadFn(repoRoot)) || '<no local diff detected>'
-    prompts.note(formatFeedbackOutcomeSummary({
-        commitHash: data.commitHash,
-        selectionMode,
-        selectedFeedbacks,
-    }), 'Review outcome')
-    prompts.note(diffStat, 'Local diff summary')
-    prompts.log.success(`Claude finished reviewing ${selectedFeedbacks.length} suggestion${selectedFeedbacks.length === 1 ? '' : 's'}`)
-
-    return buildFeedbackRunResult({
-        data,
-        selectionMode,
-        launchedClaude: true,
-        selectedFeedbacks,
-        diffStat,
-    })
-}