main.go

// git-spice is a command line tool for stacking Git branches.
package main

import (
	"context"
	"encoding"
	"errors"
	"fmt"
	"io"
	"os"
	"path/filepath"
	"strconv"
	"strings"
	"time"

	"github.com/alecthomas/kong"
	"github.com/charmbracelet/colorprofile"
	"github.com/mattn/go-isatty"
	"go.abhg.dev/gs/internal/browser"
	"go.abhg.dev/gs/internal/cli/experiment"
	"go.abhg.dev/gs/internal/cli/shorthand"
	"go.abhg.dev/gs/internal/forge"
	"go.abhg.dev/gs/internal/forge/bitbucket"
	"go.abhg.dev/gs/internal/forge/forgejo"
	"go.abhg.dev/gs/internal/forge/gitea"
	"go.abhg.dev/gs/internal/forge/github"
	"go.abhg.dev/gs/internal/forge/gitlab"
	"go.abhg.dev/gs/internal/git"
	"go.abhg.dev/gs/internal/git/giturl"
	"go.abhg.dev/gs/internal/handler/autostash"
	"go.abhg.dev/gs/internal/handler/checkout"
	"go.abhg.dev/gs/internal/handler/cherrypick"
	"go.abhg.dev/gs/internal/handler/delete"
	"go.abhg.dev/gs/internal/handler/merge"
	"go.abhg.dev/gs/internal/handler/onto"
	"go.abhg.dev/gs/internal/handler/restack"
	"go.abhg.dev/gs/internal/handler/split"
	"go.abhg.dev/gs/internal/handler/squash"
	"go.abhg.dev/gs/internal/handler/submit"
	"go.abhg.dev/gs/internal/handler/sync"
	"go.abhg.dev/gs/internal/handler/track"
	"go.abhg.dev/gs/internal/scriptrun"
	"go.abhg.dev/gs/internal/secret"
	"go.abhg.dev/gs/internal/sigstack"
	"go.abhg.dev/gs/internal/silog"
	"go.abhg.dev/gs/internal/spice"
	"go.abhg.dev/gs/internal/spice/state"
	"go.abhg.dev/gs/internal/ui"
	"go.abhg.dev/gs/internal/xec"
	"go.abhg.dev/komplete"
)

// Version of git-spice.
// Set by goreleaser at build time.
var _version = "dev"

var (
	// _keyringStash is the secure secret stash used by the application.
	//
	// This is overridden in tests to use a memory stash.
	_keyringStash secret.Stash = new(secret.Keyring)

	// _browserLauncher opens URLs in the user's configured browser.
	_browserLauncher browser.Launcher = new(browser.Browser)

	// Forges to registry into main at startup besides the defaults.
	_extraForges []func(*silog.Logger) forge.Definition

	_highlightStyle = ui.NewStyle().
			Foreground(ui.Cyan).
			Bold(true)
)

var errNoPrompt = ui.ErrPrompt

type secretBackend int

const (
	secretBackendAuto secretBackend = iota
	secretBackendFile
	secretBackendKeyring
)

var _ encoding.TextUnmarshaler = (*secretBackend)(nil)

func (b *secretBackend) UnmarshalText(bs []byte) error {
	switch strings.ToLower(string(bs)) {
	case "auto":
		*b = secretBackendAuto
	case "file":
		*b = secretBackendFile
	case "keyring":
		*b = secretBackendKeyring
	default:
		return fmt.Errorf(
			"invalid value %q: expected auto, file, or keyring",
			string(bs),
		)
	}

	return nil
}

func (b secretBackend) String() string {
	switch b {
	case secretBackendAuto:
		return "auto"
	case secretBackendFile:
		return "file"
	case secretBackendKeyring:
		return "keyring"
	default:
		return fmt.Sprintf("secretBackend(%d)", int(b))
	}
}

