feat(init/builds create): use dev component instead

yjp20 · yjp20 · commit ca2776442bdf · 2026-04-09T16:56:13.000-07:00
diff --git a/pkg/cmd/build.go b/pkg/cmd/build.go
@@ -11,10 +11,10 @@ import (
 	"path"
 	"strings"
 
-	tea "github.com/charmbracelet/bubbletea"
 	"github.com/stainless-api/stainless-api-cli/internal/apiquery"
 	"github.com/stainless-api/stainless-api-cli/internal/requestflag"
 	cbuild "github.com/stainless-api/stainless-api-cli/pkg/components/build"
+	cdev "github.com/stainless-api/stainless-api-cli/pkg/components/dev"
 	"github.com/stainless-api/stainless-api-cli/pkg/console"
 	"github.com/stainless-api/stainless-api-cli/pkg/stainlessutils"
 	"github.com/stainless-api/stainless-api-cli/pkg/workspace"
@@ -25,24 +25,15 @@ import (
 	"github.com/urfave/cli/v3"
 )
 
-// WaitMode represents the level of waiting for build completion
-type WaitMode int
-
-const (
-	WaitNone   WaitMode = iota // Don't wait
-	WaitCommit                 // Wait for commit only
-	WaitAll                    // Wait for everything including workflows
-)
-
 // parseWaitMode converts the --wait flag string to a WaitMode
-func parseWaitMode(wait string) (WaitMode, error) {
+func parseWaitMode(wait string) (cdev.WaitMode, error) {
 	switch wait {
 	case "none", "false": // Accept both "none" and "false" for backwards compatibility
-		return WaitNone, nil
+		return cdev.WaitNone, nil
 	case "commit":
-		return WaitCommit, nil
+		return cdev.WaitCommit, nil
 	case "all":
-		return WaitAll, nil
+		return cdev.WaitAll, nil
 	default:
 		return 0, fmt.Errorf("invalid --wait value: %q (must be 'none', 'commit', or 'all')", wait)
 	}
@@ -429,20 +420,26 @@ func handleBuildsCreate(ctx context.Context, cmd *cli.Command) error {
 
 	buildGroup.Property("build_id", build.ID)
 
-	if waitMode > WaitNone {
+	if waitMode > cdev.WaitNone {
 		console.Spacer()
-		buildModel := cbuild.NewModel(client, ctx, *build, cmd.String("branch"), downloadPaths)
-		buildModel.CommitOnly = waitMode == WaitCommit
-		model := tea.Model(buildCompletionModel{
-			Build:    buildModel,
-			WaitMode: waitMode,
+		devModel := cdev.NewModel(cdev.ModelConfig{
+			Client:        client,
+			Ctx:           ctx,
+			Branch:        cmd.String("branch"),
+			Start:         func() (*stainless.Build, error) { return build, nil },
+			DownloadPaths: downloadPaths,
+			Label:         "BUILD",
+			WaitMode:      waitMode,
+			Indent:        "  ",
 		})
-		model, err = console.NewProgram(model).Run()
+		devModel.Build.CommitOnly = waitMode == cdev.WaitCommit
+		model, err := console.NewProgram(devModel).Run()
 		if err != nil {
 			console.Warn("%s", err.Error())
 		}
-		b := model.(buildCompletionModel).Build
-		build = &b.Build
+		if m, ok := model.(cdev.Model); ok {
+			build = &m.Build.Build
+		}
 		console.Spacer()
 	}
 
@@ -454,7 +451,7 @@ func handleBuildsCreate(ctx context.Context, cmd *cli.Command) error {
 	}
 
 	// Only check for failures if we waited for the build
-	if waitMode == WaitNone {
+	if waitMode == cdev.WaitNone {
 		return nil
 	}
 
@@ -475,7 +472,7 @@ func handleBuildsCreate(ctx context.Context, cmd *cli.Command) error {
 		}
 
 		// Only check workflow failures if we waited for them
-		if waitMode >= WaitAll {
+		if waitMode >= cdev.WaitAll {
 			if bt.Lint.Conclusion == "failure" || bt.Test.Conclusion == "failure" || bt.Build.Conclusion == "failure" {
 				failures = append(failures, fmt.Errorf("%s workflow failed", target))
 			}
@@ -489,65 +486,6 @@ func handleBuildsCreate(ctx context.Context, cmd *cli.Command) error {
 	return nil
 }
 
-type buildCompletionModel struct {
-	Build    cbuild.Model
-	WaitMode WaitMode
-}
-
-func (c buildCompletionModel) Init() tea.Cmd {
-	return c.Build.Init()
-}
-
-func (c buildCompletionModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
-	var cmd tea.Cmd
-	c.Build, cmd = c.Build.Update(msg)
-
-	if c.IsCompleted() {
-		return c, tea.Sequence(
-			cmd,
-			tea.Quit,
-		)
-	}
-
-	return c, cmd
-}
-
-func (c buildCompletionModel) IsCompleted() bool {
-	b := stainlessutils.NewBuild(c.Build.Build)
-	for _, target := range b.Languages() {
-		buildTarget := b.BuildTarget(target)
-
-		if buildTarget == nil {
-			return false
-		}
-
-		// Check if download is completed (if applicable)
-		downloadIsCompleted := true
-		if buildTarget.IsCommitCompleted() && buildTarget.IsGoodCommitConclusion() {
-			if download, ok := c.Build.Downloads[target]; ok {
-				downloadIsCompleted = download.Status == "completed"
-			}
-		}
-
-		// Check if target is done based on wait mode
-		done := buildTarget.IsCommitCompleted()
-		if c.WaitMode >= WaitAll {
-			done = buildTarget.IsCompleted()
-		}
-
-		if !done || !downloadIsCompleted {
-			return false
-		}
-	}
-
-	return true
-}
-
-func (c buildCompletionModel) View() string {
-	c.Build.CommitOnly = c.WaitMode == WaitCommit
-	return c.Build.View()
-}
-
 func handleBuildsRetrieve(ctx context.Context, cmd *cli.Command) error {
 	client := stainless.NewClient(getDefaultRequestOptions(cmd)...)
 	unusedArgs := cmd.Args().Slice()
diff --git a/pkg/cmd/init.go b/pkg/cmd/init.go
@@ -13,7 +13,7 @@ import (
 	"strings"
 	"time"
 
-	cbuild "github.com/stainless-api/stainless-api-cli/pkg/components/build"
+	cdev "github.com/stainless-api/stainless-api-cli/pkg/components/dev"
 	"github.com/stainless-api/stainless-api-cli/pkg/console"
 	"github.com/stainless-api/stainless-api-cli/pkg/stainlessutils"
 	"github.com/stainless-api/stainless-api-cli/pkg/workspace"
@@ -483,8 +483,6 @@ func initializeWorkspace(ctx context.Context, cmd *cli.Command, client stainless
 
 	console.Spacer()
 
-	console.Info("Waiting for build to complete...")
-
 	// Try to get the latest build for this project (which should have been created automatically)
 	build, err := getLatestBuild(ctx, client, projectSlug, "main")
 	if err != nil {
@@ -496,14 +494,20 @@ func initializeWorkspace(ctx context.Context, cmd *cli.Command, client stainless
 		downloadPaths[stainless.Target(targetName)] = targetConfig.OutputPath
 	}
 
-	buildModel := cbuild.NewModel(client, ctx, *build, "main", downloadPaths)
-	buildModel.CommitOnly = true
-	model := buildCompletionModel{
-		Build:    buildModel,
-		WaitMode: WaitCommit,
-	}
+	devModel := cdev.NewModel(cdev.ModelConfig{
+		Client:        client,
+		Ctx:           ctx,
+		Branch:        "main",
+		Start:         func() (*stainless.Build, error) { return build, nil },
+		DownloadPaths: downloadPaths,
+		Label:         "BUILD",
+		WaitMode:      cdev.WaitCommit,
+		Indent:        "  ",
+	})
+	devModel.Build.CommitOnly = true
+	devModel.Diagnostics.WorkspaceConfig = config
 
-	_, err = console.NewProgram(model).Run()
+	_, err = console.NewProgram(devModel).Run()
 	if err != nil {
 		console.Warn("%s", err.Error())
 	}
diff --git a/pkg/components/dev/model.go b/pkg/components/dev/model.go
@@ -16,6 +16,15 @@ import (
 
 var ErrUserCancelled = errors.New("user cancelled")
 
+// WaitMode represents the level of waiting for build completion.
+type WaitMode int
+
+const (
+	WaitNone   WaitMode = iota // Don't wait
+	WaitCommit                 // Wait for commit only
+	WaitAll                    // Wait for everything including workflows
+)
+
 type Model struct {
 	Err error
 
@@ -26,6 +35,9 @@ type Model struct {
 	start       func() (*stainless.Build, error)
 	Branch      string
 	view        string
+	label    string
+	waitMode WaitMode
+	Indent   string
 
 	// models
 
@@ -44,15 +56,25 @@ type ModelConfig struct {
 	Start         func() (*stainless.Build, error)
 	DownloadPaths map[stainless.Target]string
 	Watch         bool
+	Label         string   // Header label, defaults to "PREVIEW"
+	WaitMode      WaitMode // When non-zero, auto-quits after diagnostics are fetched and build targets reach completion
+	Indent        string   // Prefix for every non-empty output line (e.g. "  ")
 }
 
 func NewModel(cfg ModelConfig) Model {
+	label := cfg.Label
+	if label == "" {
+		label = "PREVIEW"
+	}
 	return Model{
 		start:       cfg.Start,
 		Client:      cfg.Client,
 		Ctx:         cfg.Ctx,
 		Branch:      cfg.Branch,
 		Watch:       cfg.Watch,
+		label:    label,
+		waitMode: cfg.WaitMode,
+		Indent:   cfg.Indent,
 		Help:        help.New(),
 		Build:       build.NewModel(cfg.Client, cfg.Ctx, stainless.Build{}, cfg.Branch, cfg.DownloadPaths),
 		Diagnostics: diagnostics.NewModel(cfg.Client, cfg.Ctx, nil),
@@ -139,6 +161,12 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		// File change detected, exit with success
 		cmds = append(cmds, tea.Quit)
 	}
+
+	// Auto-quit when WaitMode is set and build targets have reached completion
+	if m.waitMode > WaitNone && m.diagnosticsFetched() && m.isComplete() {
+		return m, tea.Sequence(tea.Batch(cmds...), tea.Quit)
+	}
+
 	return m, tea.Batch(cmds...)
 }
 
@@ -163,3 +191,37 @@ func (m Model) FullHelp() [][]key.Binding {
 		return [][]key.Binding{{key.NewBinding(key.WithKeys("ctrl+c"), key.WithHelp("ctrl-c", "quit"))}}
 	}
 }
+
+func (m Model) diagnosticsFetched() bool {
+	return m.Diagnostics.Diagnostics != nil || m.Diagnostics.Err != nil
+}
+
+func (m Model) isComplete() bool {
+	buildObj := stainlessutils.NewBuild(m.Build.Build)
+	for _, target := range buildObj.Languages() {
+		buildTarget := buildObj.BuildTarget(target)
+		if buildTarget == nil {
+			return false
+		}
+
+		// Check if download is completed (if applicable)
+		if buildTarget.IsCommitCompleted() && buildTarget.IsGoodCommitConclusion() {
+			if download, ok := m.Build.Downloads[target]; ok {
+				if download.Status != "completed" {
+					return false
+				}
+			}
+		}
+
+		// Check if target is done based on wait mode
+		done := buildTarget.IsCommitCompleted()
+		if m.waitMode >= WaitAll {
+			done = buildTarget.IsCompleted()
+		}
+
+		if !done {
+			return false
+		}
+	}
+	return true
+}
diff --git a/pkg/components/dev/view.go b/pkg/components/dev/view.go
@@ -30,7 +30,21 @@ func (m Model) View() string {
 		s.WriteString("\n" + m.Err.Error() + "\n")
 	}
 
-	return s.String()
+	return m.applyIndent(s.String())
+}
+
+// applyIndent prefixes every non-empty line with m.Indent.
+func (m Model) applyIndent(s string) string {
+	if m.Indent == "" {
+		return s
+	}
+	lines := strings.Split(s, "\n")
+	for i, line := range lines {
+		if line != "" {
+			lines[i] = m.Indent + line
+		}
+	}
+	return strings.Join(lines, "\n")
 }
 
 // ViewPart represents a single part of the build view
@@ -43,7 +57,7 @@ var parts = []ViewPart{
 	{
 		Name: "header",
 		View: func(m *Model, s *strings.Builder) {
-			s.WriteString(build.ViewHeader("PREVIEW", m.Build.Build))
+			s.WriteString(build.ViewHeader(m.label, m.Build.Build))
 		},
 	},
 	{
@@ -69,6 +83,9 @@ var parts = []ViewPart{
 	{
 		Name: "studio",
 		View: func(m *Model, s *strings.Builder) {
+			if !m.Watch {
+				return
+			}
 			if m.Build.ID != "" {
 				url := fmt.Sprintf("https://app.stainless.com/%s/%s/studio?branch=%s", m.Build.Org, m.Build.Project, m.Branch)
 				s.WriteString("\n")
@@ -80,6 +97,9 @@ var parts = []ViewPart{
 	{
 		Name: "help",
 		View: func(m *Model, s *strings.Builder) {
+			if !m.Watch {
+				return
+			}
 			s.WriteString("\n")
 			s.WriteString(m.Help.View(m))
 		},
@@ -100,7 +120,7 @@ func (m *Model) updateView(targetState string) tea.Cmd {
 		return nil
 	}
 
-	output := ViewBuildRange(m, m.view, targetState)
+	output := m.applyIndent(ViewBuildRange(m, m.view, targetState))
 
 	// Update model state
 	m.view = targetState
