perf: refine command UI and simplify terminal overlays

Author: voocel

internal/ui/app.go

@@ -138,30 +138,6 @@ func (a *App) overlayState(m *tui.Model) *tui.OverlayState {
 	}
 }
 
-// completions returns matching slash command candidates for the given prefix.
-func (a *App) completions(prefix string) []tui.CompletionItem {
-	lower := strings.ToLower(prefix)
-	var items []tui.CompletionItem
-	seen := make(map[string]bool)
-	for _, cmd := range a.registry.All() {
-		spec := a.registry.EffectiveSpec(cmd)
-		if spec.Hidden {
-			continue
-		}
-		if strings.HasPrefix(spec.Name, lower) && !seen[spec.Name] {
-			items = append(items, tui.CompletionItem{Name: spec.Name, Description: spec.Description})
-			seen[spec.Name] = true
-		}
-		for _, alias := range spec.Aliases {
-			if strings.HasPrefix(alias, lower) && !seen[alias] {
-				items = append(items, tui.CompletionItem{Name: alias, Description: spec.Description})
-				seen[alias] = true
-			}
-		}
-	}
-	return items
-}
-
 // onPaste returns a tea.Cmd that asynchronously reads clipboard image data.
 func (a *App) onPaste(m *tui.Model) tea.Cmd {
 	return func() tea.Msg {

internal/ui/cmd_model.go

@@ -197,10 +197,10 @@ func (c *ModelCommand) View(width int) string {
 	sb.WriteString(hint)
 	sb.WriteString("\n")
 
-	selectedStyle := lipgloss.NewStyle().Foreground(tui.ColorAccent).Bold(true)
+	selectedStyle := lipgloss.NewStyle().Foreground(tui.ColorPrimary).Bold(true)
 	currentMark := lipgloss.NewStyle().Foreground(tui.ColorSuccess)
 	dimStyle := tui.MutedStyle
-	headerStyle := lipgloss.NewStyle().Foreground(tui.ColorAccent)
+	headerStyle := tui.MutedStyle
 
 	reg := c.app.Session.Registry()
 
@@ -209,7 +209,7 @@ func (c *ModelCommand) View(width int) string {
 		// Render group header when entering a new provider section.
 		if groupIdx < len(s.groups) && s.groups[groupIdx].startIdx == i {
 			g := s.groups[groupIdx]
-			header := fmt.Sprintf("─ %s ", g.name) + strings.Repeat("─", max(0, 30-len(g.name)))
+			header := "  " + g.name
 			sb.WriteString(headerStyle.Render(header))
 			sb.WriteString("\n")
 			groupIdx++
@@ -334,4 +334,3 @@ func buildModelList(providers map[string]config.ProviderConfig) ([]modelSelectEn
 	}
 	return entries, groups
 }
-

internal/ui/command.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/atotto/clipboard"
 	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
 	"github.com/voocel/codebot/internal/config"
 	"github.com/voocel/codebot/internal/cron"
 	"github.com/voocel/codebot/internal/policy"
@@ -22,7 +23,7 @@ func (a *App) handleCommand(input string) tea.Cmd {
 	cmd, ok := a.registry.Lookup(inv.Name)
 	if !ok {
 		return tui.SendCommandResult(tui.CommandStyle.Render(
-			fmt.Sprintf("Unknown command: /%s. Type /help for available commands.", inv.Name)))
+			fmt.Sprintf("Unknown command: /%s. 输入 / 浏览命令，或用 /help 查看完整列表。", inv.Name)))
 	}
 
 	spec := cmd.Spec()
@@ -143,7 +144,7 @@ func (a *App) builtinCommands() []Command {
 		NewSimple(CommandSpec{
 			Name: "loop", Usage: "/loop <interval|cron> <prompt>",
 			Description: "Schedule recurring prompts",
-			Risk: policy.RiskLow, Kind: CommandKindBuiltin,
+			Risk:        policy.RiskLow, Kind: CommandKindBuiltin,
 		}, func(ctx *CommandContext, inv CommandInvocation) tea.Cmd {
 			return ctx.App.cmdLoop(inv.RawArgs)
 		}),
@@ -171,31 +172,40 @@ func (a *App) helpText() string {
 		groups[spec.Kind] = append(groups[spec.Kind], cmd)
 	}
 
+	headerStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("247"))
+	sectionStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("249"))
 	var sb strings.Builder
-	sb.WriteString("Available commands:\n")
+	sb.WriteString(headerStyle.Render("Available commands (/ opens the command palette):"))
 	a.renderCommandGroup(&sb, "Built-in", groups[CommandKindBuiltin])
 	a.renderCommandGroup(&sb, "Custom commands", groups[CommandKindCustom])
 	a.renderCommandGroup(&sb, "Skills", groups[CommandKindSkill])
 
-	sb.WriteString(strings.TrimSpace(`
+	sb.WriteString("\n\n")
+	sb.WriteString(sectionStyle.Render("Keyboard shortcuts:"))
+	sb.WriteString("\n")
+	sb.WriteString(tui.MutedStyle.Render(strings.TrimSpace(`
 
-Keyboard shortcuts:
   Enter             Send message
   Esc               Abort running agent
   Ctrl+C            Quit
-`))
+`)))
 
-	return tui.CommandStyle.Render(sb.String())
+	return sb.String()
 }
 
 func (a *App) renderCommandGroup(sb *strings.Builder, title string, commands []Command) {
 	if len(commands) == 0 {
 		return
 	}
 
+	sectionStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("249"))
+	usageStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("243"))
+	descStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("247"))
+	metaStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("250"))
+
 	sb.WriteString("\n\n")
