feat: add alias completion in command mode

[yimsk]

Summary

• Add alias suggestions in command mode (e.g., typing cf suggests cfn, cf)
• Cache GetAliases() and GetAliasesForService() with sync.Once for performance
• Refactor command parsing to use strings.CutPrefix/CutSuffix idiom
• Extract fuzzy match logic to shared match.go module

Changes

• internal/view/match.go - New: fuzzyMatch, matchNamesWithFallback
• internal/view/command_input.go - Alias completion, CutPrefix refactor
• internal/registry/registry.go - Add GetAliases(), caching
• custom/ecs/tasks/render.go - CutPrefix refactor

Closes #70

[claude]

Code Review Summary

This PR successfully adds alias completion to command mode and implements several quality refactorings. The implementation is well-structured with excellent test coverage. Below are my findings:

---

✅ Strengths

Code Quality & Best Practices

• Excellent refactoring patterns: The use of strings.CutPrefix/CutSuffix throughout is idiomatic Go 1.20+ code that's cleaner than the previous HasPrefix/TrimPrefix pattern
• Good separation of concerns: Extracting fuzzy match logic to internal/view/match.go creates a reusable module with clear responsibilities
• Consistent naming: Functions and variables follow Go conventions with clear, descriptive names
• Clean command parsing: The refactored command parsing in command_input.go is more readable and maintainable

Performance

• Smart caching strategy: Using sync.Once for GetAliases() and GetAliasesForService() is the right approach since aliases are immutable after initialization
• Defensive copies: Returning slices.Clone() from cached results (registry.go:309, 327) prevents external mutation - excellent defensive programming
• Efficient algorithms: Prefix matching with fuzzy fallback provides optimal UX without unnecessary computation

Test Coverage

• Comprehensive test suite: New functionality has thorough test coverage with diverse test cases
• Concurrency testing: Registry cache tests include concurrent access scenarios (registry_test.go:295-329)
• Edge cases covered: Empty inputs, case insensitivity, self-referential aliases, and boundary conditions all tested

---

🔍 Observations & Minor Suggestions

1. Potential Race Condition in Cache Initialization (Low Priority)

Location: internal/registry/registry.go:293-309

The current implementation has a subtle issue: sync.Once.Do() guards initialization, but the RLock inside the callback is taken after other goroutines might have already passed the Once check.

r.serviceAliasesOnce.Do(func() {
    r.mu.RLock()  // Lock taken inside Once callback
    defer r.mu.RUnlock()
    // ... build cache
})
return slices.Clone(r.serviceAliasesCache[service])  // Access without lock

Issue: Between Once.Do() returning and the final map access, r.serviceAliasesCache could theoretically be accessed before it's fully initialized if multiple goroutines hit this simultaneously on first call.

Recommendation: Move the RLock outside or restructure:

r.serviceAliasesOnce.Do(func() {
    r.mu.RLock()
    defer r.mu.RUnlock()
    // build cache
})
r.mu.RLock()  // Ensure cache is visible
defer r.mu.RUnlock()
return slices.Clone(r.serviceAliasesCache[service])

However, in practice this is likely safe due to Go's memory model with sync.Once, but it's worth considering for absolute correctness.

2. Case Sensitivity Consistency

Location: internal/view/match.go:9-11

The fuzzyMatch function converts both str and pattern to lowercase (lines 10-11), which is correct. However, matchNamesWithFallback also lowercases the pattern (line 30), causing it to be lowercased twice when fuzzy matching is used.

Impact: No functional issue (lowercasing twice is idempotent), but slightly inefficient.

Suggestion: Minor optimization to lowercase pattern once at the start of matchNamesWithFallback.

3. Error Message Improvement

Location: internal/view/command_input.go:253

Nice improvement quoting the profile name in error messages! This makes invalid profile names clearer to users.

4. Alphabetical Sorting Enhancement

Location: internal/view/command_input.go:469

Good addition of slices.Sort(suggestions) to ensure consistent ordering of service and alias suggestions.

---

🔒 Security

No security concerns identified. The changes:

• Don't introduce command injection risks
• Don't expose sensitive data
• Don't modify authentication/authorization logic
• Handle user input safely with existing validation

---

⚡ Performance Considerations

Positive impacts:

• Caching eliminates repeated alias map iterations
• Prefix matching avoids fuzzy matching when possible
• Defensive copies prevent accidental O(n) mutations

No performance regressions detected. The caching strategy is particularly well-suited for this use case.

---

🧪 Testing

Excellent test coverage with:

• Unit tests for all new functions
• Concurrency tests for cache safety
• Edge case coverage (empty inputs, case insensitivity, self-referential aliases)
• Integration tests for command completion

Test quality observations:

• Good use of table-driven tests
• Clear test names describing scenarios
• Proper use of subtests for isolation

---

📝 Documentation

The PR description clearly explains the changes. Code comments are appropriate. The commit history is clean and well-organized.

---

Final Verdict

LGTM with minor observations. This is high-quality work that:

• ✅ Implements the requested feature correctly
• ✅ Improves code maintainability through refactoring
• ✅ Includes comprehensive tests
• ✅ Follows Go best practices
• ✅ Has no significant bugs or security issues

The one potential race condition mentioned is very low risk given sync.Once semantics, but worth considering if you're aiming for absolute correctness.

Great job on this PR! The fuzzy matching with prefix fallback is a nice UX touch, and the caching optimization is well-implemented.