feat: add substring suggestion mode

Signed-off-by: y-rabie <[email protected]>

Author: y-rabie

README.md

@@ -461,6 +461,11 @@ You can now override the context portForward default address configuration by se
       disableAutoscroll: false
       # Toggles log line timestamp info. Default false
       showTime: false
+    # Define how suggestions are made.
+    # "PREFIX": typed text is considered a prefix, sorts suggestions alphabetically. Default mode.
+    # "LONGEST_PREFIX": typed text is considered a prefix, sorts suggestions by how much of the typed text they match; if equal, it falls back to alphabetical order.
+    # "LONGEST_PREFIX": typed text is considered a substring, sorts suggestions by how much of the typed text they match; if equal, it falls back to alphabetical order.
+    suggestionMode: PREFIX
     # Provide shell pod customization when nodeShell feature gate is enabled!
     shellPod:
       # The shell pod image to use.

cmd/root.go

@@ -257,6 +257,12 @@ func initK9sFlags() {
 		"",
 		"Sets a path to a dir for a screen dumps",
 	)
+	rootCmd.Flags().StringVar(
+		k9sFlags.SuggestionMode,
+		"suggestion-mode",
+		string(config.DefaultSuggestionMode),
+		"Set autocompletion suggestion mode (PREFIX, LONGEST_PREFIX, LONGEST_SUBSTRING)",
+	)
 	rootCmd.Flags()
 }
 

internal/config/flags.go

@@ -12,39 +12,44 @@ const (
 
 	// DefaultCommand represents the default command to run.
 	DefaultCommand = ""
+
+	// DefaultSuggestionMode represents the default suggestion mode to use, which is `PREFIX`.
+	DefaultSuggestionMode = SuggestionModePrefix
 )
 
 // Flags represents K9s configuration flags.
 type Flags struct {
-	RefreshRate   *float32
-	LogLevel      *string
-	LogFile       *string
-	Headless      *bool
-	Logoless      *bool
-	Command       *string
-	AllNamespaces *bool
-	ReadOnly      *bool
-	Write         *bool
-	Crumbsless    *bool
-	Splashless    *bool
-	ScreenDumpDir *string
+	RefreshRate    *float32
+	LogLevel       *string
+	LogFile        *string
+	Headless       *bool
+	Logoless       *bool
+	Command        *string
+	AllNamespaces  *bool
+	ReadOnly       *bool
+	Write          *bool
+	Crumbsless     *bool
+	Splashless     *bool
+	ScreenDumpDir  *string
+	SuggestionMode *string
 }
 
 // NewFlags returns new configuration flags.
 func NewFlags() *Flags {
 	return &Flags{
-		RefreshRate:   float32Ptr(DefaultRefreshRate),
-		LogLevel:      strPtr(DefaultLogLevel),
-		LogFile:       strPtr(AppLogFile),
-		Headless:      boolPtr(false),
-		Logoless:      boolPtr(false),
-		Command:       strPtr(DefaultCommand),
-		AllNamespaces: boolPtr(false),
-		ReadOnly:      boolPtr(false),
-		Write:         boolPtr(false),
-		Crumbsless:    boolPtr(false),
-		Splashless:    boolPtr(false),
-		ScreenDumpDir: strPtr(AppDumpsDir),
+		RefreshRate:    float32Ptr(DefaultRefreshRate),
+		LogLevel:       strPtr(DefaultLogLevel),
+		LogFile:        strPtr(AppLogFile),
+		Headless:       boolPtr(false),
+		Logoless:       boolPtr(false),
+		Command:        strPtr(DefaultCommand),
+		AllNamespaces:  boolPtr(false),
+		ReadOnly:       boolPtr(false),
+		Write:          boolPtr(false),
+		Crumbsless:     boolPtr(false),
+		Splashless:     boolPtr(false),
+		ScreenDumpDir:  strPtr(AppDumpsDir),
+		SuggestionMode: strPtr(string(DefaultSuggestionMode)),
 	}
 }
 

internal/config/k9s.go

