add-mvn-java-dotnet-handlers

Add specialized handlers for several major build tools and runtimes: -
Java/Javac: Handle classpath, module flags, and system properties -
Maven: Preserve phases/goals, collapse -D properties and -P profiles -
Gradle: Keep tasks structural, handle -D/-P properties and path flags -
.NET: Support subcommands (build, run, test), MSBuild properties, and
NuGet - Deno: Handle permissions, subcommands like task/eval, and URL
scripts - CMake: Support configure/build/install modes and -D cache
variables - Ansible: Handle ad-hoc and playbook commands with
inventory/module flags - HTTP Benchmarking: Support ab, wrk, and hey
with numeric/header flags - HTTPie: Collapse request items (key=val) and
handle auth/output flags - Database Shells: Support mongo/mongosh,
mysql, psql, and redis-cli - Environment/Process: Support env, ldd,
otool, and strace - Others: fly/flyctl, just, perl, ruby, swift, task,
and vagrant

These handlers ensure that structural elements (like task names or
subcommands) are preserved while data (like paths, URLs, and property
values) is collapsed to improve command grouping and analysis.

Author: micthiesen

handler_ansible.go

@@ -0,0 +1,135 @@
+package shellshape
+
+func init() {
+	Register("ansible", handleAnsibleAdhoc)
+	Register("ansible-playbook", handleAnsiblePlaybook)
+}
+
+var ansibleCategories = []flagCategory{
+	{map[string]bool{
+		"-a": true, "--args": true,
+		"-e": true, "--extra-vars": true,
+		"-u": true, "--user": true,
+		"--become-user":     true,
+		"--become-method":   true,
+		"--tags":            true,
+		"--skip-tags":       true,
+		"--start-at":        true,
+		"--start-at-task":   true,
+		"--connection":      true,
+		"--ssh-extra-args":  true,
+		"--ssh-common-args": true,
+		"--scp-extra-args":  true,
+		"--sftp-extra-args": true,
+	}, "<val>"},
+	{map[string]bool{
+		"-i": true, "--inventory": true, "--inventory-file": true,
+		"--private-key": true, "--key-file": true,
+		"--vault-password-file": true, "--vault-id": true,
+	}, "<path>"},
+	{map[string]bool{
+		"-m": true, "--module-name": true,
+	}, "<module>"},
+	{map[string]bool{
+		"-f": true, "--forks": true,
+		"-t": true, "--timeout": true,
+	}, "N"},
+	{map[string]bool{
+		"-l": true, "--limit": true,
+	}, "<target>"},
+}
+
+// handleAnsibleAdhoc handles the `ansible` ad-hoc command.
+// First positional is the host pattern (<target>), remaining positionals
+// use classifyToken. Module flags (-m) collapse to <module>.
+func handleAnsibleAdhoc(subcommand string, tokens []string) []string {
+	args, redirects := splitRedirects(tokens)
+
+	var result []string
+	firstPositional := true
+
+	i := 0
+	for i < len(args) {
+		tok := args[i]
+
+		if isSubshellToken(tok) {
+			result = append(result, tok)
+			firstPositional = false
+			i++
+			continue
+		}
+
+		if placeholder, ok := matchFlagCategory(tok, ansibleCategories); ok {
+			result, i = consumeFlagArg(tok, args, i, result, placeholder)
+			continue
+		}
+
+		if fused, ok := consumeFusedFlag(tok, ansibleCategories); ok {
+			result = append(result, fused)
+			i++
+			continue
+		}
+
+		if isFlagToken(tok) {
+			result = append(result, tok)
+			i++
+			continue
+		}
+
+		// First positional is the host pattern.
+		if firstPositional {
+			result = append(result, "<target>")
+			firstPositional = false
+		} else {
+			result = append(result, classifyToken(tok))
+		}
+		i++
+	}
+
+	result = append(result, redirects...)
+	return result
+}
+
+// handleAnsiblePlaybook handles the `ansible-playbook` command.
+// All positionals are playbook files (classifyToken). Shares flag
+// categories with the ad-hoc handler.
+func handleAnsiblePlaybook(subcommand string, tokens []string) []string {
+	args, redirects := splitRedirects(tokens)
+
+	var result []string
+
+	i := 0
+	for i < len(args) {
+		tok := args[i]
+
+		if isSubshellToken(tok) {
+			result = append(result, tok)
+			i++
+			continue
+		}
+
+		if placeholder, ok := matchFlagCategory(tok, ansibleCategories); ok {
+			result, i = consumeFlagArg(tok, args, i, result, placeholder)
+			continue
+		}
+
+		if fused, ok := consumeFusedFlag(tok, ansibleCategories); ok {
+			result = append(result, fused)
+			i++
+			continue
+		}
+
+		if isFlagToken(tok) {
+			result = append(result, tok)
+			i++
+			continue
+		}
+
+		// All positionals are playbook files.
+		result = append(result, classifyToken(tok))
+		i++
+	}
+
+	result = append(result, redirects...)
+	return result
+}

handler_ansible_test.go

