Improve command normalization and test coverage

Refine flag handling for go, tar, and stow handlers to better support
subshells and fused arguments. Expand test suites across all handlers to
cover edge cases like trailing flags, subshell values, and shell
redirection.

Author: micthiesen

.github/workflows/ci.yml

@@ -14,6 +14,7 @@ jobs:
       - uses: actions/setup-go@v5
         with:
           go-version-file: go.mod
+          cache: false
 
       - name: Check formatting
         run: test -z "$(gofmt -l .)"

handler_dmesg_test.go

@@ -42,6 +42,19 @@ func TestDmesg(t *testing.T) {
 		{"human with facility", "dmesg -H -f kern", "dmesg -H -f <facility>"},
 		{"kernel json", "dmesg -kJ", "dmesg -kJ"},
 
+		// Subshell as standalone token (hits isSubshellToken in main loop)
+		{"subshell token", "dmesg $(get-flags)", "dmesg $(get-flags)"},
+
+		// Subshell as argument to each flag category
+		{"level subshell", "dmesg -l $(get-level)", "dmesg -l $(get-level)"},
+		{"facility subshell", "dmesg -f $(get-facility)", "dmesg -f $(get-facility)"},
+		{"size subshell", "dmesg -s $(calc-size)", "dmesg -s $(calc-size)"},
+		{"since subshell", "dmesg --since $(date-cmd)", "dmesg --since $(date-cmd)"},
+		{"time-format subshell", "dmesg --time-format $(get-fmt)", "dmesg --time-format $(get-fmt)"},
+
+		// Unexpected positional argument
+		{"positional path", "dmesg /var/log/messages", "dmesg <path>"},
+
 		// Redirect
 		{"redirect", "dmesg > /tmp/kern.log", "dmesg > <path>"},
 		{"pipe grep", "dmesg -T | grep error", "dmesg -T | grep <pattern>"},

handler_free_test.go

@@ -45,6 +45,26 @@ func TestFree(t *testing.T) {
 		{"seconds equals", "free --seconds=5", "free --seconds=<val>"},
 		{"count equals", "free --count=10", "free --count=<val>"},
 
+		// Consuming flag at end of input (no value follows)
+		{"seconds short trailing", "free -s", "free -s"},
+		{"count short trailing", "free -c", "free -c"},
+		{"seconds long trailing", "free --seconds", "free --seconds"},
+		{"count long trailing", "free --count", "free --count"},
+
+		// Combined flag ending in consuming letter at end of input
+		{"combined trailing s", "free -hs", "free -hs"},
+		{"combined trailing c", "free -hc", "free -hc"},
+
+		// Combined flag ending in consuming letter with subshell value
+		{"combined s subshell", "free -hs $(calc)", "free -hs $(calc)"},
+		{"combined c subshell", "free -hc $(calc)", "free -hc $(calc)"},
+
+		// Subshell as standalone token
+		{"subshell standalone", "free $(flags)", "free $(flags)"},
+
+		// Consuming flag with subshell value
+		{"count subshell", "free -c $(echo 5)", "free -c $(echo <str>)"},
+
 		// Edge cases
 		{"redirect", "free -h > output.txt", "free -h > <path>"},
 		{"pipe ignored in shape", "free -m", "free -m"},

handler_go.go

@@ -118,22 +118,22 @@ func handleGoTest(tokens []string) []string {
 		"-fuzztime": true,
 	}
 	pathFlags := map[string]bool{
-		"-coverprofile":  true,
-		"-cpuprofile":    true,
-		"-memprofile":    true,
-		"-mutexprofile":  true,
-		"-blockprofile":  true,
-		"-trace":         true,
-		"-outputdir":     true,
-		"-o":             true,
+		"-coverprofile": true,
+		"-cpuprofile":   true,
+		"-memprofile":   true,
+		"-mutexprofile": true,
+		"-blockprofile": true,
+		"-trace":        true,
+		"-outputdir":    true,
+		"-o":            true,
 	}
 	valFlags := map[string]bool{
-		"-covermode":       true,
-		"-coverpkg":        true,
-		"-benchtime":       true,
-		"-cpu":             true,
-		"-blockprofilerate": true,
-		"-memprofilerate":  true,
+		"-covermode":            true,
+		"-coverpkg":             true,
+		"-benchtime":            true,
+		"-cpu":                  true,
+		"-blockprofilerate":     true,
+		"-memprofilerate":       true,
 		"-mutexprofilefraction": true,
 	}
 	// merge build val flags
@@ -398,18 +398,18 @@ func handleGoMod(tokens []string) []string {
 
 	// go mod edit flags that consume a value
 	modEditValFlags := map[string]bool{
-		"-replace":    true,
-		"-require":    true,
+		"-replace":     true,
+		"-require":     true,
 		"-dropreplace": true,
 		"-droprequire": true,
-		"-exclude":    true,
+		"-exclude":     true,
 		"-dropexclude": true,
-		"-retract":    true,
+		"-retract":     true,
 		"-dropretract": true,
-		"-go":         true,
-		"-toolchain":  true,
-		"-json":       true,
-		"-fmt":        true,
+		"-go":          true,
+		"-toolchain":   true,
+		"-json":        true,
+		"-fmt":         true,
 	}
 
 	var result []string
@@ -532,33 +532,63 @@ func handleGoList(tokens []string) []string {
 	return result
 }
 
+// Flags for go tool subcommands (cover, pprof, trace) that consume a path arg.
+var goToolPathFlags = map[string]bool{
+	"-func": true, "-html": true, "-o": true,
+	"-http": true, // pprof: -http :8080 (actually a listen addr, but collapse)
+}
+
 func handleGoTool(tokens []string) []string {
 	args, redirects := splitRedirects(tokens)
 
 	var result []string
 	seenTool := false
-	for i := 0; i < len(args); i++ {
+	i := 0
+	for i < len(args) {
 		tok := args[i]
 
 		if isSubshellToken(tok) {
 			result = append(result, tok)
+			i++
+			continue
+		}
+
+		// Handle fused -flag=value (e.g. -func=/tmp/cov.out)
+		if isFlagToken(tok) && strings.Contains(tok, "=") {
+			eqIdx := strings.IndexByte(tok, '=')
+			key := tok[:eqIdx]
+			if goToolPathFlags[key] {
+				result = append(result, key+"=<path>")
+			} else {
+				result = append(result, classifyToken(tok))
+			}
+			i++
+			continue
+		}
+
+		// Handle separate -flag value
+		if goToolPathFlags[tok] {
+			result, i = consumeFlagArg(tok, args, i, result, "<path>")
 			continue
 		}
 
 		if isFlagToken(tok) {
 			result = append(result, tok)
+			i++
 			continue
 		}
 
 		if !seenTool {
-			// First positional is the tool name (pprof, trace, dist) — structural
+			// First positional is the tool name (cover, pprof, trace, dist) — structural
 			result = append(result, tok)
 			seenTool = true
+			i++
 			continue
 		}
 
 		// After tool name, classify remaining tokens
 		result = append(result, classifyToken(tok))
+		i++
 	}
 
 	result = append(result, redirects...)

handler_go_test.go

@@ -128,6 +128,11 @@ func TestGo(t *testing.T) {
 		{"tool trace", "go tool trace trace.out", "go tool trace <dotted-id>"},
 		{"tool pprof path", "go tool pprof ./cpu.prof", "go tool pprof <path>"},
 		{"tool dist list", "go tool dist list", "go tool dist list"},
+		{"tool cover func fused", "go tool cover -func=/tmp/cov.out", "go tool cover -func=<path>"},
+		{"tool cover html fused", "go tool cover -html=/tmp/cov.out -o /tmp/cov.html", "go tool cover -html=<path> -o <path>"},
+		{"tool cover func separate", "go tool cover -func /tmp/cov.out", "go tool cover -func <path>"},
+		{"tool cover func subshell", "go tool cover -func $(get-file)", "go tool cover -func $(get-file)"},
+		{"tool cover unknown fused", "go tool cover -cpuprofile=cpu.out", "go tool cover -cpuprofile=cpu.out"},
 
 		// Shared build flags across subcommands
 		{"build p flag", "go build -p 4 .", "go build -p N ."},
@@ -139,6 +144,106 @@ func TestGo(t *testing.T) {
 		{"test stderr redirect", "go test ./... 2>&1", "go test <path> 2>&1"},
 		{"vet stderr", "go vet ./... 2>&1", "go vet <path> 2>&1"},
 
+		// Fused flag forms (go test specific)
+		{"test run=pattern fused", "go test -run=TestFoo ./...", "go test -run=<pattern> <path>"},
+		{"test coverprofile=path fused", "go test -coverprofile=cov.out ./...", "go test -coverprofile=<path> <path>"},
+		{"test coverpkg=val fused", "go test -coverpkg=./pkg/... ./...", "go test -coverpkg=<val> <path>"},
+
+		// Subshell in flag argument positions
+		{"test run subshell", "go test -run $(get-pattern) ./...", "go test -run $(get-pattern) <path>"},
+		{"test timeout subshell", "go test -timeout $(calc-timeout) ./...", "go test -timeout $(calc-timeout) <path>"},
+		{"test coverprofile subshell", "go test -coverprofile $(mktemp) ./...", "go test -coverprofile $(mktemp) <path>"},
+		{"test count subshell", "go test -count $(nproc) ./...", "go test -count $(nproc) <path>"},
+		{"test coverpkg subshell", "go test -coverpkg $(get-pkg) ./...", "go test -coverpkg $(get-pkg) <path>"},
+		{"build ldflags subshell", "go build -ldflags $(gen-flags) .", "go build -ldflags $(gen-flags) ."},
+		{"build o subshell", "go build -o $(get-path) .", "go build -o $(get-path) ."},
+
+		// Trailing flag with no arg
+		{"test trailing run", "go test -run", "go test -run"},
+		{"test trailing count", "go test -count", "go test -count"},
+
+		// go run edge cases
+		{"run subshell file", "go run $(find-main)", "go run $(find-main)"},
+		{"run with build flags", "go run -tags integration ./cmd/app arg1 arg2", "go run -tags <val> <path> arg1 arg2"},
+		{"run ldflags", "go run -ldflags \"-X main.v=1\" main.go", "go run -ldflags <val> <path>"},
+		{"run p flag", "go run -p 2 main.go", "go run -p N <path>"},
+		{"run subshell in flags", "go run -tags $(get-tags) main.go", "go run -tags $(get-tags) <path>"},
+
+		// go install edge cases
+		{"install with tags", "go install -tags netgo ./cmd/server", "go install -tags <val> <path>"},
+		{"install subshell", "go install $(get-pkg)", "go install $(get-pkg)"},
+		{"install ldflags", "go install -ldflags \"-s\" golang.org/x/tools/gopls@latest", "go install -ldflags <val> golang.org/x/tools/gopls@latest"},
+		{"install p flag", "go install -p 4 ./cmd/app", "go install -p N <path>"},
+
+		// go get edge cases
+		{"get subshell", "go get $(cat go.mod-dep)", "go get $(cat go.mod-dep)"},
+		{"get relative path", "go get ../other-module", "go get <path>"},
+
+		// go mod edge cases
+		{"mod edit subshell", "go mod edit -replace $(gen-replace)", "go mod edit -replace $(gen-replace)"},
+		{"mod subshell positional", "go mod why $(get-dep)", "go mod why $(get-dep)"},
+		{"mod edit go flag", "go mod edit -go 1.21", "go mod edit -go <val>"},
+		{"mod edit dropexclude", "go mod edit -dropexclude github.com/old/dep@v1.0", "go mod edit -dropexclude <val>"},
+		{"mod edit trailing flag", "go mod edit -require", "go mod edit -require"},
+
+		// go doc edge cases
+		{"doc subshell", "go doc $(get-symbol)", "go doc $(get-symbol)"},
+
+		// go env edge cases
+		{"env subshell", "go env $(get-var)", "go env $(get-var)"},
+		{"env multiple set", "go env -w GOBIN=/usr/local/bin GOPROXY=direct", "go env -w GOBIN=<val> GOPROXY=<val>"},
+
+		// go list edge cases
+		{"list with tags", "go list -tags integration ./...", "go list -tags <val> <path>"},
+		{"list subshell", "go list $(get-pattern)", "go list $(get-pattern)"},
+		{"list f subshell", "go list -f $(get-fmt) ./...", "go list -f $(get-fmt) <path>"},
+
+		// go tool edge cases
+		{"tool subshell", "go tool $(get-tool)", "go tool $(get-tool)"},
+
+		// go default handler edge cases
+		{"vet subshell", "go vet $(get-pkg)", "go vet $(get-pkg)"},
+		{"vet p flag", "go vet -p 4 ./...", "go vet -p N <path>"},
+		{"fmt subshell", "go fmt $(get-pkg)", "go fmt $(get-pkg)"},
+		{"generate tags", "go generate -tags wireinject ./...", "go generate -tags <val> <path>"},
+		{"default subshell flag arg", "go vet -tags $(get-tags) ./...", "go vet -tags $(get-tags) <path>"},
+		{"default trailing tags", "go vet -tags", "go vet -tags"},
+
+		// Unknown fused flag - classifyToken keeps it verbatim since it's a flag
+		{"test unknown fused flag", "go test -benchmem=true ./...", "go test -benchmem=true <path>"},
+
+		// go test subshell in test-specific fused positions
+		{"test fused timeout subshell", "go test -timeout=30s ./...", "go test -timeout=<duration> <path>"},
+
+		// go build subshell in build-specific flag positions
+		{"build tags subshell", "go build -tags $(get-tags) .", "go build -tags $(get-tags) ."},
+		{"build subshell positional", "go build $(get-pkg)", "go build $(get-pkg)"},
+
+		// go install build flag subshells
+		{"install tags subshell", "go install -tags $(get-tags) ./cmd/app", "go install -tags $(get-tags) <path>"},
+		{"install subshell positional", "go install $(get-url)", "go install $(get-url)"},
+
+		// go mod subshell in edit flag positions
+		{"mod edit replace subshell", "go mod edit -replace $(gen-replace)", "go mod edit -replace $(gen-replace)"},
+		{"mod edit flag subshell", "go mod edit -go $(get-version)", "go mod edit -go $(get-version)"},
+		{"mod edit boolean flag", "go mod edit -json", "go mod edit -json"},
+
+		// go tool subshell and flag handling
+		{"tool flag before name", "go tool -n pprof", "go tool -n pprof"},
+		{"tool subshell after name", "go tool pprof $(get-profile)", "go tool pprof $(get-profile)"},
+
+		// go install boolean flag
+		{"install verbose", "go install -v golang.org/x/tools/gopls@latest", "go install -v golang.org/x/tools/gopls@latest"},
+		{"install parent path", "go install ../other/cmd", "go install <path>"},
+
+		// go mod more coverage
+		{"mod edit boolean only", "go mod edit -print", "go mod edit -print"},
+		{"mod why subshell", "go mod why $(get-dep)", "go mod why $(get-dep)"},
+		{"mod edit go subshell", "go mod edit -go $(get-version)", "go mod edit -go $(get-version)"},
+
+		// go run boolean flag after positional
+		{"run race file args", "go run -race main.go --port 8080", "go run -race <path> --port 8080"},
+
 		// Edge cases
 		{"bare go", "go", "go"},
 		{"version", "go version", "go version"},

handler_helm_test.go

@@ -51,6 +51,11 @@ func TestHelm(t *testing.T) {
 		{"rollback", "helm rollback my-release 2", "helm rollback my-release N"},
 		{"status", "helm status my-release", "helm status my-release"},
 		{"get values", "helm get values my-release", "helm get values my-release"},
+
+		// subshell as value-flag argument
+		{"set with subshell", "helm install my-release bitnami/nginx --set $(get-value)", "helm install my-release <path> --set $(get-value)"},
+		// subshell as path-flag argument
+		{"values file subshell", "helm install my-release bitnami/nginx -f $(find-values)", "helm install my-release <path> -f $(find-values)"},
 	}
 
 	for _, tt := range tests {

handler_htop_test.go

@@ -42,6 +42,29 @@ func TestHtop(t *testing.T) {
 		{"delay and sort", "htop -d 20 -s PERCENT_CPU", "htop -d N -s <col>"},
 		{"tree no color user", "htop -t -C -u admin", "htop -t -C -u <user>"},
 
+		// Numeric flag at end of input (no value follows)
+		{"delay short trailing", "htop -d", "htop -d"},
+		{"highlight trailing", "htop -H", "htop -H"},
+
+		// Value flag at end of input (no value follows)
+		{"user short trailing", "htop -u", "htop -u"},
+		{"pid short trailing", "htop -p", "htop -p"},
+		{"sort short trailing", "htop -s", "htop -s"},
+		{"filter short trailing", "htop -F", "htop -F"},
+
+		// Numeric flag with subshell value
+		{"delay subshell", "htop -d $(echo 10)", "htop -d $(echo <str>)"},
+		{"highlight subshell", "htop --highlight-changes $(calc)", "htop --highlight-changes $(calc)"},
+
+		// Value flag with subshell value
+		{"user subshell", "htop -u $(whoami)", "htop -u $(whoami)"},
+		{"pid subshell", "htop -p $(pgrep foo)", "htop -p $(pgrep foo)"},
+		{"sort subshell", "htop --sort-key $(echo CPU)", "htop --sort-key $(echo <str>)"},
+		{"filter subshell", "htop -F $(echo nginx)", "htop -F $(echo <str>)"},
+
+		// Subshell as standalone token
+		{"subshell standalone", "htop $(flags)", "htop $(flags)"},
+
 		// Redirect
 		{"redirect", "htop -p 123 > out.txt", "htop -p <pid> > <path>"},
 	}

handler_ip_test.go

@@ -52,6 +52,15 @@ func TestIP(t *testing.T) {
 		// tunnel
 		{"tunnel show", "ip tunnel show", "ip tunnel show"},
 
+		// subshell as globalValFlag argument
+		{"family subshell", "ip -f $(get-family) addr show", "ip -f $(get-family) addr show"},
+		// subshell as valKeyword argument
+		{"dev subshell", "ip link set dev $(get-dev) up", "ip link set dev $(get-dev) up"},
+		// subshell as numKeyword argument
+		{"mtu subshell", "ip link set dev eth0 mtu $(get-mtu)", "ip link set dev <val> mtu $(get-mtu)"},
+		// subshell as addrKeyword argument
+		{"address subshell", "ip link set dev eth0 address $(get-mac)", "ip link set dev <val> address $(get-mac)"},
+
 		// redirect preserved
 		{"with redirect", "ip addr show > /tmp/out.txt", "ip addr show > <path>"},
 	}

handler_iptables_test.go

@@ -49,6 +49,15 @@ func TestIptables(t *testing.T) {
 
 		// Destination and source together
 		{"src and dst", "iptables -A FORWARD -s 10.0.0.0/8 -d 172.16.0.0/12 -j ACCEPT", "iptables -A FORWARD -s <addr> -d <addr> -j ACCEPT"},
+
+		// Subshell as standalone token in args
+		{"subshell standalone", "iptables $(get-flags) -j ACCEPT", "iptables $(get-flags) -j ACCEPT"},
+		// Subshell as verbatim flag argument
+		{"subshell verbatim arg", "iptables -A INPUT -p $(get-proto) -j ACCEPT", "iptables -A INPUT -p $(get-proto) -j ACCEPT"},
+		// Subshell as val flag argument
+		{"subshell val arg", "iptables -A INPUT --dport $(get-port) -j ACCEPT", "iptables -A INPUT --dport $(get-port) -j ACCEPT"},
+		// Subshell as str flag argument
+		{"subshell str arg", "iptables -A INPUT -m comment --comment $(gen-comment) -j ACCEPT", "iptables -A INPUT -m comment --comment $(gen-comment) -j ACCEPT"},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {

handler_kill_test.go

@@ -20,6 +20,18 @@ func TestKill(t *testing.T) {
 		// List mode
 		{"list signals", "kill -l", "kill -l"},
 		{"list with exit status", "kill -l 1", "kill -l N"},
+		// Bare dash (not a numeric signal, treated as positional)
+		{"bare dash", "kill - 1234", "kill <pid>+"},
+		// Mixed digit-letter flag (not a valid numeric signal)
+		{"invalid numeric signal", "kill -9a 1234", "kill <pid>+"},
+		// Double-dash with subshell
+		{"double dash subshell", "kill -- $(pgrep nginx)", "kill -- $(pgrep nginx)"},
+		// Subshell as standalone token
+		{"subshell standalone", "kill $(pgrep nginx)", "kill $(pgrep nginx)"},
+		// -s with no following token
+		{"dash-s trailing", "kill -s", "kill -s"},
+		// -l followed by a letter flag (does not consume)
+		{"dash-l followed by flag", "kill -l -HUP", "kill -l -HUP"},
 		// Special pids
 		{"job spec", "kill %1", "kill <pid>"},
 		{"double dash", "kill -- -1", "kill -- <pid>"},