@@ -50,6 +50,7 @@ type K9s struct {
 	Logger              Logger     `json:"logger" yaml:"logger"`
 	Thresholds          Threshold  `json:"thresholds" yaml:"thresholds"`
 	DefaultView         string     `json:"defaultView" yaml:"defaultView"`
+	SuggestionMode      string     `json:"suggestionMode" yaml:"suggestionMode,omitempty"`
 	manualRefreshRate   float32
 	manualReadOnly      *bool
 	manualCommand       *string
@@ -77,6 +78,7 @@ func NewK9s(conn client.Connection, ks data.KubeSettings) *K9s {
 		PortForwardAddress: defaultPFAddress(),
 		ShellPod:           NewShellPod(),
 		ImageScans:         NewImageScans(),
+		SuggestionMode:     string(DefaultSuggestionMode),
 		dir:                data.NewDir(AppContextsDir),
 		conn:               conn,
 		ks:                 ks,
@@ -152,6 +154,7 @@ func (k *K9s) Merge(k1 *K9s) {
 	if k1.Thresholds != nil {
 		k.Thresholds = k1.Thresholds
 	}
+	k.SuggestionMode = k1.SuggestionMode
 }
 
 // AppScreenDumpDir fetch screen dumps dir.
@@ -332,6 +335,9 @@ func (k *K9s) Override(k9sFlags *Flags) {
 	}
 	k.manualCommand = k9sFlags.Command
 	k.manualScreenDumpDir = k9sFlags.ScreenDumpDir
+	if k9sFlags.SuggestionMode != nil {
+		k.SuggestionMode = *k9sFlags.SuggestionMode
+	}
 }
 
 // IsHeadless returns headless setting.

internal/config/testdata/configs/default.yaml

@@ -46,3 +46,4 @@ k9s:
       critical: 90
       warn: 70
   defaultView: ""
+  suggestionMode: PREFIX

internal/config/types.go

@@ -14,6 +14,14 @@ const (
 	MEM = "memory"
 )
 
+type SuggestionMode string
+
+const (
+	SuggestionModePrefix           SuggestionMode = "PREFIX"
+	SuggestionModeLongestPrefix    SuggestionMode = "LONGEST_PREFIX"
+	SuggestionModeLongestSubstring SuggestionMode = "LONGEST_SUBSTRING"
+)
+
 // UI tracks ui specific configs.
 type UI struct {
 	// EnableMouse toggles mouse support.

internal/ui/prompt.go

@@ -5,6 +5,7 @@ package ui
 
 import (
 	"fmt"
+	"strings"
 	"sync"
 
 	"github.com/derailed/k9s/internal/config"
@@ -177,7 +178,14 @@ func (p *Prompt) keyboard(evt *tcell.EventKey) *tcell.EventKey {
 
 	case tcell.KeyTab, tcell.KeyRight, tcell.KeyCtrlF:
 		if s, ok := m.CurrentSuggestion(); ok {
-			p.model.SetText(p.model.GetText()+s, "")
+			// Substitute the last word of the text with the suggestion if text isn't empty.
+			// Otherwise, just write the suggestion.
+			if words := strings.Fields(strings.TrimSpace(p.model.GetText())); len(words) != 0 {
+				text := strings.Join(words[0:len(words)-1], " ") + " " + s
+				p.model.SetText(strings.TrimSpace(text), "")
+			} else {
+				p.model.SetText(s, "")
+			}
 			m.ClearSuggestions()
 		}
 	}
@@ -231,11 +239,43 @@ func (p *Prompt) write(text, suggest string) {
 	defer p.mx.Unlock()
 
 	p.SetCursorIndex(p.spacer + len(text))
+
+	written := text
+
 	if suggest != "" {
-		text += fmt.Sprintf("[%s::-]%s", p.styles.Prompt().SuggestColor, suggest)
+		words := strings.Fields(strings.TrimSpace(text))
+
+		if len(words) != 0 {
+			// Append all words of text except the last one.
+			written = strings.Join(words[0:len(words)-1], " ") + " "
+			lastWord := words[len(words)-1]
+
+			// Get indices of where the last word of text lie within the suggestion.
+			// Could be anywhere if LONGEST_SUBSTRING mode suggestion is used.
+			// Otherwise at 0 for PREFIX/LONGEST_PREFIX suggestion modes.
+			startIdx := strings.Index(suggest, lastWord)
+			endIdx := startIdx + len(lastWord)
+
+			if startIdx != -1 {
+				written += fmt.Sprintf("[%s::-]%s[%s::-]%s[%s::-]%s",
+					p.styles.Prompt().SuggestColor, suggest[0:startIdx],
+					p.styles.Prompt().FgColor, suggest[startIdx:endIdx],
+					p.styles.Prompt().SuggestColor, suggest[endIdx:],
+				)
+			} else {
+				// `lastWord` isn't found within suggest. Just append `lastWord` again.
+				written += lastWord
+			}
+
+			written = strings.TrimSpace(written)
+		} else {
+			// No text, just write suggest in `SuggestColor`.
+			written = fmt.Sprintf("[%s::-]%s", p.styles.Prompt().SuggestColor, suggest)
+		}
 	}
+
 	p.StylesChanged(p.styles)
-	_, _ = fmt.Fprintf(p, defaultPrompt, p.icon, p.prefix, text)
+	_, _ = fmt.Fprintf(p, defaultPrompt, p.icon, p.prefix, written)
 }
 
 // ----------------------------------------------------------------------------

internal/view/app.go

@@ -198,22 +198,38 @@ func (a *App) suggestCommand() model.SuggestionFunc {
 			return a.cmdHistory.List()
 		}
 
+		entriesMap := make(map[string]float64)
+
 		ls := strings.ToLower(s)
 		for alias := range maps.Keys(a.command.alias.Alias) {
-			if suggest, ok := cmd.ShouldAddSuggest(ls, alias); ok {
-				entries = append(entries, suggest)
+			if weight := cmd.ShouldAddSuggest(a.Config.K9s.SuggestionMode, ls, alias); weight != -1 {
+				entriesMap[alias] = weight
 			}
 		}
 
 		namespaceNames, err := a.factory.Client().ValidNamespaceNames()
 		if err != nil {
 			slog.Error("Failed to obtain list of namespaces", slogs.Error, err)
 		}
-		entries = append(entries, cmd.SuggestSubCommand(s, namespaceNames, contextNames)...)
-		if len(entries) == 0 {
+		maps.Copy(entriesMap, cmd.SuggestSubCommand(a.Config.K9s.SuggestionMode, s, namespaceNames, contextNames))
+		if len(entriesMap) == 0 {
 			return nil
 		}
-		entries.Sort()
+
+		entries = make([]string, 0, len(entriesMap))
+		for k := range entriesMap {
+			entries = append(entries, k)
+		}
+
+		// PREFIX suggestion mode:, all weights are set to 0, sort strings normally.
+		// LONGEST_PREFIX,LONGEST_SUBSTRING suggestion modes: sort based on weights and fallback to string sorting for equal weights.
+		sort.SliceStable(entries, func(i, j int) bool {
+			if entriesMap[entries[i]] == entriesMap[entries[j]] {
+				return entries[i] < entries[j]
+			}
+			return entriesMap[entries[i]] > entriesMap[entries[j]]
+		})
+
 		return
 	}
 }

internal/view/cmd/helpers.go

@@ -4,7 +4,6 @@
 package cmd
 
 import (
-	"slices"
 	"strings"
 
 	"github.com/derailed/k9s/internal/client"
@@ -30,18 +29,32 @@ func ToLabels(s string) map[string]string {
 }
 
 // ShouldAddSuggest checks if a suggestion match the given command.
-func ShouldAddSuggest(command, suggest string) (string, bool) {
-	if command != suggest && strings.HasPrefix(suggest, command) {
-		return strings.TrimPrefix(suggest, command), true
+func ShouldAddSuggest(suggestionMode, command, suggest string) float64 {
+	var searchCondition bool
+	var weight float64 = 0
+
+	switch suggestionMode {
+	case "LONGEST_SUBSTRING":
+		searchCondition = strings.Contains(suggest, command)
+		weight = float64(len(command)) / float64(len(suggest))
+	case "LONGEST_PREFIX":
+		searchCondition = strings.HasPrefix(suggest, command)
+		weight = float64(len(command)) / float64(len(suggest))
+	default:
+		searchCondition = strings.HasPrefix(suggest, command)
+	}
+
+	if command != suggest && searchCondition {
+		return weight
 	}
 
-	return "", false
+	return -1
 }
 
 // SuggestSubCommand suggests namespaces or contexts based on current command.
-func SuggestSubCommand(command string, namespaces client.NamespaceNames, contexts []string) []string {
+func SuggestSubCommand(suggestionMode, command string, namespaces client.NamespaceNames, contexts []string) map[string]float64 {
 	p := NewInterpreter(command)
-	var suggests []string
+	var suggests map[string]float64
 	switch {
 	case p.IsCowCmd(), p.IsHelpCmd(), p.IsAliasCmd(), p.IsBailCmd(), p.IsDirCmd():
 		return nil
@@ -51,18 +64,18 @@ func SuggestSubCommand(command string, namespaces client.NamespaceNames, context
 		if !ok || ns == "" {
 			return nil
 		}
-		suggests = completeNS(ns, namespaces)
+		suggests = completeNS(suggestionMode, ns, namespaces)
 
 	case p.IsContextCmd():
 		n, ok := p.ContextArg()
 		if !ok {
 			return nil
 		}
-		suggests = completeCtx(command, n, contexts)
+		suggests = completeCtx(suggestionMode, command, n, contexts)
 
 	case p.HasNS():
 		if n, ok := p.HasContext(); ok {
-			suggests = completeCtx(command, n, contexts)
+			suggests = completeCtx(suggestionMode, command, n, contexts)
 		}
 		if len(suggests) > 0 {
 			break
@@ -72,44 +85,51 @@ func SuggestSubCommand(command string, namespaces client.NamespaceNames, context
 		if !ok {
 			return nil
 		}
-		suggests = completeNS(ns, namespaces)
+		suggests = completeNS(suggestionMode, ns, namespaces)
 
 	default:
 		if n, ok := p.HasContext(); ok {
-			suggests = completeCtx(command, n, contexts)
+			suggests = completeCtx(suggestionMode, command, n, contexts)
 		}
 	}
-	slices.Sort(suggests)
 
 	return suggests
 }
 
-func completeNS(s string, nn client.NamespaceNames) []string {
+func completeNS(suggestionMode, s string, nn client.NamespaceNames) map[string]float64 {
 	s = strings.ToLower(s)
-	var suggests []string
-	if suggest, ok := ShouldAddSuggest(s, client.NamespaceAll); ok {
-		suggests = append(suggests, suggest)
+	suggests := make(map[string]float64)
+	if weight := ShouldAddSuggest(suggestionMode, s, client.NamespaceAll); weight != -1 {
+		suggests[client.NamespaceAll] = weight
 	}
 	for ns := range nn {
-		if suggest, ok := ShouldAddSuggest(s, ns); ok {
-			suggests = append(suggests, suggest)
+		if weight := ShouldAddSuggest(suggestionMode, s, ns); weight != -1 {
+			suggests[ns] = weight
 		}
 	}
 
+	if len(suggests) == 0 {
+		return nil
+	}
+
 	return suggests
 }
 
-func completeCtx(command, s string, contexts []string) []string {
-	var suggests []string
+func completeCtx(suggestionMode, command, s string, contexts []string) map[string]float64 {
+	suggests := make(map[string]float64)
 	for _, ctxName := range contexts {
-		if suggest, ok := ShouldAddSuggest(s, ctxName); ok {
+		if weight := ShouldAddSuggest(suggestionMode, s, ctxName); weight != -1 {
 			if s == "" && !strings.HasSuffix(command, " ") {
-				suggests = append(suggests, " "+suggest)
+				suggests[" "+ctxName] = weight
 				continue
 			}
-			suggests = append(suggests, suggest)
+			suggests[ctxName] = weight
 		}
 	}
 
+	if len(suggests) == 0 {
+		return nil
+	}
+
 	return suggests
 }