@@ -0,0 +1,75 @@
+package shellshape
+
+import "testing"
+
+func TestAnsible(t *testing.T) {
+	tests := []struct {
+		name  string
+		input string
+		want  string
+	}{
+		// Basic ansible usage
+		{"ping all", "ansible all -m ping", "ansible <target> -m <module>"},
+		{"shell module with args", "ansible webservers -m shell -a 'uptime'", "ansible <target> -m <module> -a <val>"},
+		{"command module with args", "ansible dbservers -m command -a 'df -h'", "ansible <target> -m <module> -a <val>"},
+		{"with inventory", "ansible all -i hosts.ini -m ping", "ansible <target> -i <path> -m <module>"},
+		{"with user", "ansible all -u deploy -m setup", "ansible <target> -u <val> -m <module>"},
+		{"become flags", "ansible all --become --ask-become-pass -m command -a 'whoami'", "ansible <target> --become --ask-become-pass -m <module> -a <val>"},
+		{"with limit", "ansible all -l webservers -m ping", "ansible <target> -l <target> -m <module>"},
+		{"with extra vars", "ansible all -e 'foo=bar' -m debug -a 'var=foo'", "ansible <target> -e <val> -m <module> -a <val>"},
+		{"with forks", "ansible all -f 20 -m ping", "ansible <target> -f N -m <module>"},
+		{"with timeout", "ansible all -t 30 -m ping", "ansible <target> -t N -m <module>"},
+		{"with private key", "ansible all --private-key /home/user/.ssh/id_rsa -m ping", "ansible <target> --private-key <path> -m <module>"},
+		{"verbose", "ansible all -vvv -m ping", "ansible <target> -vvv -m <module>"},
+		{"list hosts", "ansible webservers --list-hosts", "ansible <target> --list-hosts"},
+
+		// ansible-playbook usage
+		{"playbook simple", "ansible-playbook site.yml", "ansible-playbook <path>"},
+		{"playbook with inventory", "ansible-playbook -i inventory/prod deploy.yml", "ansible-playbook -i <path>+"},
+		{"playbook with extra vars", "ansible-playbook playbook.yml -e 'version=1.2'", "ansible-playbook <path> -e <val>"},
+		{"playbook with tags", "ansible-playbook playbook.yml --tags deploy,setup", "ansible-playbook <path> --tags <val>"},
+		{"playbook with skip tags", "ansible-playbook playbook.yml --skip-tags slow", "ansible-playbook <path> --skip-tags <val>"},
+		{"playbook with limit", "ansible-playbook playbook.yml --limit staging", "ansible-playbook <path> --limit <target>"},
+		{"playbook with start-at", "ansible-playbook playbook.yml --start-at 'Install nginx'", "ansible-playbook <path> --start-at <val>"},
+		{"playbook check mode", "ansible-playbook playbook.yml -C -D", "ansible-playbook <path> -C -D"},
+		{"playbook with forks and user", "ansible-playbook playbook.yml -f 10 -u deploy", "ansible-playbook <path> -f N -u <val>"},
+		{"playbook with vault", "ansible-playbook playbook.yml --vault-password-file /tmp/vault.txt", "ansible-playbook <path> --vault-password-file <path>"},
+		{"playbook with become user", "ansible-playbook playbook.yml -b --become-user root", "ansible-playbook <path> -b --become-user <val>"},
+		{"playbook extra vars json file", "ansible-playbook playbook.yml -e @variables.json", "ansible-playbook <path> -e <val>"},
+		{"playbook multiple plays", "ansible-playbook site.yml deploy.yml", "ansible-playbook <path>+"},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := Normalize(tt.input)
+			if got != tt.want {
+				t.Errorf("Normalize(%q) = %q, want %q", tt.input, got, tt.want)
+			}
+		})
+	}
+
+	// COLLISION TESTS
+	t.Run("different hosts collide", func(t *testing.T) {
+		a := Normalize("ansible webservers -m ping")
+		b := Normalize("ansible dbservers -m ping")
+		if a != b {
+			t.Errorf("expected %q == %q", a, b)
+		}
+	})
+
+	t.Run("different playbooks collide", func(t *testing.T) {
+		a := Normalize("ansible-playbook site.yml -e 'env=prod'")
+		b := Normalize("ansible-playbook deploy.yml -e 'env=staging'")
+		if a != b {
+			t.Errorf("expected %q == %q", a, b)
+		}
+	})
+
+	// SAFETY TEST: subshell must not collapse
+	t.Run("subshell not collapsed", func(t *testing.T) {
+		benign := Normalize("ansible all -m ping")
+		subshell := Normalize("ansible $(cat hosts) -m ping")
+		if benign == subshell {
+			t.Error("subshell must produce different shape than literal")
+		}
+	})
+}

handler_clang.go

