2d9aebe cli: address review feedback for non-TUI style alignment · dumber

M internal/cli/cmd/config.go +3 -5


@@ -114,27 +114,26 @@ func runConfigOpen(_ *cobra.Command, _ []string) error {
114	114		return fmt.Errorf("app not initialized")
115	115		}
116	116
	117	+	renderer := styles.NewConfigRenderer(app.Theme)
	118	+
117	119		configFile, err := config.GetConfigFile()
118	120		if err != nil {
119		-	renderer := styles.NewConfigRenderer(app.Theme)
120	121		return fmt.Errorf("%s", strings.TrimRight(renderer.RenderError(fmt.Errorf("get config file: %w", err)), "\n"))
121	122		}
122	123
123	124		// Check if config file exists
124	125		if _, statErr := os.Stat(configFile); os.IsNotExist(statErr) {
125		-	renderer := styles.NewConfigRenderer(app.Theme)
126	126		return fmt.Errorf("%s", strings.TrimRight(renderer.RenderError(fmt.Errorf("config file does not exist: %s", configFile)), "\n"))
127	127		}
128	128
129	129		editor := getEditor()
130	130		if editor == "" {
131		-	renderer := styles.NewConfigRenderer(app.Theme)
132	131		const msg = "no editor found: set $EDITOR or $VISUAL environment variable"
133	132		return fmt.Errorf("%s", strings.TrimRight(renderer.RenderError(fmt.Errorf("%s", msg)), "\n"))
134	133		}
135	134
136	135		// Keep this a simple, non-interactive message; the actual editor takes over the terminal.
137		-	fmt.Println(styles.NewConfigRenderer(app.Theme).RenderOpening(configFile, editor))
	136	+	fmt.Println(renderer.RenderOpening(configFile, editor))
138	137
139	138		cmd := exec.Command(editor, configFile)
140	139		cmd.Stdin = os.Stdin

@@ -142,7 +141,6 @@ func runConfigOpen(_ *cobra.Command, _ []string) error {
142	141		cmd.Stderr = os.Stderr
143	142
144	143		if err := cmd.Run(); err != nil {
145		-	renderer := styles.NewConfigRenderer(app.Theme)
146	144		return fmt.Errorf("%s", strings.TrimRight(renderer.RenderError(fmt.Errorf("open config: %w", err)), "\n"))
147	145		}
148	146		return nil

 		return fmt.Errorf("app not initialized")
 	}
+	renderer := styles.NewConfigRenderer(app.Theme)
 	configFile, err := config.GetConfigFile()
 	if err != nil {
-		renderer := styles.NewConfigRenderer(app.Theme)
 		return fmt.Errorf("%s", strings.TrimRight(renderer.RenderError(fmt.Errorf("get config file: %w", err)), "\n"))
 	}
 	// Check if config file exists
 	if _, statErr := os.Stat(configFile); os.IsNotExist(statErr) {
-		renderer := styles.NewConfigRenderer(app.Theme)
 		return fmt.Errorf("%s", strings.TrimRight(renderer.RenderError(fmt.Errorf("config file does not exist: %s", configFile)), "\n"))
 	}
 	editor := getEditor()
 	if editor == "" {
-		renderer := styles.NewConfigRenderer(app.Theme)
 		const msg = "no editor found: set $EDITOR or $VISUAL environment variable"
 		return fmt.Errorf("%s", strings.TrimRight(renderer.RenderError(fmt.Errorf("%s", msg)), "\n"))
 	}
 	// Keep this a simple, non-interactive message; the actual editor takes over the terminal.
-	fmt.Println(styles.NewConfigRenderer(app.Theme).RenderOpening(configFile, editor))
+	fmt.Println(renderer.RenderOpening(configFile, editor))
 	cmd := exec.Command(editor, configFile)
 	cmd.Stdin = os.Stdin
 	cmd.Stderr = os.Stderr
 	if err := cmd.Run(); err != nil {
-		renderer := styles.NewConfigRenderer(app.Theme)
 		return fmt.Errorf("%s", strings.TrimRight(renderer.RenderError(fmt.Errorf("open config: %w", err)), "\n"))
 	}
 	return nil