func main() {
	stderr := ui.NewOutputWriter(os.Stderr)
	logger := silog.New(&colorprofile.Writer{
		Forward: stderr,
		Profile: colorprofile.Detect(stderr.Unwrap(), os.Environ()),
	}, &silog.Options{
		Level: silog.LevelInfo,
	})

	// Register supported forges.
	var forges forge.Registry
	forges.Register(&bitbucket.Definition{Log: logger})
	forges.Register(&forgejo.Definition{Log: logger})
	forges.Register(&gitea.Definition{Log: logger})
	forges.Register(&github.Definition{Log: logger})
	forges.Register(&gitlab.Definition{Log: logger})
	for _, buildForge := range _extraForges {
		forges.Register(buildForge(logger))
	}

	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	var sigStack sigstack.Stack
	sigc := make(chan sigstack.Signal, 1)
	sigStack.Notify(sigc, os.Interrupt)
	go func() {
		select {
		case <-sigc:
			sigStack.Stop(sigc)
			logger.Info("Cleaning up. Press Ctrl-C again to exit immediately.")
			cancel()

		case <-ctx.Done():
		}
	}()

	spiceConfig, err := spice.LoadConfig(
		ctx,
		git.NewConfig(git.ConfigOptions{Log: logger}),
		spice.ConfigOptions{
			Log: logger,
		},
	)
	if err != nil {
		logger.Error("Error loading spice configuration; continuing without it.", "error", err)
	}

	var cmd mainCmd

	// Forges may register additional command line flags
	// by implementing CLIPlugin.
	for f := range forges.All() {
		if plugin := f.CLIPlugin(); plugin != nil {
			cmd.Plugins = append(cmd.Plugins, plugin)
		}
	}

	cmdName := filepath.Base(os.Args[0])
	parser, err := kong.New(&cmd,
		kong.Name(cmdName),
		kong.Description("git-spice is a command line tool for stacking Git branches."),
		kong.Resolvers(spiceConfig),
		kong.Bind(logger, &forges, &sigStack, &cmd),
		kong.BindTo(&cmd.Forge, (*forgeOptions)(nil)),
		kong.BindTo(ctx, (*context.Context)(nil)),
		kong.BindTo(spiceConfig, (*experiment.Enabler)(nil)),
		kong.Vars{
			// Default to prompting only when the terminal is interactive.
			"defaultPrompt": strconv.FormatBool(isatty.IsTerminal(os.Stdin.Fd())),
		},
		kong.UsageOnError(),
		kong.Help(helpPrinter),
		kong.Writers(os.Stdout, stderr),
	)
	if err != nil {
		panic(err)
	}

	builtinShorthands, err := shorthand.NewBuiltin(parser.Model)
	if err != nil {
		panic(err)
	}

	// user-configured shorthands take precedence over builtins.
	shorthands := shorthand.Sources{spiceConfig, builtinShorthands}

	komplete.Run(parser,
		komplete.WithTransformCompleted(func(args []string) []string {
			return shorthand.Expand(shorthands, args)
		}),
		komplete.WithPredictor("branches", komplete.PredictFunc(predictBranches)),
		komplete.WithPredictor("trackedBranches", komplete.PredictFunc(predictTrackedBranches)),
		komplete.WithPredictor("remotes", komplete.PredictFunc(predictRemotes)),
		komplete.WithPredictor("dirs", komplete.PredictFunc(predictDirs)),
		komplete.WithPredictor("forges", komplete.PredictFunc(predictForges(&forges))),
	)

	args := os.Args[1:]
	if len(args) == 0 {
		// If invoked with no arguments, show help,
		// but then exit with a non-zero status code.
		args = []string{"--help"}
		parser.Exit = func(int) {
			fmt.Fprintln(os.Stderr)
			logger.Fatalf("%v: please provide a command", cmdName)
		}
	} else if shellCmd, ok := spiceConfig.ShellCommand(args[0]); ok {
		const (
			recursionDepthLimit  = 10
			recursionDepthEnvVar = "__GS_SHELL_COMMAND_DEPTH"
		)

		var depth int
		if depthStr := os.Getenv(recursionDepthEnvVar); depthStr != "" {
			// Prevent infinite loops by limiting recursion depth.
			var err error
			depth, err = strconv.Atoi(depthStr)
			if err != nil {
				// Assume depth is 0 if invalid.
				depth = 0
			}
		}
		if depth >= recursionDepthLimit {
			logger.Fatalf("%v: shell command recursion depth limit exceeded (%d): %v",
				cmdName, recursionDepthLimit, args[0])
		}

		// The first argument might be a shell command alias.
		// If so, invoke the shell command directly and exit.
		shArgs := []string{"-c", shellCmd}
		if len(args) > 1 {
			shArgs = append(shArgs, cmdName) // $0
			shArgs = append(shArgs, args[1:]...)
		}

		if err := xec.Command(ctx, logger, "sh", shArgs...).
			WithStdin(os.Stdin).
			WithStdout(os.Stdout).
			WithStderr(os.Stderr).
			AppendEnv(fmt.Sprintf("%v=%d", recursionDepthEnvVar, depth+1)).
			Run(); err != nil {
			logger.Fatalf("%v: %v", cmdName, err)
		}
		return
	} else {
		// Otherwise, expand the shorthand,
		// parse the arguments, and proceed as usual.
		args = shorthand.Expand(shorthands, args)
	}

	kctx, err := parser.Parse(args)
	if err != nil {
		logger.Fatalf("%v: %v", cmdName, err)
	}

	if err := cmd.Profile.Start(); err != nil {
		logger.Error("Error creating trace file", "error", err)
	}

	if err := kctx.Run(builtinShorthands); err != nil {
		logger.Fatalf("%v: %v", cmdName, err)
	}

	if err := cmd.Profile.Stop(); err != nil {
		logger.Error("Error closing trace file", "error", err)
	}
}