-	sb.WriteString(title)
-	sb.WriteString(":\n")
+	sb.WriteString(sectionStyle.Render(title + ":"))
+	sb.WriteString("\n")
 
 	for _, cmd := range commands {
 		spec := a.registry.EffectiveSpec(cmd)
@@ -224,7 +234,14 @@ func (a *App) renderCommandGroup(sb *strings.Builder, title string, commands []C
 		if len(spec.Aliases) > 0 {
 			tags = append(tags, "aliases: "+strings.Join(spec.Aliases, ","))
 		}
-		fmt.Fprintf(sb, "  %-24s %s [%s]\n", usage, desc, strings.Join(tags, ", "))
+
+		sb.WriteString("  ")
+		sb.WriteString(usageStyle.Render(fmt.Sprintf("%-24s", usage)))
+		sb.WriteString(" ")
+		sb.WriteString(descStyle.Render(desc))
+		sb.WriteString(" ")
+		sb.WriteString(metaStyle.Render("[" + strings.Join(tags, ", ") + "]"))
+		sb.WriteString("\n")
 	}
 }
 
@@ -312,7 +329,6 @@ func (a *App) cmdNew() tea.Cmd {
 	}
 }
 
-
 func (a *App) cmdSettings() tea.Cmd {
 	s := a.Session.Settings()
 	baseURL := a.Session.BaseURL()
@@ -325,10 +341,42 @@ func (a *App) cmdSettings() tea.Cmd {
 	}
 	apiKey := a.Session.APIKey()
 	masked := maskKey(apiKey)
-	info := fmt.Sprintf("Provider: %s\nModel: %s\nAPI Key: %s\nBase URL: %s\nThinking level: %s\nContext window: %d\nAuto compaction: %v\nMax turns: %d\nConfig: %s",
-		s.Provider, a.Session.ModelName(), masked, baseURL,
-		thinking, s.ContextWindow, s.AutoCompaction, s.MaxTurns, config.SettingsPath(a.Cwd))
-	return tui.SendCommandResult(tui.CommandStyle.Render(info))
+
+	labelStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("243"))
+	valueStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("247"))
+	metaStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("248"))
+
+	autoCompact := "off"
+	if s.AutoCompaction {
+		autoCompact = "on"
+	}
+
+	var sb strings.Builder
+	renderRow := func(label, value string) {
+		sb.WriteString(labelStyle.Render(fmt.Sprintf("%-16s", label)))
+		sb.WriteString(" ")
+		sb.WriteString(valueStyle.Render(value))
+		sb.WriteString("\n")
+	}
+	renderMetaRow := func(label, value string) {
+		sb.WriteString(labelStyle.Render(fmt.Sprintf("%-16s", label)))
+		sb.WriteString(" ")
+		sb.WriteString(metaStyle.Render(value))
+		sb.WriteString("\n")
+	}
+
+	renderRow("Provider", s.Provider)
+	renderRow("Model", a.Session.ModelName())
+	renderRow("API key", masked)
+	renderRow("Base URL", baseURL)
+	sb.WriteString("\n")
+	renderRow("Thinking", thinking)
+	renderRow("Context", tui.FormatTokens(s.ContextWindow))
+	renderRow("Auto compact", autoCompact)
+	renderRow("Max turns", fmt.Sprintf("%d", s.MaxTurns))
+	renderMetaRow("Config", config.SettingsPath(a.Cwd))
+
+	return tui.SendCommandResult(strings.TrimRight(sb.String(), "\n"))
 }
 
 func maskKey(key string) string {

internal/ui/command_palette.go

@@ -0,0 +1,127 @@
+package ui
+
+import (
+	"sort"
+	"strings"
+
+	"github.com/voocel/codebot/internal/ui/tui"
+)
+
+type commandPaletteMatch struct {
+	item  tui.CompletionItem
+	score int
+}
+
+func (a *App) completions(prefix string) []tui.CompletionItem {
+	query := strings.TrimSpace(strings.ToLower(prefix))
+	var matches []commandPaletteMatch
+
+	for _, cmd := range a.registry.All() {
+		spec := a.registry.EffectiveSpec(cmd)
+		if spec.Hidden {
+			continue
+		}
+		item, score, ok := buildCommandPaletteItem(spec, query)
+		if !ok {
+			continue
+		}
+		matches = append(matches, commandPaletteMatch{item: item, score: score})
+	}
+
+	sort.SliceStable(matches, func(i, j int) bool {
+		if matches[i].score != matches[j].score {
+			return matches[i].score > matches[j].score
+		}
+		kindI := commandKindOrder[CommandKind(matches[i].item.Kind)]
+		kindJ := commandKindOrder[CommandKind(matches[j].item.Kind)]
+		if kindI != kindJ {
+			return kindI < kindJ
+		}
+		return strings.Compare(matches[i].item.Name, matches[j].item.Name) < 0
+	})
+
+	items := make([]tui.CompletionItem, 0, len(matches))
+	for _, match := range matches {
+		items = append(items, match.item)
+	}
+	return items
+}
+
+func buildCommandPaletteItem(spec CommandSpec, query string) (tui.CompletionItem, int, bool) {
+	item := tui.CompletionItem{
+		Name:        spec.Name,
+		Description: spec.Description,
+		Usage:       spec.Usage,
+		Kind:        string(spec.Kind),
+		Risk:        string(spec.Risk),
+		NeedsIdle:   spec.NeedsIdle,
+		Source:      spec.Source,
+		Aliases:     append([]string(nil), spec.Aliases...),
+		AutoExecute: commandPaletteAutoExecute(spec),
+	}
+
+	if item.Description == "" {
+		item.Description = "(no description)"
+	}
+	if item.Usage == "" {
+		item.Usage = "/" + item.Name
+	}
+	if item.Risk == "" {
+		item.Risk = "low"
+	}
+
+	score, ok := scoreCommandPaletteItem(spec, query)
+	return item, score, ok
+}
+
+func scoreCommandPaletteItem(spec CommandSpec, query string) (int, bool) {
+	if query == "" {
+		return 100, true
+	}
+
+	name := strings.ToLower(spec.Name)
+	description := strings.ToLower(spec.Description)
+	usage := strings.ToLower(spec.Usage)
+
+	bestScore := 0
+	if score := scorePaletteField(name, query, 1200, 950, 700); score > bestScore {
+		bestScore = score
+	}
+	for _, alias := range spec.Aliases {
+		if score := scorePaletteField(strings.ToLower(alias), query, 1100, 900, 650); score > bestScore {
+			bestScore = score
+		}
+	}
+	if score := scorePaletteField(description, query, 520, 420, 320); score > bestScore {
+		bestScore = score
+	}
+	if score := scorePaletteField(usage, query, 480, 380, 280); score > bestScore {
+		bestScore = score
+	}
+
+	return bestScore, bestScore > 0
+}
+
+func scorePaletteField(field, query string, exact, prefix, contains int) int {
+	if field == "" {
+		return 0
+	}
+	switch {
+	case field == query:
+		return exact
+	case strings.HasPrefix(field, query):
+		return prefix - min(len(field)-len(query), 40)
+	case strings.Contains(field, query):
+		return contains
+	default:
+		return 0
+	}
+}
+
+func commandPaletteAutoExecute(spec CommandSpec) bool {
+	usage := strings.TrimSpace(spec.Usage)
+	if usage == "" {
+		return true
+	}
+	return usage == "/"+spec.Name
+}

internal/ui/command_test.go

@@ -127,3 +127,52 @@ func TestRegistryReassignsAliasAndHidesOldOwnerAlias(t *testing.T) {
 		t.Fatalf("expected new owner alias to remain active, got %v", aliases)
 	}
 }
