feat: Match interface abbreviations in sequence steps without static table (#136)

Add matchSequenceStep() for sequence step matching that handles
interface-style tokens (e.g. 'g0/0/2' matching 'GigabitEthernet0/0/2').

For tokens with a letter/digit boundary (alpha prefix + numeric suffix):
- Step's alpha prefix must start with input's alpha prefix (case-insensitive)
- Numeric suffix must match exactly

This means 'int g0/0/2' matches 'interface GigabitEthernet0/0/2' but
'int gub0/0/2' and 'int g0/0/3' do not.

No hardcoded abbreviation table — the sequence step itself provides
the ground truth. Only applies to sequence matching, not context
switches or supported commands.

Closes #135

Author: lykinsbd

ssh_server/handlers/ciscohandlers.go

@@ -133,8 +133,7 @@ func handleSequenceStep(t *term.Terminal, userInput string, fd *fakedevices.Fake
 		return false, false
 	}
 	step := sequence[*seqIdx]
-	match, _, multipleMatches := cmdmatch.Match(userInput, map[string]string{step.Command: ""})
-	if !match || multipleMatches {
+	if !matchSequenceStep(userInput, step.Command) {
 		return false, false
 	}
 	output, err := fakedevices.TranscriptReader(step.Transcript, fd)
@@ -218,6 +217,51 @@ func dispatchCommand(t *term.Terminal, userInput string, fd *fakedevices.FakeDev
 	return false
 }
 
+// matchSequenceStep returns true if userInput matches the sequence step command.
+// Uses standard prefix matching for regular words, and for tokens containing a
+// letter/digit boundary (e.g. "g0/0/2"), matches the alpha prefix against the
+// step's alpha prefix and requires an exact suffix match.
+// This allows "int g0/0/2" to match "interface GigabitEthernet0/0/2" without
+// a hardcoded abbreviation table.
+func matchSequenceStep(userInput, stepCmd string) bool {
+	userFields := strings.Fields(strings.ToLower(userInput))
+	stepFields := strings.Fields(strings.ToLower(stepCmd))
+	if len(userFields) != len(stepFields) {
+		return false
+	}
+	for i, uf := range userFields {
+		sf := stepFields[i]
+		uAlpha, uSuffix := splitIfaceToken(uf)
+		sAlpha, sSuffix := splitIfaceToken(sf)
+		if uSuffix != "" || sSuffix != "" {
+			// Interface-style token: alpha prefix must match, suffix must be equal
+			if !strings.HasPrefix(sAlpha, uAlpha) || uSuffix != sSuffix {
+				return false
+			}
+		} else {
+			// Regular word: step word must start with user word (abbreviation)
+			if !strings.HasPrefix(sf, uf) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+// splitIfaceToken splits a token like "gigabitethernet0/0/2" into ("gigabitethernet", "0/0/2").
+// Only splits when the suffix starts with a digit (interface-style tokens).
+// Returns (token, "") if there is no letter/digit boundary.
+func splitIfaceToken(token string) (alpha, suffix string) {
+	i := 0
+	for i < len(token) && token[i] >= 'a' && token[i] <= 'z' {
+		i++
+	}
+	if i == 0 || i == len(token) || token[i] < '0' || token[i] > '9' {
+		return token, ""
+	}
+	return token[:i], token[i:]
+}
+
 // buildPrompt constructs the terminal prompt string.
 // If format is empty, falls back to hostname+context (default Cisco style).
 // If prefixLine is non-empty, it is prepended above the prompt on its own line.

ssh_server/handlers/ciscohandlers_test.go

@@ -624,3 +624,36 @@ func TestScenarioStrictContextSwitch(t *testing.T) {
 		t.Errorf("expected show running-config to return output, got:\n%s", out)
 	}
 }
+
+func TestMatchSequenceStep(t *testing.T) {
+	cases := []struct {
+		input string
+		step  string
+		want  bool
+	}{
+		// Standard prefix matching
+		{"show running-config", "show running-config", true},
+		{"sho run", "show running-config", true},
+		{"enable", "enable", true},
+		{"en", "enable", true},
+		// Interface token matching
+		{"interface GigabitEthernet0/0/2", "interface GigabitEthernet0/0/2", true},
+		{"int GigabitEthernet0/0/2", "interface GigabitEthernet0/0/2", true},
+		{"int g0/0/2", "interface GigabitEthernet0/0/2", true},
+		{"int gi0/0/2", "interface GigabitEthernet0/0/2", true},
+		// Wrong suffix — must not match
+		{"int g0/0/3", "interface GigabitEthernet0/0/2", false},
+		// Wrong alpha prefix — must not match
+		{"int gub0/0/2", "interface GigabitEthernet0/0/2", false},
+		{"int fa0/0/2", "interface GigabitEthernet0/0/2", false},
+		// Wrong word count
+		{"interface GigabitEthernet0/0/2 extra", "interface GigabitEthernet0/0/2", false},
+	}
+
+	for _, c := range cases {
+		got := matchSequenceStep(c.input, c.step)
+		if got != c.want {
+			t.Errorf("matchSequenceStep(%q, %q) = %v; want %v", c.input, c.step, got, c.want)
+		}
+	}
+}