M internal/cli/cmd/crashes.go +4 -4


@@ -101,13 +101,13 @@ func runCrashesShow(_ *cobra.Command, args []string) error {
101	101		report, err := resolveCrashReport(getCrashReportsDir(app.Config), args[0])
102	102		if err != nil {
103	103		_, _ = fmt.Fprintf(os.Stderr, "%s\n%s\n", renderer.RenderError(err), renderer.RenderHintList())
104		-	return nil
	104	+	return fmt.Errorf("resolve crash report: %w", err)
105	105		}
106	106
107	107		body, err := os.ReadFile(report.MarkdownPath)
108	108		if err != nil {
109	109		_, _ = fmt.Fprintf(os.Stderr, "%s\n", renderer.RenderError(fmt.Errorf("read crash report markdown: %w", err)))
110		-	return nil
	110	+	return fmt.Errorf("read crash report markdown: %w", err)
111	111		}
112	112		fmt.Print(string(body))
113	113		return nil

@@ -123,13 +123,13 @@ func runCrashesIssue(_ *cobra.Command, args []string) error {
123	123		report, err := resolveCrashReport(getCrashReportsDir(app.Config), args[0])
124	124		if err != nil {
125	125		_, _ = fmt.Fprintf(os.Stderr, "%s\n%s\n", renderer.RenderError(err), renderer.RenderHintList())
126		-	return nil
	126	+	return fmt.Errorf("resolve crash report: %w", err)
127	127		}
128	128
129	129		body, err := os.ReadFile(report.MarkdownPath)
130	130		if err != nil {
131	131		_, _ = fmt.Fprintf(os.Stderr, "%s\n", renderer.RenderError(fmt.Errorf("read crash report markdown: %w", err)))
132		-	return nil
	132	+	return fmt.Errorf("read crash report markdown: %w", err)
133	133		}
134	134		all := string(body)
135	135		start := strings.Index(all, "## GitHub Issue Template")


@@ -101,13 +101,13 @@ func runCrashesShow(_ *cobra.Command, args []string) error {
101		report, err := resolveCrashReport(getCrashReportsDir(app.Config), args[0])	101		report, err := resolveCrashReport(getCrashReportsDir(app.Config), args[0])
102		if err != nil {	102		if err != nil {
103		_, _ = fmt.Fprintf(os.Stderr, "%s\n%s\n", renderer.RenderError(err), renderer.RenderHintList())	103		_, _ = fmt.Fprintf(os.Stderr, "%s\n%s\n", renderer.RenderError(err), renderer.RenderHintList())
104	-	return nil	104	+	return fmt.Errorf("resolve crash report: %w", err)
105		}	105		}
106			106
107		body, err := os.ReadFile(report.MarkdownPath)	107		body, err := os.ReadFile(report.MarkdownPath)
108		if err != nil {	108		if err != nil {
109		_, _ = fmt.Fprintf(os.Stderr, "%s\n", renderer.RenderError(fmt.Errorf("read crash report markdown: %w", err)))	109		_, _ = fmt.Fprintf(os.Stderr, "%s\n", renderer.RenderError(fmt.Errorf("read crash report markdown: %w", err)))
110	-	return nil	110	+	return fmt.Errorf("read crash report markdown: %w", err)
111		}	111		}
112		fmt.Print(string(body))	112		fmt.Print(string(body))
113		return nil	113		return nil

@@ -123,13 +123,13 @@ func runCrashesIssue(_ *cobra.Command, args []string) error {
123		report, err := resolveCrashReport(getCrashReportsDir(app.Config), args[0])	123		report, err := resolveCrashReport(getCrashReportsDir(app.Config), args[0])
124		if err != nil {	124		if err != nil {
125		_, _ = fmt.Fprintf(os.Stderr, "%s\n%s\n", renderer.RenderError(err), renderer.RenderHintList())	125		_, _ = fmt.Fprintf(os.Stderr, "%s\n%s\n", renderer.RenderError(err), renderer.RenderHintList())
126	-	return nil	126	+	return fmt.Errorf("resolve crash report: %w", err)
127		}	127		}
128			128
129		body, err := os.ReadFile(report.MarkdownPath)	129		body, err := os.ReadFile(report.MarkdownPath)
130		if err != nil {	130		if err != nil {
131		_, _ = fmt.Fprintf(os.Stderr, "%s\n", renderer.RenderError(fmt.Errorf("read crash report markdown: %w", err)))	131		_, _ = fmt.Fprintf(os.Stderr, "%s\n", renderer.RenderError(fmt.Errorf("read crash report markdown: %w", err)))
132	-	return nil	132	+	return fmt.Errorf("read crash report markdown: %w", err)
133		}	133		}
134		all := string(body)	134		all := string(body)
135		start := strings.Index(all, "## GitHub Issue Template")	135		start := strings.Index(all, "## GitHub Issue Template")

M internal/cli/cmd/sessions.go +25 -9


@@ -96,7 +96,9 @@ func runSessionsList(_ *cobra.Command, _ []string) error {
96	96		renderer := styles.NewSessionsCLIRenderer(app.Theme)
97	97
98	98		if app.ListSessionsUC == nil {
99		-	return fmt.Errorf("%s", renderer.RenderError(fmt.Errorf("session management not available")))
	99	+	err := fmt.Errorf("session management not available")
	100	+	fmt.Fprintln(os.Stderr, renderer.RenderError(err))
	101	+	return err
100	102		}
101	103
102	104		// Get current session ID (empty if not running as browser)

@@ -107,7 +109,9 @@ func runSessionsList(_ *cobra.Command, _ []string) error {
107	109
108	110		output, err := app.ListSessionsUC.Execute(app.Ctx(), currentSessionID, sessionsLimit)
109	111		if err != nil {
110		-	return fmt.Errorf("%s", renderer.RenderError(fmt.Errorf("list sessions: %w", err)))
	112	+	wrappedErr := fmt.Errorf("list sessions: %w", err)
	113	+	fmt.Fprintln(os.Stderr, renderer.RenderError(wrappedErr))
	114	+	return wrappedErr
111	115		}
112	116
113	117		if sessionsJSON {

@@ -154,13 +158,16 @@ func runSessionsRestore(_ *cobra.Command, args []string) error {
154	158		renderer := styles.NewSessionsCLIRenderer(app.Theme)
155	159
156	160		if app.RestoreUC == nil \|\| app.ListSessionsUC == nil {
157		-	return fmt.Errorf("%s", renderer.RenderError(fmt.Errorf("session restoration not available")))
	161	+	err := fmt.Errorf("session restoration not available")
	162	+	fmt.Fprintln(os.Stderr, renderer.RenderError(err))
	163	+	return err
158	164		}
159	165
160	166		// Find session by ID or suffix
161	167		sessionInfo, err := findSessionByIDOrSuffix(args[0])
162	168		if err != nil {
163		-	return fmt.Errorf("%s", renderer.RenderError(err))
	169	+	fmt.Fprintln(os.Stderr, renderer.RenderError(err))
	170	+	return err
164	171		}
165	172
166	173		sessionID := sessionInfo.Session.ID

@@ -168,13 +175,17 @@ func runSessionsRestore(_ *cobra.Command, args []string) error {
168	175		// Validate the session has restorable state
169	176		_, err = app.RestoreUC.Execute(app.Ctx(), usecase.RestoreInput{SessionID: sessionID})
170	177		if err != nil {
171		-	return fmt.Errorf("%s", renderer.RenderError(fmt.Errorf("restore session: %w", err)))
	178	+	wrappedErr := fmt.Errorf("restore session: %w", err)
	179	+	fmt.Fprintln(os.Stderr, renderer.RenderError(wrappedErr))
	180	+	return wrappedErr
172	181		}
173	182
174	183		// Spawn a new dumber instance with the session
175	184		spawner := desktop.NewSessionSpawner(app.Ctx())
176	185		if err := spawner.SpawnWithSession(sessionID); err != nil {
177		-	return fmt.Errorf("%s", renderer.RenderError(fmt.Errorf("spawn browser: %w", err)))
	186	+	wrappedErr := fmt.Errorf("spawn browser: %w", err)
	187	+	fmt.Fprintln(os.Stderr, renderer.RenderError(wrappedErr))
	188	+	return wrappedErr
178	189		}
179	190
180	191		fmt.Println(renderer.RenderRestoreStarted(sessionID))

@@ -211,13 +222,16 @@ func runSessionsDelete(_ *cobra.Command, args []string) error {
211	222		renderer := styles.NewSessionsCLIRenderer(app.Theme)
212	223
213	224		if app.DeleteSessionUC == nil \|\| app.ListSessionsUC == nil {
214		-	return fmt.Errorf("%s", renderer.RenderError(fmt.Errorf("session management not available")))
	225	+	err := fmt.Errorf("session management not available")
	226	+	fmt.Fprintln(os.Stderr, renderer.RenderError(err))
	227	+	return err
215	228		}
216	229
217	230		// Find session by ID or suffix
218	231		sessionInfo, err := findSessionByIDOrSuffix(args[0])
219	232		if err != nil {
220		-	return fmt.Errorf("%s", renderer.RenderError(err))
	233	+	fmt.Fprintln(os.Stderr, renderer.RenderError(err))
	234	+	return err
221	235		}
222	236
223	237		// Get current session ID

@@ -231,7 +245,9 @@ func runSessionsDelete(_ *cobra.Command, args []string) error {
231	245		SessionID: sessionInfo.Session.ID,
232	246		CurrentSessionID: currentSessionID,
233	247		}); err != nil {
234		-	return fmt.Errorf("%s", renderer.RenderError(fmt.Errorf("delete session: %w", err)))
	248	+	wrappedErr := fmt.Errorf("delete session: %w", err)
	249	+	fmt.Fprintln(os.Stderr, renderer.RenderError(wrappedErr))
	250	+	return wrappedErr
235	251		}
236	252
237	253		fmt.Println(renderer.RenderDeleted(sessionInfo.Session.ID))

 	renderer := styles.NewSessionsCLIRenderer(app.Theme)
 	if app.ListSessionsUC == nil {
-		return fmt.Errorf("%s", renderer.RenderError(fmt.Errorf("session management not available")))
+		err := fmt.Errorf("session management not available")
+		fmt.Fprintln(os.Stderr, renderer.RenderError(err))
+		return err
 	}
 	// Get current session ID (empty if not running as browser)
 	output, err := app.ListSessionsUC.Execute(app.Ctx(), currentSessionID, sessionsLimit)
 	if err != nil {
-		return fmt.Errorf("%s", renderer.RenderError(fmt.Errorf("list sessions: %w", err)))
+		wrappedErr := fmt.Errorf("list sessions: %w", err)
+		fmt.Fprintln(os.Stderr, renderer.RenderError(wrappedErr))
+		return wrappedErr
 	}
 	if sessionsJSON {
 	renderer := styles.NewSessionsCLIRenderer(app.Theme)
 	if app.RestoreUC == nil || app.ListSessionsUC == nil {
-		return fmt.Errorf("%s", renderer.RenderError(fmt.Errorf("session restoration not available")))
+		err := fmt.Errorf("session restoration not available")
+		fmt.Fprintln(os.Stderr, renderer.RenderError(err))
+		return err
 	}
 	// Find session by ID or suffix
 	sessionInfo, err := findSessionByIDOrSuffix(args[0])
 	if err != nil {
-		return fmt.Errorf("%s", renderer.RenderError(err))
+		fmt.Fprintln(os.Stderr, renderer.RenderError(err))
+		return err
 	}
 	sessionID := sessionInfo.Session.ID
 	// Validate the session has restorable state
 	_, err = app.RestoreUC.Execute(app.Ctx(), usecase.RestoreInput{SessionID: sessionID})
 	if err != nil {
-		return fmt.Errorf("%s", renderer.RenderError(fmt.Errorf("restore session: %w", err)))
+		wrappedErr := fmt.Errorf("restore session: %w", err)
+		fmt.Fprintln(os.Stderr, renderer.RenderError(wrappedErr))
+		return wrappedErr
 	}
 	// Spawn a new dumber instance with the session
 	spawner := desktop.NewSessionSpawner(app.Ctx())
 	if err := spawner.SpawnWithSession(sessionID); err != nil {
-		return fmt.Errorf("%s", renderer.RenderError(fmt.Errorf("spawn browser: %w", err)))
+		wrappedErr := fmt.Errorf("spawn browser: %w", err)
+		fmt.Fprintln(os.Stderr, renderer.RenderError(wrappedErr))
+		return wrappedErr
 	}
 	fmt.Println(renderer.RenderRestoreStarted(sessionID))
 	renderer := styles.NewSessionsCLIRenderer(app.Theme)
 	if app.DeleteSessionUC == nil || app.ListSessionsUC == nil {
-		return fmt.Errorf("%s", renderer.RenderError(fmt.Errorf("session management not available")))
+		err := fmt.Errorf("session management not available")
+		fmt.Fprintln(os.Stderr, renderer.RenderError(err))
+		return err
 	}
 	// Find session by ID or suffix
 	sessionInfo, err := findSessionByIDOrSuffix(args[0])
 	if err != nil {
-		return fmt.Errorf("%s", renderer.RenderError(err))
+		fmt.Fprintln(os.Stderr, renderer.RenderError(err))
+		return err
 	}
 	// Get current session ID
 		SessionID:        sessionInfo.Session.ID,
 		CurrentSessionID: currentSessionID,
 	}); err != nil {
-		return fmt.Errorf("%s", renderer.RenderError(fmt.Errorf("delete session: %w", err)))
+		wrappedErr := fmt.Errorf("delete session: %w", err)
+		fmt.Fprintln(os.Stderr, renderer.RenderError(wrappedErr))
+		return wrappedErr
 	}
 	fmt.Println(renderer.RenderDeleted(sessionInfo.Session.ID))

M internal/cli/model/sessions.go +1 -5


@@ -463,7 +463,7 @@ func (m SessionsModel) renderSessionsList(maxHeight int) string {
463	463		}
464	464
465	465		// Render expanded details, but never exceed available height.
466		-	if isExpanded && info.State != nil && remaining > 0 {
	466	+	if isExpanded && remaining > 0 {
467	467		details := m.renderSessionDetails(info)
468	468		details = truncateLines(details, remaining)
469	469		if details != "" {

@@ -492,10 +492,6 @@ func (m SessionsModel) rowHeight(idx int) int {
492	492		}
493	493
494	494		info := m.sessions[idx]
495		-	if info.State == nil {
496		-	return height
497		-	}
498		-
499	495		details := m.renderSessionDetails(info)
500	496		if details == "" {
501	497		return height

 		}
 		// Render expanded details, but never exceed available height.
-		if isExpanded && info.State != nil && remaining > 0 {
+		if isExpanded && remaining > 0 {
 			details := m.renderSessionDetails(info)
 			details = truncateLines(details, remaining)
 			if details != "" {
 	}
 	info := m.sessions[idx]
-	if info.State == nil {
-		return height
-	}
 	details := m.renderSessionDetails(info)
 	if details == "" {
 		return height