type mainCmd struct {
	kong.Plugins
	experiment.Check

	Profile ProfileFlags `embed:""`

	// Global options that are never accessed directly by subcommands.
	Globals struct {
		// Flags with built-in side effects.
		Version       versionFlag        `help:"Print version information and quit"`
		Verbose       bool               `short:"v" help:"Enable verbose output" env:"GIT_SPICE_VERBOSE"`
		Dir           kong.ChangeDirFlag `short:"C" placeholder:"DIR" help:"Change to DIR before doing anything" predictor:"dirs"`
		Prompt        bool               `name:"prompt" negatable:"" default:"${defaultPrompt}" help:"Whether to prompt for missing information"`
		SecretBackend secretBackend      `name:"secret-backend" hidden:"" config:"secret.backend" env:"GIT_SPICE_SECRET_BACKEND" default:"auto" help:"Backend to use for secret storage."`
	} `embed:"" group:"globals"`

	Git struct {
		IndexLockTimeout time.Duration `name:"git-index-lock-timeout" hidden:"" default:"5s" config:"git.indexLockTimeout" help:"Total time to spend retrying git commands that fail due to index.lock contention. Set to 0 to disable retries."`
	} `embed:""`

	Forge forgeOptions `embed:""`

	Shell shellCmd `cmd:"" group:"Shell"`
	Auth  authCmd  `cmd:"" group:"Authentication"`

	Repo repoCmd `cmd:"" aliases:"r" group:"Repository"`
	Log  logCmd  `cmd:"" aliases:"l" group:"Log"`

	Stack     stackCmd     `cmd:"" aliases:"s" group:"Stack"`
	Upstack   upstackCmd   `cmd:"" aliases:"us" group:"Stack"`
	Downstack downstackCmd `cmd:"" aliases:"ds" group:"Stack"`

	Branch branchCmd `cmd:"" aliases:"b" group:"Branch"`
	Commit commitCmd `cmd:"" aliases:"c" group:"Commit"`

	Rebase rebaseCmd `cmd:"" aliases:"rb" group:"Rebase"`

	// Navigation
	Up     upCmd     `cmd:"" aliases:"u" group:"Navigation" help:"Move up one branch"`
	Down   downCmd   `cmd:"" aliases:"d" group:"Navigation" help:"Move down one branch"`
	Top    topCmd    `cmd:"" aliases:"U" group:"Navigation" help:"Move to the top of the stack"`
	Bottom bottomCmd `cmd:"" aliases:"D" group:"Navigation" help:"Move to the bottom of the stack"`
	Trunk  trunkCmd  `cmd:"" group:"Navigation" help:"Move to the trunk branch"`

	Version versionCmd `cmd:"" help:"Print version information and quit"`

	Internal internalCmd `cmd:"" hidden:"" help:"For internal use only."`

	// Hidden commands:
	DumpMD dumpMarkdownCmd `name:"dumpmd" hidden:"" cmd:"" help:"Dump a Markdown reference to stdout and quit"`
}

// forgeOptions defines application-wide forge selection options.
type forgeOptions struct {
	// Kind names the forge to use when a Git remote URL does not identify one.
	// It is hidden from command help because forge selection is a repository
	// or environment setting rather than a per-invocation control.
	Kind string `name:"forge-kind" hidden:"" config:"forge.kind" env:"GIT_SPICE_FORGE_KIND" configHelp:"-" help:"Forge kind to use when remote URLs do not identify a supported Git host."`
}