@@ -0,0 +1,148 @@
+package shellshape
+
+import (
+	"regexp"
+	"strings"
+)
+
+func init() {
+	for _, name := range []string{"clang", "clang++", "gcc", "g++", "cc", "c++"} {
+		Register(name, handleClang)
+	}
+}
+
+// Fused short-flag prefixes: -I<path>, -L<path>, -D<def>, -U<def>, -l<lib>.
+var clangFusedShortRE = regexp.MustCompile(`^-(I|L)(.+)$`)
+var clangFusedDefRE = regexp.MustCompile(`^-(D|U)(.+)$`)
+var clangFusedLibRE = regexp.MustCompile(`^-l(.+)$`)
+
+// Fused long-flag=value patterns.
+var clangFusedLongRE = regexp.MustCompile(`^(-std|-march|-mcpu|-mtune|-mabi|-mfpu|-mfloat-abi|--target)=(.+)$`)
+var clangFusedLongPathRE = regexp.MustCompile(`^(--sysroot)=(.+)$`)
+
+// handleClang handles clang, clang++, gcc, g++, cc, c++.
+//
+// Path flags (-o, -I, -L, -isystem, etc.) collapse the next arg to <path>.
+// Define flags (-D, -U) collapse the next arg to <def>.
+// Value flags (-l, -std, --target, -arch, -x, etc.) collapse the next arg to <val>.
+// Fused forms like -I/path, -DFOO, -lm, -std=c++17, --target=... are split and collapsed.
+// Optimization flags (-O0, -O2, -Os, etc.) and warning flags (-W...) are kept verbatim.
+// Positionals use classifyToken.
+func handleClang(subcommand string, tokens []string) []string {
+	args, redirects := splitRedirects(tokens)
+
+	pathFlags := map[string]bool{
+		"-o": true, "--output": true,
+		"-I": true, "-L": true,
+		"-isystem": true, "-isysroot": true,
+		"-iquote": true, "-idirafter": true,
+		"-iprefix": true, "-iwithprefix": true, "-iwithprefixbefore": true,
+		"-F": true, "-B": true,
+		"-MF": true, "-MQ": true, "-MT": true,
+		"-include": true, "-imacros": true,
+	}
+
+	defFlags := map[string]bool{
+		"-D": true, "-U": true,
+	}
+
+	valFlags := map[string]bool{
+		"-l": true, "-Xlinker": true,
+		"-target": true, "--target": true,
+		"-arch": true, "-march": true, "-mcpu": true, "-mtune": true,
+		"-mabi": true, "-mfpu": true, "-mfloat-abi": true,
+		"-std": true, "--std": true,
+		"-x": true, "-T": true, "-e": true,
+		"--serialize-diagnostics": true, "-MJ": true,
+		"-rpath": true,
+	}
+
+	categories := []flagCategory{
+		{pathFlags, "<path>"},
+		{defFlags, "<def>"},
+		{valFlags, "<val>"},
+	}
+
+	var result []string
+	i := 0
+	for i < len(args) {
+		tok := args[i]
+
+		if isSubshellToken(tok) {
+			result = append(result, tok)
+			i++
+			continue
+		}
+
+		// Fused short flags: -I/path, -L/path
+		if m := clangFusedShortRE.FindStringSubmatch(tok); m != nil {
+			result = append(result, "-"+m[1], "<path>")
+			i++
+			continue
+		}
+
+		// Fused define flags: -DFOO, -UFOO
+		if m := clangFusedDefRE.FindStringSubmatch(tok); m != nil {
+			result = append(result, "-"+m[1], "<def>")
+			i++
+			continue
+		}
+
+		// Fused library: -lfoo
+		if m := clangFusedLibRE.FindStringSubmatch(tok); m != nil {
+			result = append(result, "-l", "<val>")
+			i++
+			continue
+		}
+
+		// Fused long flag=value (val): -std=c++17, --target=..., -march=...
+		if m := clangFusedLongRE.FindStringSubmatch(tok); m != nil {
+			result = append(result, m[1]+"=<val>")
+			i++
+			continue
+		}
+
+		// Fused long flag=value (path): --sysroot=...
+		if m := clangFusedLongPathRE.FindStringSubmatch(tok); m != nil {
+			result = append(result, m[1]+"=<path>")
+			i++
+			continue
+		}
+
+		// Space-separated flag categories
+		if placeholder, ok := matchFlagCategory(tok, categories); ok {
+			result, i = consumeFlagArg(tok, args, i, result, placeholder)
+			continue
+		}
+
+		// Other flags (including -O*, -W*, -f*, -m (boolean), -g, -c, -S, -E, etc.)
+		if isFlagToken(tok) {
+			// Check for --flag=value on remaining long flags
+			if strings.Contains(tok, "=") {
+				eqIdx := strings.IndexByte(tok, '=')
+				key := tok[:eqIdx]
+				if pathFlags[key] {
+					result = append(result, key+"=<path>")
+				} else if defFlags[key] {
+					result = append(result, key+"=<def>")
+				} else if valFlags[key] {
+					result = append(result, key+"=<val>")
+				} else {
+					result = append(result, tok)
+				}
+				i++
+				continue
+			}
+			result = append(result, tok)
+			i++
+			continue
+		}
+
+		// Positional: source files, object files, etc.
+		result = append(result, classifyToken(tok))
+		i++
+	}
+
+	result = append(result, redirects...)
+	return result
+}