feat(nnctl): use cobra for CLI help

Signed-off-by: Ville Vesilehto <ville@vesilehto.fi>

Author: thevilledev

nnctl/go.mod

@@ -1,3 +1,10 @@
 module nnctl
 
 go 1.26
+
+require github.com/spf13/cobra v1.10.2
+
+require (
+	github.com/inconshreveable/mousetrap v1.1.0 // indirect
+	github.com/spf13/pflag v1.0.9 // indirect
+)

nnctl/go.sum

@@ -0,0 +1,10 @@
+github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
+github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
+github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
+github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/spf13/cobra v1.10.2 h1:DMTTonx5m65Ic0GOoRY2c16WCbHxOOw6xxezuLaBpcU=
+github.com/spf13/cobra v1.10.2/go.mod h1:7C1pvHqHw5A4vrJfjNwvOdzYu0Gml16OCs2GRiTUUS4=
+github.com/spf13/pflag v1.0.9 h1:9exaQaMOCwffKiiiYk6/BndUBv+iRViNW+4lEMi0PvY=
+github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=

nnctl/internal/cli/app.go

@@ -2,15 +2,10 @@ package cli
 
 import (
 	"context"
-	"errors"
-	"flag"
 	"fmt"
 	"io"
 	"os"
-	"runtime"
 	"strings"
-
-	"nnctl/internal/repo"
 )
 
 const (
@@ -41,77 +36,9 @@ func Main(args []string) int {
 }
 
 func (a *App) Run(ctx context.Context, args []string) error {
-	global := flag.NewFlagSet("nnctl", flag.ContinueOnError)
-	global.SetOutput(a.stderr())
-
-	repoRoot := ""
-	zig := getenvDefault("ZIG", "zig")
-	global.StringVar(&repoRoot, "repo", "", "repository root to operate on")
-	global.StringVar(&repoRoot, "C", "", "repository root to operate on")
-	global.StringVar(&zig, "zig", zig, "Zig executable to use")
-
-	if err := global.Parse(args); err != nil {
-		if errors.Is(err, flag.ErrHelp) {
-			printUsage(a.stdout())
-			return nil
-		}
-		return err
-	}
-
-	rest := global.Args()
-	if len(rest) == 0 {
-		printUsage(a.stdout())
-		return nil
-	}
-
-	command := rest[0]
-	commandArgs := rest[1:]
-	if command == "help" || command == "-h" || command == "--help" {
-		printHelp(a.stdout(), commandArgs)
-		return nil
-	}
-	if command == "version" {
-		fmt.Fprintf(a.stdout(), "nnctl dev (%s)\n", runtime.Version())
-		return nil
-	}
-
-	root, err := repo.ResolveRoot(repoRoot)
-	if err != nil {
-		return err
-	}
-	a.repoRoot = root
-	a.zig = zig
-
-	switch command {
-	case "all":
-		return a.cmdAll(ctx, commandArgs)
-	case "build":
-		return a.cmdBuild(ctx, commandArgs, false)
-	case "release":
-		return a.cmdBuild(ctx, commandArgs, true)
-	case "test":
-		return a.cmdTest(ctx, commandArgs)
-	case "examples":
-		return a.cmdExamples(ctx, commandArgs)
-	case "run":
-		return a.cmdRun(ctx, commandArgs)
-	case "train":
-		return a.cmdTrain(ctx, commandArgs)
-	case "chat":
-		return a.cmdChat(ctx, commandArgs)
-	case "list":
-		return a.cmdList(commandArgs)
-	case "fmt", "format":
-		return a.cmdFormat(ctx, commandArgs)
-	case "clean":
-		return a.cmdClean(commandArgs)
-	case "data":
-		return a.cmdData(ctx, commandArgs)
-	case "doctor", "env":
-		return a.cmdDoctor(ctx, commandArgs)
-	default:
-		return fmt.Errorf("unknown command %q; run nnctl help", command)
-	}
+	root := a.newRootCommand()
+	root.SetArgs(args)
+	return root.ExecuteContext(ctx)
 }
 
 func (a *App) stdout() io.Writer {
@@ -135,12 +62,6 @@ func (a *App) stdin() io.Reader {
 	return a.Stdin
 }
 
-func newFlagSet(out io.Writer, name string) *flag.FlagSet {
-	fs := flag.NewFlagSet(name, flag.ContinueOnError)
-	fs.SetOutput(out)
-	return fs
-}
-
 func getenvDefault(key, fallback string) string {
 	if value := os.Getenv(key); value != "" {
 		return value

nnctl/internal/cli/chat.go

@@ -13,96 +13,77 @@ import (
 	"strconv"
 	"time"
 
-	"nnctl/internal/flagx"
 	"nnctl/internal/zig"
 )
 
-func (a *App) cmdChat(ctx context.Context, args []string) error {
-	fs := newFlagSet(a.stderr(), "chat")
-	mode := getenvDefault("NNCTL_OPTIMIZE", getenvDefault("BUILD_MODE", defaultBuildMode))
-	host := "127.0.0.1"
-	port := 8090
-	apiHost := "127.0.0.1"
-	apiPort := 8080
-	modelPath := ""
-	modelName := "tiny-gpt-zig"
-	maxTokens := 120
-	temperature := 1.0
-	topK := 8
-	allowUntrained := false
-	readyTimeoutText := "2m"
-
-	fs.StringVar(&mode, "mode", mode, "Zig optimization mode")
-	fs.StringVar(&mode, "optimize", mode, "Zig optimization mode")
-	fs.StringVar(&host, "host", host, "chat app bind host")
-	fs.IntVar(&port, "port", port, "chat app bind port")
-	fs.StringVar(&apiHost, "api-host", apiHost, "TinyGPT inference bind host")
-	fs.IntVar(&apiPort, "api-port", apiPort, "TinyGPT inference bind port")
-	fs.StringVar(&modelPath, "model", modelPath, "TinyGPT checkpoint to serve")
-	fs.StringVar(&modelName, "model-name", modelName, "OpenAI-compatible model id")
-	fs.IntVar(&maxTokens, "max-tokens", maxTokens, "default generated tokens per reply")
-	fs.Float64Var(&temperature, "temperature", temperature, "default sampling temperature")
-	fs.IntVar(&topK, "top-k", topK, "default TinyGPT top-k sampler cutoff")
-	fs.BoolVar(&allowUntrained, "allow-untrained", allowUntrained, "serve a seeded untrained model when --model is omitted")
-	fs.StringVar(&readyTimeoutText, "ready-timeout", readyTimeoutText, "time to wait for inference server readiness")
+type chatOptions struct {
+	mode             string
+	host             string
+	port             int
+	apiHost          string
+	apiPort          int
+	modelPath        string
+	modelName        string
+	maxTokens        int
+	temperature      float64
+	topK             int
+	allowUntrained   bool
+	readyTimeoutText string
+}
 
-	if err := flagx.ParseInterspersed(fs, args, map[string]bool{
-		"mode":            true,
-		"optimize":        true,
-		"host":            true,
-		"port":            true,
-		"api-host":        true,
-		"api-port":        true,
-		"model":           true,
-		"model-name":      true,
-		"max-tokens":      true,
-		"temperature":     true,
-		"top-k":           true,
-		"allow-untrained": false,
-		"ready-timeout":   true,
-	}); err != nil {
-		return err
+func defaultChatOptions() chatOptions {
+	return chatOptions{
+		mode:             getenvDefault("NNCTL_OPTIMIZE", getenvDefault("BUILD_MODE", defaultBuildMode)),
+		host:             "127.0.0.1",
+		port:             8090,
+		apiHost:          "127.0.0.1",
+		apiPort:          8080,
+		modelName:        "tiny-gpt-zig",
+		maxTokens:        120,
+		temperature:      1.0,
+		topK:             8,
+		readyTimeoutText: "2m",
 	}
-	if fs.NArg() != 0 {
-		return fmt.Errorf("chat does not accept positional arguments")
-	}
-	if modelPath == "" && !allowUntrained {
+}
+
+func (a *App) runChat(ctx context.Context, opts chatOptions) error {
+	if opts.modelPath == "" && !opts.allowUntrained {
 		return fmt.Errorf("chat requires --model <checkpoint> or --allow-untrained")
 	}
-	if port <= 0 || port > 65535 {
+	if opts.port <= 0 || opts.port > 65535 {
 		return fmt.Errorf("--port must be between 1 and 65535")
 	}
-	if apiPort <= 0 || apiPort > 65535 {
+	if opts.apiPort <= 0 || opts.apiPort > 65535 {
 		return fmt.Errorf("--api-port must be between 1 and 65535")
 	}
-	if maxTokens < 0 {
+	if opts.maxTokens < 0 {
 		return fmt.Errorf("--max-tokens must be non-negative")
 	}
-	if topK < 0 {
+	if opts.topK < 0 {
 		return fmt.Errorf("--top-k must be non-negative")
 	}
 
-	readyTimeout, err := time.ParseDuration(readyTimeoutText)
+	readyTimeout, err := time.ParseDuration(opts.readyTimeoutText)
 	if err != nil {
 		return fmt.Errorf("parse --ready-timeout: %w", err)
 	}
 
-	apiBaseURL := "http://" + net.JoinHostPort(apiHost, strconv.Itoa(apiPort))
+	apiBaseURL := "http://" + net.JoinHostPort(opts.apiHost, strconv.Itoa(opts.apiPort))
 	serverArgs := []string{
-		"--host", apiHost,
-		"--port", strconv.Itoa(apiPort),
-		"--model-name", modelName,
-		"--max-tokens", strconv.Itoa(maxTokens),
-		"--temperature", strconv.FormatFloat(temperature, 'f', -1, 64),
-		"--top-k", strconv.Itoa(topK),
+		"--host", opts.apiHost,
+		"--port", strconv.Itoa(opts.apiPort),
+		"--model-name", opts.modelName,
+		"--max-tokens", strconv.Itoa(opts.maxTokens),
+		"--temperature", strconv.FormatFloat(opts.temperature, 'f', -1, 64),
+		"--top-k", strconv.Itoa(opts.topK),
 	}
-	if modelPath != "" {
-		serverArgs = append(serverArgs, "--model", modelPath)
+	if opts.modelPath != "" {
+		serverArgs = append(serverArgs, "--model", opts.modelPath)
 	} else {
 		serverArgs = append(serverArgs, "--allow-untrained")
 	}
 
-	runArgs := zig.RunArgs("run_tiny_gpt_openai", zig.Options{Optimize: mode}, serverArgs)
+	runArgs := zig.RunArgs("run_tiny_gpt_openai", zig.Options{Optimize: opts.mode}, serverArgs)
 	fmt.Fprintf(a.stderr(), "==> %s\n", zig.CommandString(a.zig, runArgs))
 	serverCmd := exec.CommandContext(ctx, a.zig, runArgs...)
 	serverCmd.Dir = a.repoRoot
@@ -131,13 +112,13 @@ func (a *App) cmdChat(ctx context.Context, args []string) error {
 	mux.HandleFunc("/", serveChatApp)
 	mux.Handle("/api/chat", chatProxy{
 		apiBaseURL:  apiBaseURL,
-		modelName:   modelName,
-		maxTokens:   maxTokens,
-		temperature: temperature,
+		modelName:   opts.modelName,
+		maxTokens:   opts.maxTokens,
+		temperature: opts.temperature,
 		client:      &http.Client{Timeout: 2 * time.Minute},
 	})
 
-	chatAddr := net.JoinHostPort(host, strconv.Itoa(port))
+	chatAddr := net.JoinHostPort(opts.host, strconv.Itoa(opts.port))
 	chatServer := &http.Server{
 		Addr:              chatAddr,
 		Handler:           mux,