Move the command tree into internal/cli (closes #8)

cmd/simplexcalc/ now holds only main.go: it passes the version the
linker sets to cli.Main and exits with the status that returns. root.go
and run.go move to internal/cli with their comments, changed only to
take the version as a parameter. Main reads the process's arguments and
output; execute takes them as parameters so the new tests can check the
version line and the non-zero status of an unknown command. Commands,
flags, output, log lines and exit status are unchanged, and the
-X main.version flag in the Dockerfile still applies.

Model: opus-5-5

internal/cli/cli.go

@@ -0,0 +1,38 @@
+// Package cli is the simplexcalc command tree: the run and version
+// commands, and the exit status the program ends with.
+package cli
+
+import (
+	"fmt"
+	"io"
+	"os"
+)
+
+// appname is the name the program reports in its logs and its version.
+const appname = "simplexcalc"
+
+// Main runs the command named on the command line and returns the exit
+// status for main to pass to os.Exit.
+func Main(version string) int {
+	return execute(version, os.Args[1:], os.Stdout, os.Stderr)
+}
+
+// execute is Main with the arguments and the output passed in, so that
+// a test can supply them.
+func execute(version string, args []string, stdout, stderr io.Writer) int {
+	root := rootCmd(version)
+	root.SetArgs(args)
+	root.SetOut(stdout)
+	root.SetErr(stderr)
+
+	err := root.Execute()
+	if err != nil {
+		// cobra has already printed the error; this only sets the exit
+		// status, which is what a supervisor and a shell script read.
+		_, _ = fmt.Fprintln(stderr, "exiting: "+err.Error())
+
+		return 1
+	}
+
+	return 0
+}

internal/cli/cli_test.go

@@ -0,0 +1,41 @@
+package cli_test
+
+import (
+	"bytes"
+	"runtime"
+	"strings"
+	"testing"
+
+	"sneak.berlin/go/simplexcalc/internal/cli"
+)
+
+func TestVersionPrintsVersion(t *testing.T) {
+	t.Parallel()
+
+	var stdout, stderr bytes.Buffer
+
+	status := cli.Execute("1.2.3", []string{"version"}, &stdout, &stderr)
+	if status != 0 {
+		t.Fatalf("status = %d, want 0; stderr: %q", status, stderr.String())
+	}
+
+	want := "simplexcalc 1.2.3 " + runtime.GOOS + "/" + runtime.GOARCH + "\n"
+	if stdout.String() != want {
+		t.Errorf("stdout = %q, want %q", stdout.String(), want)
+	}
+}
+
+func TestUnknownCommandFails(t *testing.T) {
+	t.Parallel()
+
+	var stdout, stderr bytes.Buffer
+
+	status := cli.Execute("1.2.3", []string{"frobnicate"}, &stdout, &stderr)
+	if status == 0 {
+		t.Fatal("status = 0, want non-zero")
+	}
+
+	if !strings.HasPrefix(stderr.String(), "exiting: ") {
+		t.Errorf("stderr = %q, want the error after \"exiting: \"", stderr.String())
+	}
+}

internal/cli/export_test.go

@@ -0,0 +1,7 @@
+package cli
+
+// Execute is execute, exported for the external test package, which
+// needs to supply the arguments and read the output.
+//
+//nolint:gochecknoglobals // a test seam, not mutable state.
+var Execute = execute

internal/cli/root.go

@@ -0,0 +1,49 @@
+package cli
+
+import (
+	"fmt"
+	"runtime"
+
+	"github.com/spf13/cobra"
+)
+
+// rootCmd builds the command tree. Configuration comes from the
+// environment (see internal/config), not from flags: the bot runs in a
+// container, where the environment is the interface, and one source of
+// truth means there is no precedence rule to get wrong.
+func rootCmd(version string) *cobra.Command {
+	root := &cobra.Command{
+		Use:   appname,
+		Short: appname + " — a SimpleX Chat bot that answers arithmetic",
+		Long: appname + " is a SimpleX Chat bot that answers arithmetic.\n\n" +
+			"It runs the simplex-chat command-line client, which must be on\n" +
+			"PATH. Configuration is read from the environment and from an\n" +
+			"optional .env file in the working directory. See README.md\n" +
+			"for the full list of variables.",
+		SilenceUsage: true,
+		// Without this, cobra prints the error itself and main prints
+		// it again.
+		SilenceErrors: true,
+	}
+
+	root.AddCommand(runCmd(version), versionCmd(version))
+
+	return root
+}
+
+func versionCmd(version string) *cobra.Command {
+	return &cobra.Command{
+		Use:   "version",
+		Short: "print the version and exit",
+		Args:  cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			_, err := fmt.Fprintf(cmd.OutOrStdout(), "%s %s %s/%s\n",
+				appname, version, runtime.GOOS, runtime.GOARCH)
+			if err != nil {
+				return fmt.Errorf("writing version: %w", err)
+			}
+
+			return nil
+		},
+	}
+}

internal/cli/run.go

@@ -0,0 +1,58 @@
+package cli
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/signal"
+	"runtime"
+	"syscall"
+
+	"github.com/spf13/cobra"
+	"sneak.berlin/go/simplexcalc/internal/bot"
+	"sneak.berlin/go/simplexcalc/internal/config"
+	"sneak.berlin/go/simplexcalc/internal/logger"
+)
+
+func runCmd(version string) *cobra.Command {
+	return &cobra.Command{
+		Use:   "run",
+		Short: "run the bot",
+		Args:  cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			return run(cmd.Context(), version)
+		},
+	}
+}
+
+// run reads the configuration and runs the bot until SIGINT or SIGTERM,
+// or until it fails. A failure is the process's exit status, so a
+// supervisor restarts it.
+func run(ctx context.Context, version string) error {
+	cfg, err := config.New()
+	if err != nil {
+		return fmt.Errorf("reading configuration: %w", err)
+	}
+
+	log := logger.New(os.Stdout, cfg.Debug)
+	log.Info("starting",
+		"appname", appname,
+		"version", version,
+		"arch", runtime.GOARCH,
+		"data_dir", cfg.DataDir,
+	)
+
+	ctx, stop := signal.NotifyContext(ctx, syscall.SIGINT, syscall.SIGTERM)
+	defer stop()
+
+	err = bot.Run(ctx, log, cfg.DataDir)
+	if err != nil {
+		log.Error("stopped", "error", err)
+
+		return err
+	}
+
+	log.Info("stopped")
+
+	return nil
+}