/simplify: reuse confirmDoctorFix + take repo in PushMigratedCheckpointRefs

bf27e92·

Soph·2w ago·2 files·+8 added/-35 removed

• doctor migrate-checkpoints now reuses the existing confirmDoctorFix helper instead of a near-duplicate confirm form — picking up its context-cancellation guard (huh opens the TTY during startup regardless of ctx state) and dropping the huh/errors/context imports.
• PushMigratedCheckpointRefs takes the *git.Repository the command already opened rather than re-opening one, matching the strategy entry-point pattern and removing a redundant repo open per invocation.

Co-Authored-By: Claude Opus 4.8 (1M context) noreply@anthropic.com

Sessions

01f324c13852View transcript

Changes

2

• cmd/entire/cli

• Mdoctor_migrate.go+4/-26

• strategy

• Mmanual_commit_push.go+4/-9

1
2
3
4
5
4
5
8
6
7
8
60 unmodified lines

69
70
71
75
72
73
74
75
76
77
80
78
79
80
81
84
82
83
84
85
4 unmodified lines

90
91
92
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

package cli

import (
    context
    "errors"
    "fmt"

"charm.land/huh/v2"
    "github.com/spf13/cobra"

"github.com/entireio/cli/cmd/entire/cli/checkpoint"
60 unmodified lines

return nil
    }

confirmed, err := confirmPushMigratedRefs(ctx, len(result.Migrated))
    title := fmt.Sprintf("Push %d migrated checkpoint ref(s) now?", len(result.Migrated))
    confirmed, err := confirmDoctorFix(ctx, out, title)
    if err != nil {
        return err
    }
    if !confirmed {
        fmt.Fprintln(out, "Left queued for the next push.")
        fmt.Fprintln(out, "Refs stay queued for the next push.")
        return nil
    }

pushed, err := strategy.PushMigratedCheckpointRefs(ctx, migrateCheckpointsPushRemote)
    pushed, err := strategy.PushMigratedCheckpointRefs(ctx, repo, migrateCheckpointsPushRemote)
    if err != nil {
        return fmt.Errorf("push migrated refs: %w", err)
    }
4 unmodified lines

cmd.Flags().BoolVar(&dryRun, "dry-run", false, "Report what would be migrated without writing refs")
    return cmd
}

// confirmPushMigratedRefs prompts whether to push the migrated refs now. A user
// abort (or cancelled context) is treated as "no", not an error.
func confirmPushMigratedRefs(ctx context.Context, count int) (bool, error) {
    var confirmed bool
    form := NewAccessibleForm(
        huh.NewGroup(
            huh.NewConfirm().
                Title(fmt.Sprintf("Push %d migrated checkpoint ref(s) now?", count)).
                Value(&confirmed),
            ),
        )
    if err := form.RunWithContext(ctx); err != nil {
        if errors.Is(err, huh.ErrUserAborted) || errors.Is(err, context.Canceled) {
            return false, nil
        }
        return false, fmt.Errorf("prompt failed: %w", err)
    }
    return confirmed, nil
}

Mcmd/entire/cli/doctor_migrate.go+4/-26

172 unmodified lines

173
174
175
176
177
178
179
176
177
178
179
180
181
182
183
184
185
186
187
188
184
185
186

172 unmodified lines

// PushMigratedCheckpointRefs pushes any queued checkpoint refs to the configured
// checkpoint remote, surfacing errors (unlike the fail-soft pre-push path). It is
// the opt-in "push now" invoked by the checkpoint migration command. Returns the
// number of refs pushed. A no-op (0, nil) when pushing is disabled or the queue
// is empty.
func PushMigratedCheckpointRefs(ctx context.Context, remote string) (int, error) {
// the opt-in "push now" invoked by the checkpoint migration command; the caller
// owns the repo. Returns the number of refs pushed — a no-op (0, nil) when
// pushing is disabled or the queue is empty.
func PushMigratedCheckpointRefs(ctx context.Context, repo *git.Repository, remote string) (int, error) {
    ps := resolvePushSettings(ctx, remote)
    if ps.pushDisabled {
        return 0, nil
    }
    repo, err := OpenRepository(ctx)
    if err != nil {
        return 0, fmt.Errorf("open repository: %w", err)
    }
    defer repo.Close()
    return flushCheckpointRefsQueue(ctx, repo, ps.pushTarget())
}

Mcmd/entire/cli/strategy/manual_commit_push.go+4/-9