func (cmd *mainCmd) AfterApply(
	ctx context.Context,
	kctx *kong.Context,
	logger *silog.Logger,
	signals *sigstack.Stack,
) error {
	if cmd.Globals.Verbose {
		logger.SetLevel(silog.LevelDebug)
	}

	// On macOS, UserConfigDir always returns ~/Library/Application Support.
	// XDG_CONFIG_HOME should take precedence if set.
	userConfigDir := os.Getenv("XDG_CONFIG_HOME")
	if userConfigDir == "" {
		var err error
		userConfigDir, err = os.UserConfigDir()
		if err != nil {
			return fmt.Errorf("get user config directory: %w", err)
		}
	}

	view, err := _buildView(os.Stdin, kctx.Stderr, cmd.Globals.Prompt, signals)
	if err != nil {
		return fmt.Errorf("build view: %w", err)
	}
	kctx.BindTo(view, (*ui.View)(nil))

	insecureStash := &secret.InsecureStash{
		Path: filepath.Join(userConfigDir, "git-spice", "secrets.json"),
		Log:  logger,
	}

	var secretStash secret.Stash
	switch cmd.Globals.SecretBackend {
	case secretBackendFile:
		secretStash = insecureStash
	case secretBackendKeyring:
		secretStash = _keyringStash
	default:
		secretStash = &secret.FallbackStash{
			Primary:   _keyringStash,
			Secondary: insecureStash,
		}
	}
	kctx.BindTo(secretStash, (*secret.Stash)(nil))
	kctx.BindTo(&cmd.Forge, (*forgeOptions)(nil))

	// TODO: bind interfaces, not values
	// TODO:
	// introduce a type that defaults to the current branch
	// so that commands that don't need worktree aren't forced to use it
	// just to get the current branch name.

	return errors.Join(
		kctx.BindSingletonProvider(func() (*git.Worktree, error) {
			return git.OpenWorktree(ctx, ".", git.OpenOptions{
				Log:              logger,
				IndexLockTimeout: &cmd.Git.IndexLockTimeout,
			})
		}),
		kctx.BindSingletonProvider(func(wt *git.Worktree) (*git.Repository, error) {
			return wt.Repository(), nil
		}),
		kctx.BindSingletonProvider(func(
			repo *git.Repository,
			forges *forge.Registry,
		) *remoteResolver {
			return &remoteResolver{
				Forges:     forges,
				Repository: repo,
				ForgeKind:  cmd.Forge.Kind,
			}
		}),
		kctx.BindSingletonProvider(func(repo *git.Repository, wt *git.Worktree) (*state.Store, error) {
			return ensureStore(ctx, repo, wt, logger, view)
		}),
		kctx.BindSingletonProvider(func(
			repo *git.Repository,
			wt *git.Worktree,
			store *state.Store,
			forges *forge.Registry,
		) (*spice.Service, error) {
			return spice.NewService(repo, wt, store, forges, logger), nil
		}),
		kctx.BindSingletonProvider(func(
			log *silog.Logger,
			wt *git.Worktree,
			svc *spice.Service,
		) (AutostashHandler, error) {
			return &autostash.Handler{
				Log:      log,
				Worktree: wt,
				Service:  svc,
			}, nil
		}),
		kctx.BindSingletonProvider(func(
			log *silog.Logger,
			view ui.View,
			repo *git.Repository,
			store *state.Store,
			svc *spice.Service,
		) (TrackHandler, error) {
			return &track.Handler{
				Log:        log,
				View:       view,
				Repository: repo,
				Store:      store,
				Service:    svc,
			}, nil
		}),
		kctx.BindSingletonProvider(func(
			log *silog.Logger,
			store *state.Store,
			repo *git.Repository,
			wt *git.Worktree,
			svc *spice.Service,
			trackHandler TrackHandler,
		) (CheckoutHandler, error) {
			return &checkout.Handler{
				Stdout:     kctx.Stdout,
				Log:        log,
				Store:      store,
				Repository: repo,
				Worktree:   wt,
				Track:      trackHandler,
				Service:    svc,
			}, nil
		}),
		kctx.BindSingletonProvider(func(
			log *silog.Logger,
			store *state.Store,
			wt *git.Worktree,
			svc *spice.Service,
			secretStash secret.Stash,
			remoteResolver *remoteResolver,
		) (SubmitHandler, error) {
			return &submit.Handler{
				Log:        log,
				View:       view,
				Repository: wt.Repository(),
				Worktree:   wt,
				Store:      store,
				Service:    svc,
				Browser:    _browserLauncher,
				FindRemote: func(ctx context.Context) (state.Remote, error) {
					return ensureRemote(ctx, wt.Repository(), store, log, view)
				},
				ResolveRepository: func(ctx context.Context, remote string) (forge.Forge, forge.RepositoryID, error) {
					return resolveRemoteRepository(ctx, log, remoteResolver, remote)
				},
				OpenRepository: func(ctx context.Context, f forge.Forge, repo forge.RepositoryID) (forge.Repository, error) {
					return openRepository(ctx, log, secretStash, f, repo)
				},
			}, nil
		}),
		kctx.BindSingletonProvider(func(
			log *silog.Logger,
			worktree *git.Worktree,
			store *state.Store,
			svc *spice.Service,
		) (RestackHandler, error) {
			return &restack.Handler{
				Log:      log,
				Worktree: worktree,
				Store:    store,
				Service:  svc,
			}, nil
		}),
		kctx.BindSingletonProvider(func(
			log *silog.Logger,
			wt *git.Worktree,
			svc *spice.Service,
			restackHandler RestackHandler,
		) (OntoHandler, error) {
			return &onto.Handler{
				Log:      log,
				Worktree: wt,
				Service:  svc,
				Restack:  restackHandler,
			}, nil
		}),
		kctx.BindSingletonProvider(func(
			log *silog.Logger,
			store *state.Store,
			wt *git.Worktree,
			svc *spice.Service,
			restackHandler RestackHandler,
		) (DeleteHandler, error) {
			return &delete.Handler{
				Log:        log,
				View:       view,
				Repository: wt.Repository(),
				Worktree:   wt,
				Store:      store,
				Service:    svc,
				Restack:    restackHandler,
			}, nil
		}),
		kctx.BindSingletonProvider(func(
			log *silog.Logger,
			repo *git.Repository,
			wt *git.Worktree,
			store *state.Store,
			svc *spice.Service,
			restackHandler RestackHandler,
		) (SquashHandler, error) {
			return &squash.Handler{
				Log:        log,
				Repository: repo,
				Worktree:   wt,
				Store:      store,
				Service:    svc,
				Restack:    restackHandler,
			}, nil
		}),
		kctx.BindSingletonProvider(func(
			log *silog.Logger,
			view ui.View,
			repo *git.Repository,
			store *state.Store,
			svc *spice.Service,
			forges *forge.Registry,
		) (SplitHandler, error) {
			return &split.Handler{
				Log:        log,
				View:       view,
				Repository: repo,
				Store:      store,
				Service:    svc,
				FindForge: func(ctx context.Context, id string) (forge.Forge, bool) {
					remote, err := store.Remote()
					if err != nil {
						return nil, false
					}

					remoteURL, err := repo.RemoteURL(ctx, remote.Upstream)
					if err != nil {
						return nil, false
					}

					parsedRemoteURL, err := giturl.Parse(remoteURL)
					if err != nil {
						return nil, false
					}

					f, err := forges.New(id, parsedRemoteURL)
					return f, err == nil
				},
				HighlightStyle: _highlightStyle,
			}, nil
		}),
		kctx.BindSingletonProvider(func(
			log *silog.Logger,
			repo *git.Repository,
			wt *git.Worktree,
			restackHandler RestackHandler,
			autostashHandler AutostashHandler,
		) (CherryPickHandler, error) {
			return &cherrypick.Handler{
				Log:        log,
				Repository: repo,
				Worktree:   wt,
				Restack:    restackHandler,
				Autostash:  autostashHandler,
			}, nil
		}),
		kctx.BindSingletonProvider(func(
			log *silog.Logger,
			view ui.View,
			repo *git.Repository,
			wt *git.Worktree,
			store *state.Store,
			svc *spice.Service,
			secretStash secret.Stash,
			remoteResolver *remoteResolver,
			deleteHandler DeleteHandler,
			restackHandler RestackHandler,
			autostashHandler AutostashHandler,
		) (SyncHandler, error) {
			remote, err := ensureRemote(ctx, repo, store, log, view)
			// TODO: move ensure remote to Service
			if err != nil {
				return nil, err
			}

			remoteRepo, err := remoteResolver.Open(ctx, secretStash, remote.Upstream)
			if err != nil {
				var unsupported *unsupportedForgeError
				if !errors.As(err, &unsupported) {
					return nil, err
				}
				remoteRepo = nil
			}

			var pushRepository forge.RepositoryID
			if remote.ForkMode() {
				pushRepository, err = remoteResolver.ResolveID(ctx, remote.Push)
				if err != nil {
					return nil, fmt.Errorf("resolve push repository: %w", err)
				}
			}

			return &sync.Handler{
				Log:              log,
				View:             view,
				Repository:       repo,
				Worktree:         wt,
				Store:            store,
				Service:          svc,
				Delete:           deleteHandler,
				Restack:          restackHandler,
				Autostash:        autostashHandler,
				Remote:           remote.Upstream,
				RemoteRepository: remoteRepo,
				PushRepository:   pushRepository,
			}, nil
		}),
		kctx.BindSingletonProvider(func(
			log *silog.Logger,
			view ui.View,
			store *state.Store,
			svc *spice.Service,
			repo *git.Repository,
			remote state.Remote,
			remoteRepo *remoteRepository,
			restackHandler RestackHandler,
			submitHandler SubmitHandler,
			syncHandler SyncHandler,
			scriptRunner *scriptrun.Runner,
		) (MergeHandler, error) {
			return &merge.Handler{
				Log:                log,
				View:               view,
				Store:              store,
				Service:            svc,
				RemoteRepository:   remoteRepo.Repository,
				RemoteRepositoryID: remoteRepo.ID,
				Restack:            restackHandler,
				Submit:             submitHandler,
				Sync:               syncHandler,
				Repository:         repo,
				Remote:             remote.Upstream,
				ScriptRunner:       scriptRunner,
			}, nil
		}),
		kctx.BindSingletonProvider(func(
			remoteRepo *remoteRepository,
		) forge.Repository {
			return remoteRepo.Repository
		}),
		kctx.BindSingletonProvider(func(
			log *silog.Logger,
			secretStash secret.Stash,
			remoteResolver *remoteResolver,
			remote state.Remote,
		) (*remoteRepository, error) {
			f, repoID, err := resolveRemoteRepository(
				ctx, log, remoteResolver, remote.Upstream,
			)
			if err != nil {
				return nil, fmt.Errorf(
					"resolve remote repository %q: %w",
					remote.Upstream, err,
				)
			}
			remoteRepo, err := openRepository(
				ctx, log, secretStash, f, repoID,
			)
			if err != nil {
				return nil, fmt.Errorf("open remote repository: %w", err)
			}
			return &remoteRepository{
				Repository: remoteRepo,
				ID:         repoID,
			}, nil
		}),
		kctx.BindSingletonProvider(func(
			ctx context.Context,
			repo *git.Repository,
			store *state.Store,
			log *silog.Logger,
			view ui.View,
		) (state.Remote, error) {
			return ensureRemote(ctx, repo, store, log, view)
		}),
		kctx.BindSingletonProvider(func(log *silog.Logger) *scriptrun.Runner {
			return &scriptrun.Runner{
				Log: log,
			}
		}),
	)
}

type AutostashHandler interface {
	BeginAutostash(ctx context.Context, opts *autostash.Options) (func(*error, *autostash.CleanupOptions), error)
	RestoreAutostash(ctx context.Context, stashHash string) error
}

var _ AutostashHandler = (*autostash.Handler)(nil)

// remoteRepository keeps the opened forge repository together with the
// repository ID that produced it.
// The command wiring needs the opened repository for forge operations,
// while merge planning uses the repository ID to format change URLs
// without making another forge API request.
type remoteRepository struct {
	Repository forge.Repository
	ID         forge.RepositoryID
}

var _buildView = func(
	stdin io.Reader,
	stderr io.Writer,
	interactive bool,
	signals *sigstack.Stack,
) (ui.View, error) {
	if interactive {
		return ui.NewTerminalView(stdin, stderr).WithSignals(signals), nil
	}
	return ui.NewFileView(stderr), nil
}