pretty needs tty & add pretty for process

Author: skoowoo

cmd/ask.go

@@ -53,7 +53,7 @@ func runAsk(cmd *cobra.Command, args []string) error {
 
 	var stopSpinner chan struct{}
 	var spinnerDone chan struct{}
-	if prettyOutput {
+	if prettyOutput && isStderrTTY() {
 		stopSpinner = make(chan struct{})
 		spinnerDone = make(chan struct{})
 		go func() {
@@ -83,7 +83,7 @@ func runAsk(cmd *cobra.Command, args []string) error {
 
 	result, err := ask.Ask(context.Background(), client, question)
 
-	if prettyOutput {
+	if stopSpinner != nil {
 		close(stopSpinner)
 		<-spinnerDone
 	}

cmd/output.go

@@ -22,13 +22,15 @@ func loadGlamourStyle() string {
 }
 
 // printMarkdown writes text to cmd's output stream, rendering it through
-// glamour when the global --pretty flag is set.
+// glamour when the global --pretty flag is set and stdout is a TTY.
+// When stdout is not a TTY the rendered ANSI codes would be meaningless
+// (e.g. piped to a file or another process), so plain text is used instead.
 func printMarkdown(cmd *cobra.Command, text string) {
 	// --pretty-no-pager takes priority over --pretty
-	if prettyNoPager {
+	if prettyNoPager && isTTY() {
 		text = render.Markdown(text, loadGlamourStyle())
 		fmt.Fprint(cmd.OutOrStdout(), text)
-	} else if prettyOutput {
+	} else if prettyOutput && isTTY() {
 		text = render.Markdown(text, loadGlamourStyle())
 		printWithPager(cmd, text)
 	} else {
@@ -41,10 +43,10 @@ func printMarkdown(cmd *cobra.Command, text string) {
 // so glamour does not collapse them into a single line per item.
 func printMarkdownAnswer(cmd *cobra.Command, text string) {
 	// --pretty-no-pager takes priority over --pretty
-	if prettyNoPager {
+	if prettyNoPager && isTTY() {
 		text = render.MarkdownAnswer(text, loadGlamourStyle())
 		fmt.Fprint(cmd.OutOrStdout(), text)
-	} else if prettyOutput {
+	} else if prettyOutput && isTTY() {
 		text = render.MarkdownAnswer(text, loadGlamourStyle())
 		printWithPager(cmd, text)
 	} else {
@@ -90,3 +92,8 @@ func printWithPager(cmd *cobra.Command, text string) {
 func isTTY() bool {
 	return term.IsTerminal(1) // fd 1 = stdout
 }
+
+// isStderrTTY returns true if stderr is a terminal.
+func isStderrTTY() bool {
+	return term.IsTerminal(2) // fd 2 = stderr
+}

cmd/process.go

@@ -4,6 +4,8 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"strings"
+	"sync"
 	"time"
 
 	"github.com/hardhacker/podwise-cli/internal/api"
@@ -119,8 +121,13 @@ func runProcess(cmd *cobra.Command, args []string) error {
 	if result.Progress != nil {
 		initialProgress = *result.Progress
 	}
-	printProcessStatus(result, initialProgress)
 
+	if (prettyOutput || prettyNoPager) && isTTY() {
+		return runProcessPretty(ctx, client, seq, result.Status, initialProgress, startTime)
+	}
+
+	// Plain (non-pretty) path.
+	printProcessStatus(result, initialProgress)
 	if result.Status == "done" {
 		printProcessDoneHint(seq, time.Since(startTime))
 		return nil
@@ -151,7 +158,95 @@ func runProcess(cmd *cobra.Command, args []string) error {
 		case "done":
 			printProcessDoneHint(seq, time.Since(startTime))
 			return nil
-		case "failed":
+		case "failed", "not_requested":
+			return fmt.Errorf("processing failed for episode %s", episode.BuildEpisodeURL(seq))
+		}
+	}
+	return nil
+}
+
+// runProcessPretty runs the polling loop with an animated spinner.
+// A goroutine redraws the status line at 100 ms so the spinner animates
+// continuously, while API polls happen on the normal (≥30 s) interval.
+func runProcessPretty(ctx context.Context, client *api.Client, seq int, initialStatus string, initialProgress float64, startTime time.Time) error {
+	// Shared state between the spinner goroutine and the poll loop.
+	var mu sync.Mutex
+	curStatus := initialStatus
+	curProgress := initialProgress
+	spinIdx := 0
+
+	// Initial render.
+	prettyPrintProcessStatus(&episode.ProcessResult{Status: curStatus}, curProgress, spinIdx)
+
+	if curStatus == "done" {
+		prettyPrintProcessDoneHint(seq, time.Since(startTime))
+		return nil
+	}
+
+	stopCh := make(chan struct{})
+	var wg sync.WaitGroup
+	wg.Add(1)
+
+	// Spinner goroutine: redraws the current line at ~100 ms.
+	go func() {
+		defer wg.Done()
+		t := time.NewTicker(100 * time.Millisecond)
+		defer t.Stop()
+		for {
+			select {
+			case <-stopCh:
+				return
+			case <-t.C:
+				mu.Lock()
+				spinIdx++
+				prettyPrintProcessStatus(&episode.ProcessResult{Status: curStatus}, curProgress, spinIdx)
+				mu.Unlock()
+			}
+		}
+	}()
+
+	stopSpinner := func() {
+		select {
+		case <-stopCh:
+		default:
+			close(stopCh)
+		}
+		wg.Wait()
+	}
+
+	deadline := time.Now().Add(processTimeout)
+	pollTicker := time.NewTicker(processPollInterval)
+	defer pollTicker.Stop()
+
+	for range pollTicker.C {
+		if time.Now().After(deadline) {
+			stopSpinner()
+			fmt.Println()
+			return fmt.Errorf("timed out after %s waiting for episode %s to finish processing", processTimeout, episode.BuildEpisodeURL(seq))
+		}
+		status, err := episode.FetchStatus(ctx, client, seq)
+		if err != nil {
+			stopSpinner()
+			fmt.Println()
+			return err
+		}
+
+		mu.Lock()
+		if status.Progress != nil && *status.Progress > curProgress {
+			curProgress = *status.Progress
+		}
+		curStatus = status.Status
+		mu.Unlock()
+
+		switch status.Status {
+		case "done":
+			stopSpinner()
+			prettyPrintProcessStatus(status, curProgress, 0)
+			prettyPrintProcessDoneHint(seq, time.Since(startTime))
+			return nil
+		case "failed", "not_requested":
+			stopSpinner()
+			prettyPrintProcessStatus(status, curProgress, 0)
 			return fmt.Errorf("processing failed for episode %s", episode.BuildEpisodeURL(seq))
 		}
 	}
@@ -166,18 +261,13 @@ func printProcessStatus(r *episode.ProcessResult, maxProgress float64) {
 	switch r.Status {
 	case "waiting":
 		fmt.Printf("  [%s] → waiting       episode is queued for processing\n", ts)
-	case "processing":
-		if maxProgress >= 0.0 {
-			fmt.Printf("  [%s] → processing    %.0f%% complete\n", ts, maxProgress)
-		}
 	case "done":
 		fmt.Printf("  [%s] ✓ done          processing complete (100%%)\n", ts)
-	case "not_requested":
-		fmt.Printf("  [%s] → not_requested  transcription has not been requested yet\n", ts)
-	case "failed":
+	case "failed", "not_requested":
 		fmt.Printf("  [%s] ✗ failed         transcription failed\n", ts)
 	default:
-		fmt.Printf("  [%s] ? %s\n", ts, r.Status)
+		// "processing" and any other transitional status are all treated as in-progress.
+		fmt.Printf("  [%s] → processing    %.0f%% complete\n", ts, maxProgress)
 	}
 }
 
@@ -195,3 +285,74 @@ func printProcessDoneHint(seq int, elapsed time.Duration) {
 	fmt.Printf("    podwise get summary    %s\n", episodeURL)
 	fmt.Printf("    podwise get --help     to see all available commands\n")
 }
+
+// prettySpinnerFrames are the braille spinner frames used in pretty mode.
+var prettySpinnerFrames = []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}
+
+// prettyPrintProcessStatus overwrites the current terminal line with a styled
+// status. spinnerIdx is incremented by the caller on each poll to advance the
+// spinner. done/failed states end the line with \n so subsequent output is clean.
+func prettyPrintProcessStatus(r *episode.ProcessResult, maxProgress float64, spinnerIdx int) {
+	const (
+		reset  = "\033[0m"
+		bold   = "\033[1m"
+		dim    = "\033[2m"
+		green  = "\033[32m"
+		yellow = "\033[33m"
+		blue   = "\033[34m"
+		red    = "\033[31m"
+		cyan   = "\033[36m"
+		barW   = 24
+	)
+	spinner := prettySpinnerFrames[spinnerIdx%len(prettySpinnerFrames)]
+
+	buildBar := func(pct float64) string {
+		n := int(pct / 100.0 * barW)
+		if n > barW {
+			n = barW
+		}
+		return strings.Repeat("█", n) + strings.Repeat("░", barW-n)
+	}
+
+	var line string
+	switch r.Status {
+	case "waiting":
+		line = fmt.Sprintf("\r\033[K  %s%s%s %swaiting%s    queued for processing",
+			yellow, spinner, reset, yellow, reset)
+	case "done":
+		bar := buildBar(100)
+		line = fmt.Sprintf("\r\033[K  %s✓%s %sdone%s  %s[%s]%s %s100%%%s\n",
+			green, reset, green+bold, reset, dim, bar, reset, bold, reset)
+	case "failed", "not_requested":
+		line = fmt.Sprintf("\r\033[K  %s✗%s %sfailed%s  transcription failed\n",
+			red, reset, red+bold, reset)
+	default:
+		// "processing" and any other transitional status are all treated as in-progress.
+		bar := buildBar(maxProgress)
+		line = fmt.Sprintf("\r\033[K  %s%s%s %sprocessing%s  %s[%s]%s %s%.0f%%%s",
+			blue, spinner, reset, blue, reset, dim, bar, reset, bold, maxProgress, reset)
+	}
+	fmt.Print(line)
+}
+
+func prettyPrintProcessDoneHint(seq int, elapsed time.Duration) {
+	const (
+		reset = "\033[0m"
+		bold  = "\033[1m"
+		dim   = "\033[2m"
+		green = "\033[32m"
+		cyan  = "\033[36m"
+	)
+	episodeURL := episode.BuildEpisodeURL(seq)
+	sep := "─────────────────────────────────────────────────────────"
+	fmt.Printf("\n%s%s%s\n", dim, sep, reset)
+	fmt.Printf("  %s✓  Processing Complete%s\n", green+bold, reset)
+	fmt.Printf("%s%s%s\n", dim, sep, reset)
+	fmt.Printf("  %sEpisode URL:%s   %s%s%s\n", dim, reset, cyan, episodeURL, reset)
+	fmt.Printf("  %sDuration   :%s   %s\n", dim, reset, utils.FormatDuration(elapsed))
+	fmt.Printf("\n")
+	fmt.Printf("  %sNext steps:%s\n", bold, reset)
+	fmt.Printf("    %spodwise get transcript%s %s\n", cyan, reset, episodeURL)
+	fmt.Printf("    %spodwise get summary%s    %s\n", cyan, reset, episodeURL)
+	fmt.Printf("    %spodwise get --help%s     to see all available commands\n", cyan, reset)
+}