Merge pull request #1110 from entireio/migration-completion-output

Checkpoints v2 migration: Keep user in the loop after the progress bar completes

Author: computermode

cmd/entire/cli/explain.go

@@ -377,7 +377,7 @@ func runExplain(ctx context.Context, w, errW io.Writer, sessionID, commitRef, ch
 func runExplainAuto(ctx context.Context, w, errW io.Writer, target string, noPager, verbose, full, rawTranscript, generate, force, searchAll bool) error {
 	stop := startSpinner(errW, "Loading checkpoints")
 	lookup, lookupErr := newExplainCheckpointLookup(ctx)
-	stop("")
+	stop(false)
 	if generate {
 		if err := runExplainAutoAmbiguityGuard(ctx, target, lookup, lookupErr); err != nil {
 			return err
@@ -524,7 +524,7 @@ func runExplainCheckpointWithLookup(ctx context.Context, w, errW io.Writer, chec
 				v2OK = true
 			}
 		}
-		stop("")
+		stop(false)
 		if v1Err == nil || v2OK {
 			if freshLookup, freshErr := newExplainCheckpointLookup(ctx); freshErr == nil {
 				lookup = freshLookup
@@ -586,14 +586,14 @@ func runExplainCheckpointWithLookup(ctx context.Context, w, errW io.Writer, chec
 
 	resolvedReader, summary, content, err := loadCheckpointForExplain(ctx, errW, lookup, fullCheckpointID, full, generate, rawTranscript)
 	if err != nil {
-		stopLoad("")
+		stopLoad(false)
 		return err
 	}
 	v2Reader, isCheckpointsV2 := resolvedReader.(*checkpoint.V2GitStore)
 
 	// Handle summary generation — uses raw transcript.
 	if generate {
-		stopLoad("") // generation prints its own progress to w/errW
+		stopLoad(false) // generation prints its own progress to w/errW
 		if err := generateCheckpointSummary(ctx, w, errW, lookup.v1Store, lookup.v2Store, fullCheckpointID, summary, content, force); err != nil {
 			return err
 		}
@@ -606,14 +606,14 @@ func runExplainCheckpointWithLookup(ctx context.Context, w, errW io.Writer, chec
 			content, err = readLatestSessionContentForExplain(ctx, resolvedReader, fullCheckpointID, summary)
 		}
 		if err != nil {
-			stopLoad("")
+			stopLoad(false)
 			return fmt.Errorf("failed to reload checkpoint: %w", err)
 		}
 	}
 
 	// Handle raw transcript output
 	if rawTranscript {
-		stopLoad("")
+		stopLoad(false)
 		rawLog, _, rawErr := checkpoint.ResolveRawSessionLogForCheckpoint(ctx, fullCheckpointID, lookup.v1Store, lookup.v2Store, lookup.preferCheckpointsV2)
 		if rawErr != nil {
 			return fmt.Errorf("failed to read raw transcript: %w", rawErr)
@@ -646,7 +646,7 @@ func runExplainCheckpointWithLookup(ctx context.Context, w, errW io.Writer, chec
 
 	// Format and output. Stop spinner BEFORE any write to w to keep stderr
 	// frames and stdout content from interleaving.
-	stopLoad("")
+	stopLoad(false)
 	output := formatCheckpointOutput(summary, content, fullCheckpointID, associatedCommits, author, verbose, full, w)
 	outputExplainContent(w, output, noPager)
 	return nil

cmd/entire/cli/migrate.go

@@ -102,11 +102,14 @@ func runMigrateCheckpointsV2(ctx context.Context, cmd *cobra.Command, force bool
 	// AggregateTranscriptTimestamps in the packer.
 	var repairResult *strategy.RepairV2GenerationMetadataResult
 	if len(freshlyPackedRefs) > 0 {
+		stopRepair := startSpinner(cmd.ErrOrStderr(), "Repairing archived generation metadata")
 		var repairErr error
 		repairResult, repairErr = strategy.RepairV2GenerationMetadata(ctx, freshlyPackedRefs)
 		if repairErr != nil {
+			stopRepair(false)
 			return fmt.Errorf("failed to repair archived v2 generation metadata: %w", repairErr)
 		}
+		stopRepair(true)
 		printV2GenerationRepairResult(out, cmd.ErrOrStderr(), repairResult)
 	}
 
@@ -256,9 +259,13 @@ func migrateCheckpointsV2(ctx context.Context, repo *git.Repository, v1Store *ch
 		progress.Increment()
 	}
 
+	progress.Finish()
+	stopFinalize := startSpinner(progressOut, "Packing migrated raw transcripts")
 	if err := packer.finalize(ctx, !fullCurrentExistsBefore); err != nil {
+		stopFinalize(false)
 		return result, packer.writtenRefs, fmt.Errorf("failed to pack migrated raw transcripts: %w", err)
 	}
+	stopFinalize(true)
 
 	return result, packer.writtenRefs, nil
 }

cmd/entire/cli/migrate_test.go

@@ -425,7 +425,7 @@ func TestMigrateCheckpointsV2_ForceOverwritesExisting(t *testing.T) {
 	require.NoError(t, err)
 	assert.Equal(t, 1, result3.migrated)
 	assert.Equal(t, 0, result3.skipped)
-	assert.Empty(t, stdout.String())
+	assert.Equal(t, "✓ Packing migrated raw transcripts\n", stdout.String())
 
 	// Verify checkpoint still readable in v2
 	summary, readErr := v2Store.ReadCommitted(context.Background(), cpID)
@@ -580,7 +580,7 @@ func TestMigrateCmd_RepairsArchivedGenerationMetadata(t *testing.T) {
 
 	require.NoError(t, cmd.Execute())
 	assert.Contains(t, stdout.String(), "Archived generation metadata repair: 1 repaired")
-	assert.Empty(t, stderr.String())
+	assert.Equal(t, "✓ Packing migrated raw transcripts\n✓ Repairing archived generation metadata\n", stderr.String())
 
 	v2Store := checkpoint.NewV2GitStore(repo, migrateRemoteName)
 	gen, genErr := v2Store.ReadGenerationFromRef(plumbing.ReferenceName(paths.V2FullRefPrefix + "0000000000007"))
@@ -1129,7 +1129,7 @@ func TestMigrateCheckpointsV2_CompactionSkipped(t *testing.T) {
 	require.NoError(t, migrateErr)
 	assert.Equal(t, 1, result.migrated)
 	assert.Equal(t, 1, result.compactTranscriptSkipped)
-	assert.Empty(t, stdout.String())
+	assert.Equal(t, "✓ Packing migrated raw transcripts\n", stdout.String())
 }
 
 func TestMigrateCheckpointsV2_TaskCheckpoint(t *testing.T) {

cmd/entire/cli/progress.go

@@ -22,19 +22,15 @@ const (
 )
 
 // startSpinner prints msg followed by an animated spinner to w when the
-// operation takes longer than spinnerInitialDelay. Returns a stop function
-// that clears the spinner line and prints suffix (with a newline) if
-// non-empty. Fast operations that call stop before the initial delay
-// elapses produce no output at all.
-//
-// When w is not a terminal (CI, redirected output, agent subprocess), the
-// spinner and the suppression message are both omitted — non-interactive
-// callers get clean output without progress chatter.
-func startSpinner(w io.Writer, msg string) func(suffix string) {
+// operation takes longer than spinnerInitialDelay. stop(true) leaves
+// "✓ msg" on the line; stop(false) erases the line and writes nothing.
+// On non-terminal writers the animation is omitted but stop(true) still
+// prints the completion line.
+func startSpinner(w io.Writer, msg string) func(success bool) {
 	if !interactive.IsTerminalWriter(w) {
-		return func(suffix string) {
-			if suffix != "" {
-				fmt.Fprintln(w, suffix)
+		return func(success bool) {
+			if success {
+				fmt.Fprintf(w, "✓ %s\n", msg)
 			}
 		}
 	}
@@ -63,25 +59,25 @@ func startSpinner(w io.Writer, msg string) func(suffix string) {
 			}
 		}
 	}()
-	return func(suffix string) {
+	return func(success bool) {
 		close(done)
 		<-stopped
-		// \r\033[K is a no-op on a line that was never drawn; on a drawn
-		// line it returns the cursor and clears it.
-		fmt.Fprint(w, "\r\033[K")
-		if suffix != "" {
-			fmt.Fprintln(w, suffix)
+		if success {
+			fmt.Fprintf(w, "\r\033[K✓ %s\n", msg)
+			return
 		}
+		fmt.Fprint(w, "\r\033[K")
 	}
 }
 
 type progressBar struct {
-	w       io.Writer
-	label   string
-	total   int
-	current int
-	width   int
-	enabled bool
+	w        io.Writer
+	label    string
+	total    int
+	current  int
+	width    int
+	enabled  bool
+	finished bool
 }
 
 func startProgressBar(w io.Writer, label string, total int) *progressBar {
@@ -112,7 +108,12 @@ func (p *progressBar) Increment() {
 }
 
 func (p *progressBar) Finish() {
-	if !p.enabled {
+	if !p.enabled || p.finished {
+		return
+	}
+	p.finished = true
+	if p.current >= p.total {
+		fmt.Fprintln(p.w)
 		return
 	}
 	fmt.Fprint(p.w, "\r\033[K")