+
+func TestCommandPaletteMatchesAliasAndDescription(t *testing.T) {
+	t.Parallel()
+
+	app := &App{
+		Commands: []config.FileCommand{
+			{
+				Name:        "deploy",
+				Aliases:     []string{"ship"},
+				Description: "Deploy project to staging",
+				Usage:       "/deploy [env]",
+			},
+		},
+	}
+	app.rebuildRegistry()
+
+	aliasItems := app.completions("ship")
+	if len(aliasItems) == 0 || aliasItems[0].Name != "deploy" {
+		t.Fatalf("expected alias query to resolve deploy, got %#v", aliasItems)
+	}
+	if aliasItems[0].Usage != "/deploy [env]" {
+		t.Fatalf("expected usage metadata to be preserved, got %q", aliasItems[0].Usage)
+	}
+
+	descItems := app.completions("staging")
+	if len(descItems) == 0 || descItems[0].Name != "deploy" {
+		t.Fatalf("expected description query to resolve deploy, got %#v", descItems)
+	}
+}
+
+func TestCommandPaletteAutoExecuteDependsOnUsage(t *testing.T) {
+	t.Parallel()
+
+	noArgs, _, _ := buildCommandPaletteItem(CommandSpec{
+		Name:  "help",
+		Usage: "/help",
+	}, "")
+	if !noArgs.AutoExecute {
+		t.Fatal("expected no-arg command to auto execute")
+	}
+
+	withArgs, _, _ := buildCommandPaletteItem(CommandSpec{
+		Name:  "model",
+		Usage: "/model [name]",
+	}, "")
+	if withArgs.AutoExecute {
+		t.Fatal("expected arg command to only fill input")
+	}
+}