fix: unknown command handling

Author: ivklgn

cmd/root.go

@@ -23,6 +23,45 @@ func cleanVersion(v string) string {
 	return v
 }
 
+// FormatExecuteError returns styled output for known cobra errors
+// (unknown command, unknown flag). Returns empty string for unrecognized errors.
+func FormatExecuteError(err error) string {
+	if err == nil {
+		return ""
+	}
+	msg := err.Error()
+
+	var b strings.Builder
+
+	switch {
+	case strings.HasPrefix(msg, "unknown command"):
+		lines := strings.SplitN(msg, "\n", 2)
+		b.WriteString(display.FailLine(lines[0]))
+		if len(lines) > 1 {
+			// Preserve cobra's "Did you mean this?" suggestion lines
+			for line := range strings.SplitSeq(lines[1], "\n") {
+				trimmed := strings.TrimSpace(line)
+				if trimmed != "" {
+					b.WriteString("\n")
+					b.WriteString(display.HintLine(trimmed))
+				}
+			}
+		}
+		b.WriteString("\n")
+		b.WriteString(display.HintLine("Run 'archcore --help' to see available commands"))
+		return b.String()
+
+	case strings.HasPrefix(msg, "unknown flag"), strings.HasPrefix(msg, "unknown shorthand flag"):
+		b.WriteString(display.FailLine(msg))
+		b.WriteString("\n")
+		b.WriteString(display.HintLine("Run 'archcore --help' to see available options"))
+		return b.String()
+
+	default:
+		return ""
+	}
+}
+
 func NewRootCmd(version string) *cobra.Command {
 	cleaned := cleanVersion(version)
 	root := &cobra.Command{
@@ -32,22 +71,22 @@ func NewRootCmd(version string) *cobra.Command {
 		SilenceErrors: true,
 		SilenceUsage:  true,
 		Run: func(cmd *cobra.Command, args []string) {
-			fmt.Println(display.WelcomeBanner())
-			fmt.Println()
+			fmt.Fprintln(cmd.OutOrStdout(), display.WelcomeBanner())
+			fmt.Fprintln(cmd.OutOrStdout())
 			_ = cmd.Usage()
 		},
 		CompletionOptions: cobra.CompletionOptions{
 			DisableDefaultCmd: true,
 		},
 	}
 
-	root.SetVersionTemplate(fmt.Sprintf("%s\n", cleaned))
+	root.SetVersionTemplate("{{.Version}}\n")
 
 	defaultHelp := root.HelpFunc()
 	root.SetHelpFunc(func(cmd *cobra.Command, args []string) {
 		if cmd == root {
-			fmt.Println(display.WelcomeBanner())
-			fmt.Println()
+			fmt.Fprintln(cmd.OutOrStdout(), display.WelcomeBanner())
+			fmt.Fprintln(cmd.OutOrStdout())
 			_ = cmd.Usage()
 			return
 		}

cmd/root_test.go

@@ -1,6 +1,10 @@
 package cmd
 
-import "testing"
+import (
+	"errors"
+	"strings"
+	"testing"
+)
 
 func TestCleanVersion(t *testing.T) {
 	tests := []struct {
@@ -25,3 +29,95 @@ func TestCleanVersion(t *testing.T) {
 		})
 	}
 }
+
+func TestFormatExecuteError(t *testing.T) {
+	tests := []struct {
+		name       string
+		err        error
+		wantEmpty  bool
+		wantSubstr []string
+	}{
+		{
+			name:      "nil error",
+			err:       nil,
+			wantEmpty: true,
+		},
+		{
+			name:       "unknown command",
+			err:        errors.New(`unknown command "foo" for "archcore"`),
+			wantSubstr: []string{`unknown command "foo"`, "--help", "available commands"},
+		},
+		{
+			name:       "unknown command with suggestion",
+			err:        errors.New("unknown command \"ini\" for \"archcore\"\n\nDid you mean this?\n\tinit"),
+			wantSubstr: []string{`unknown command "ini"`, "Did you mean this?", "init", "--help"},
+		},
+		{
+			name:       "unknown flag",
+			err:        errors.New("unknown flag: --bogus"),
+			wantSubstr: []string{"unknown flag: --bogus", "--help", "available options"},
+		},
+		{
+			name:       "unknown shorthand flag",
+			err:        errors.New(`unknown shorthand flag: 'x' in -x`),
+			wantSubstr: []string{"unknown shorthand flag", "--help", "available options"},
+		},
+		{
+			name:      "unrelated error",
+			err:       errors.New("something else went wrong"),
+			wantEmpty: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := FormatExecuteError(tt.err)
+			if tt.wantEmpty {
+				if got != "" {
+					t.Errorf("expected empty string, got %q", got)
+				}
+				return
+			}
+			for _, sub := range tt.wantSubstr {
+				if !strings.Contains(got, sub) {
+					t.Errorf("output missing %q\ngot: %s", sub, got)
+				}
+			}
+		})
+	}
+}
+
+func TestUnknownCommandOutput(t *testing.T) {
+	root := NewRootCmd("test")
+	root.SetArgs([]string{"foo"})
+
+	err := root.ExecuteContext(t.Context())
+	if err == nil {
+		t.Fatal("expected error for unknown command")
+	}
+
+	msg := FormatExecuteError(err)
+	if !strings.Contains(msg, `"foo"`) {
+		t.Errorf("output should mention the unknown command, got: %s", msg)
+	}
+	if !strings.Contains(msg, "--help") {
+		t.Errorf("output should mention --help, got: %s", msg)
+	}
+}
+
+func TestUnknownFlagOutput(t *testing.T) {
+	root := NewRootCmd("test")
+	root.SetArgs([]string{"--bogus"})
+
+	err := root.ExecuteContext(t.Context())
+	if err == nil {
+		t.Fatal("expected error for unknown flag")
+	}
+
+	msg := FormatExecuteError(err)
+	if !strings.Contains(msg, "--bogus") {
+		t.Errorf("output should mention the unknown flag, got: %s", msg)
+	}
+	if !strings.Contains(msg, "--help") {
+		t.Errorf("output should mention --help, got: %s", msg)
+	}
+}

main.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"context"
+	"fmt"
 	"os"
 	"os/signal"
 	"runtime/debug"
@@ -32,6 +33,11 @@ func main() {
 	resolveVersion()
 
 	if err := cmd.NewRootCmd(version).ExecuteContext(ctx); err != nil {
+		if msg := cmd.FormatExecuteError(err); msg != "" {
+			fmt.Println(msg)
+		} else {
+			fmt.Fprintln(os.Stderr, err)
+		}
 		os.Exit(1)
 	}
 }