tui.go

v0.2.0
package tui

import (
	"encoding/json"
	"fmt"
	"strings"

	"os"

	"sourcecraft.dev/bigbes/claudio/cache"
	"sourcecraft.dev/bigbes/claudio/config"
	"sourcecraft.dev/bigbes/claudio/copilot"
	"sourcecraft.dev/bigbes/claudio/nvidia"
	ollamaAPI "sourcecraft.dev/bigbes/claudio/ollama"
	"sourcecraft.dev/bigbes/claudio/openrouter"
	"sourcecraft.dev/bigbes/claudio/provider"
	"sourcecraft.dev/bigbes/claudio/vkproxy"
	"github.com/charmbracelet/bubbles/filepicker"
	"github.com/charmbracelet/bubbles/textinput"
	tea "github.com/charmbracelet/bubbletea"
	"github.com/charmbracelet/lipgloss"
)

const logo = `
       _                 _ _       
   ___| | __ _ _   _  __| (_) ___  
  / __| |/ _` + "`" + ` | | | |/ _` + "`" + ` | |/ _ \ 
 | (__| | (_| | |_| | (_| | | (_) |
  \___|_|\__,_|\__,_|\__,_|_|\___/ `

type phase int

const (
	phaseSelect phase = iota
	phaseInputKey
	phaseSelectPlan
	phaseLoadingModels
	phaseSelectModel
	phaseFilePicker
	phaseDone
)

type entry struct {
	Key         string
	Name        string
	Description string
}

// PickerItem is a generic model entry for the two-column picker.
type PickerItem struct {
	ID            string
	Name          string
	ContextLength int
}

// DisplayName returns a human-friendly label for the item.
func (p PickerItem) DisplayName() string {
	if p.Name != "" {
		return p.Name
	}
	return p.ID
}

// pickerModelsMsg is returned by the async model-fetch command.
type pickerModelsMsg struct {
	families []string
	models   map[string][]PickerItem
	err      error

	// Popular provider drill-down data (openrouter only).
	popularProviders      []string
	popularProviderModels map[string][]PickerItem

	// All model IDs for "enter by hand" validation (openrouter only).
	allModelIDs map[string]bool
}

type Model struct {
	cfg      *config.Config
	cache    *cache.DB
	entries  []entry
	phase    phase
	cursor   int
	selected string
	input    textinput.Model
	quitting bool
	width    int
	height   int

	// Model picker state (copilot or openrouter).
	pickerProvider string
	modelCursor    int
	modelsErr      error

	// Two-column model picker state.
	families     []string
	familyModels map[string][]PickerItem
	familyCursor int
	modelFocus   bool // true = right column focused

	// Popular provider drill-down state (openrouter).
	popularProviders      []string
	popularProviderModels map[string][]PickerItem
	popularProviderCursor int
	popularDrilldown      bool // true = browsing models within a provider

	// "Enter model ID" input state (openrouter).
	pickerInput       textinput.Model
	pickerInputActive bool
	pickerInputErr    string
	allModelIDs       map[string]bool

	// Provider filter state (phaseSelect).
	filterActive bool
	filterInput  textinput.Model
	filteredIdx  []int // indices into entries matching filter

	// Show hidden providers toggle (phaseSelect).
	showHidden bool

	// Transient status message (e.g. after refresh).
	statusMsg string

	// File picker state (vkproxy zip selection).
	filePicker filepicker.Model

	// Plan selection state (phaseSelectPlan).
	plans      []provider.Plan
	planCursor int

	// Model picker filter state (phaseSelectModel).
	pickerFilterActive bool
	pickerFilteredIdx  []int
	pickerFilterCursor int
	pickerFilterRight  bool // true = filtering right column, false = left
}

func buildEntries(cfg *config.Config, showHidden bool) []entry {
	seen := make(map[string]bool)
	var entries []entry
	for _, key := range provider.Order {
		if !showHidden && cfg.Providers[key].Hidden {
			seen[key] = true
			continue
		}
		p := provider.Registry[key]
		entries = append(entries, entry{Key: key, Name: p.Name, Description: p.Description})
		seen[key] = true
	}
	for key, pc := range cfg.Providers {
		if seen[key] || (!showHidden && pc.Hidden) {
			continue
		}
		name := pc.Name
		if name == "" {
			name = key
		}
		desc := pc.Description
		if desc == "" && pc.Compat == "openai" {
			desc = "Custom OpenAI-compatible provider"
		}
		entries = append(entries, entry{Key: key, Name: name, Description: desc})
	}
	return entries
}

func New(cfg *config.Config, cdb *cache.DB) Model {
	ti := textinput.New()
	ti.Placeholder = "sk-..."
	ti.CharLimit = 256
	ti.Width = 60
	ti.EchoMode = textinput.EchoPassword
	ti.EchoCharacter = '•'

	entries := buildEntries(cfg, false)

	cursor := 0
	for i, e := range entries {
		if e.Key == cfg.ActiveProvider {
			cursor = i
			break
		}
	}

	fi := textinput.New()
	fi.Placeholder = "filter..."
	fi.CharLimit = 64
	fi.Width = 30

	return Model{
		cfg:         cfg,
		cache:       cdb,
		entries:     entries,
		phase:       phaseSelect,
		cursor:      cursor,
		input:       ti,
		filterInput: fi,
	}
}

// NewModelPicker creates a Model that goes directly to the copilot model selection phase.
func NewModelPicker(cfg *config.Config, cdb *cache.DB, models []copilot.CopilotModel) Model {
	families, grouped := copilot.VendorFamilies(models)
	items := make(map[string][]PickerItem)
	for fam, cms := range grouped {
		for _, cm := range cms {
			items[fam] = append(items[fam], PickerItem{ID: cm.ID, Name: cm.DisplayName(), ContextLength: cm.ContextWindow})
		}
	}
	m := Model{
		cfg:            cfg,
		cache:          cdb,
		phase:          phaseSelectModel,
		pickerProvider: "copilot",
		families:       families,
		familyModels:   items,
	}
	m.preSelectModel()
	return m
}

// preSelectModel positions cursors on the currently active model.
func (m *Model) preSelectModel() {
	m.familyCursor = 0
	m.modelCursor = 0
	m.modelFocus = false

	pc := m.cfg.Providers[m.pickerProvider]
	current := pc.Model
	if current == "" {
		if reg, ok := provider.Registry[m.pickerProvider]; ok {
			current = reg.Model
		}
	}
	for fi, fam := range m.families {
		for mi, item := range m.familyModels[fam] {
			if item.ID == current {
				m.familyCursor = fi
				m.modelCursor = mi
				return
			}
		}
	}
}

func (m Model) Cfg() *config.Config { return m.cfg }
func (m Model) Quitting() bool      { return m.quitting }

func (m Model) Init() tea.Cmd { return nil }

func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
	if msg, ok := msg.(tea.WindowSizeMsg); ok {
		m.width = msg.Width
		m.height = msg.Height
	}
	switch m.phase {
	case phaseSelect:
		return m.updateSelect(msg)
	case phaseInputKey:
		return m.updateInput(msg)
	case phaseSelectPlan:
		return m.updateSelectPlan(msg)
	case phaseLoadingModels:
		return m.updateLoadingModels(msg)
	case phaseSelectModel:
		return m.updateSelectModel(msg)
	case phaseFilePicker:
		return m.updateFilePicker(msg)
	default:
		return m, tea.Quit
	}
}

func (m *Model) recomputeFilter() {
	query := strings.ToLower(m.filterInput.Value())
	m.filteredIdx = nil
	for i, e := range m.entries {
		if query == "" || strings.Contains(strings.ToLower(e.Name), query) || strings.Contains(strings.ToLower(e.Key), query) {
			m.filteredIdx = append(m.filteredIdx, i)
		}
	}
	if m.cursor >= len(m.filteredIdx) {
		m.cursor = max(0, len(m.filteredIdx)-1)
	}
}

func (m Model) resolveEntry() entry {
	if m.filterActive && len(m.filteredIdx) > 0 && m.cursor < len(m.filteredIdx) {
		return m.entries[m.filteredIdx[m.cursor]]
	}
	return m.entries[m.cursor]
}

func (m Model) updateSelect(msg tea.Msg) (tea.Model, tea.Cmd) {
	if m.filterActive {
		return m.updateSelectFilter(msg)
	}
	switch msg := msg.(type) {
	case tea.KeyMsg:
		m.modelsErr = nil
		switch msg.String() {
		case "ctrl+c", "q":
			m.quitting = true
			return m, tea.Quit
		case "up", "k":
			if m.cursor > 0 {
				m.cursor--
			}
		case "down", "j":
			if m.cursor < len(m.entries)-1 {
				m.cursor++
			}
		case "/":
			m.filterActive = true
			m.filterInput.SetValue("")
			m.filterInput.Focus()
			m.cursor = 0
			m.recomputeFilter()
			return m, m.filterInput.Cursor.BlinkCmd()
		case "enter":
			m.selected = m.entries[m.cursor].Key
			return m.selectProvider()
		case "x":
			// Toggle hidden state for current provider.
			key := m.entries[m.cursor].Key
			pc := m.cfg.Providers[key]
			pc.Hidden = !pc.Hidden
			m.cfg.Providers[key] = pc
			if !m.showHidden && pc.Hidden {
				m.entries = buildEntries(m.cfg, m.showHidden)
				if m.cursor >= len(m.entries) {
					m.cursor = max(0, len(m.entries)-1)
				}
			}
			return m, nil
		case "H":
			// Toggle showing hidden providers.
			m.showHidden = !m.showHidden
			prev := ""
			if m.cursor < len(m.entries) {
				prev = m.entries[m.cursor].Key
			}
			m.entries = buildEntries(m.cfg, m.showHidden)
			m.cursor = 0
			for i, e := range m.entries {
				if e.Key == prev {
					m.cursor = i
					break
				}
			}
			return m, nil
		case "e":
			// Edit key for current provider.
			m.selected = m.entries[m.cursor].Key
			existing := ""
			if pc, ok := m.cfg.Providers[m.selected]; ok {
				existing = pc.APIKey
			}
			m.input.SetValue(existing)
			m.input.Focus()
			m.phase = phaseInputKey
			return m, m.input.Cursor.BlinkCmd()
		}
	}
	return m, nil
}

func (m Model) updateSelectFilter(msg tea.Msg) (tea.Model, tea.Cmd) {
	switch msg := msg.(type) {
	case tea.KeyMsg:
		switch msg.String() {
		case "ctrl+c":
			m.quitting = true
			return m, tea.Quit
		case "esc":
			m.filterActive = false
			// Restore cursor to the full list position.
			if len(m.filteredIdx) > 0 && m.cursor < len(m.filteredIdx) {
				m.cursor = m.filteredIdx[m.cursor]
			} else {
				m.cursor = 0
			}
			return m, nil
		case "up":
			if m.cursor > 0 {
				m.cursor--
			}
			return m, nil
		case "down":
			if m.cursor < len(m.filteredIdx)-1 {
				m.cursor++
			}
			return m, nil
		case "enter":
			if len(m.filteredIdx) == 0 {
				return m, nil
			}
			m.selected = m.resolveEntry().Key
			m.filterActive = false
			return m.selectProvider()
		}
	}
	var cmd tea.Cmd
	m.filterInput, cmd = m.filterInput.Update(msg)
	m.recomputeFilter()
	return m, cmd
}

func (m Model) selectProvider() (tea.Model, tea.Cmd) {
	// VK LLM Proxy: always parse zip and show picker.
	if m.selected == "vkproxy" {
		return m.startVKProxyPicker()
	}
	// If provider already has a key, just activate it.
	if pc, ok := m.cfg.Providers[m.selected]; ok && pc.APIKey != "" {
		m.cfg.ActiveProvider = m.selected
		// For copilot, show model picker.
		if m.selected == "copilot" {
			return m.startModelFetch(pc.APIKey)
		}
		// For openrouter, show model picker.
		if m.selected == "openrouter" {
			return m.startORModelFetch(pc.APIKey)
		}
		// For nvidia, show model picker.
		if m.selected == "nvidia" {
			return m.startNvidiaModelFetch(pc.APIKey)
		}
		// For ollama or ollama-cloud, show model picker.
		if m.selected == "ollama" || m.selected == "ollama-cloud" {
			reg := provider.Registry[m.selected]
			return m.startOllamaModelFetch(pc.APIKey, reg.BaseURL)
		}
		// For providers with plans, show plan picker.
		if reg, ok := provider.Registry[m.selected]; ok && len(reg.Plans) > 0 {
			return m.showPlanPicker(reg.Plans), nil
		}
		// For providers with static model lists, show model picker.
		if models, ok := provider.StaticModels[m.selected]; ok {
			return m.showStaticModelPicker(models), nil
		}
		m.phase = phaseDone
		return m, tea.Quit
	}
	// Copilot uses OAuth device flow; just activate and let main handle auth.
	if m.selected == "copilot" {
		m.cfg.ActiveProvider = m.selected
		m.phase = phaseDone
		return m, tea.Quit
	}
	// NoAuth providers (e.g. local Ollama) don't need an API key.
	if reg, ok := provider.Registry[m.selected]; ok && reg.NoAuth {
		m.cfg.ActiveProvider = m.selected
		// For ollama, show model picker.
		if m.selected == "ollama" {
			return m.startOllamaModelFetch("", reg.BaseURL)
		}
		m.phase = phaseDone
		return m, tea.Quit
	}
	// Otherwise prompt for key.
	m.input.SetValue("")
	m.input.Focus()
	m.phase = phaseInputKey
	return m, m.input.Cursor.BlinkCmd()
}

func (m Model) updateInput(msg tea.Msg) (tea.Model, tea.Cmd) {
	switch msg := msg.(type) {
	case tea.KeyMsg:
		switch msg.String() {
		case "ctrl+c":
			m.quitting = true
			return m, tea.Quit
		case "esc":
			m.phase = phaseSelect
			return m, nil
		case "enter":
			key := strings.TrimSpace(m.input.Value())
			if key == "" {
				return m, nil
			}
			m.cfg.ActiveProvider = m.selected
			pc := m.cfg.Providers[m.selected]
			pc.APIKey = key
			m.cfg.Providers[m.selected] = pc
			// For openrouter, show model picker after entering key.
			if m.selected == "openrouter" {
				return m.startORModelFetch(key)
			}
			// For nvidia, show model picker after entering key.
			if m.selected == "nvidia" {
				return m.startNvidiaModelFetch(key)
			}
			// For ollama-cloud, show model picker after entering key.
			if m.selected == "ollama-cloud" {
				reg := provider.Registry[m.selected]
				return m.startOllamaModelFetch(key, reg.BaseURL)
			}
			// For providers with plans, show plan picker after entering key.
			if reg, ok := provider.Registry[m.selected]; ok && len(reg.Plans) > 0 {
				return m.showPlanPicker(reg.Plans), nil
			}
			// For providers with static model lists, show model picker after entering key.
			if models, ok := provider.StaticModels[m.selected]; ok {
				return m.showStaticModelPicker(models), nil
			}
			m.phase = phaseDone
			return m, tea.Quit
		}
	}

	var cmd tea.Cmd
	m.input, cmd = m.input.Update(msg)
	return m, cmd
}

func (m Model) showStaticModelPicker(models []provider.StaticModel) Model {
	var familyOrder []string
	familyMap := make(map[string][]PickerItem)
	seen := make(map[string]bool)
	for _, sm := range models {
		if !seen[sm.Family] {
			seen[sm.Family] = true
			familyOrder = append(familyOrder, sm.Family)
		}
		familyMap[sm.Family] = append(familyMap[sm.Family], PickerItem{ID: sm.ID, Name: sm.Name, ContextLength: 0})
	}
	m.phase = phaseSelectModel
	m.pickerProvider = m.selected
	m.families = familyOrder
	m.familyModels = familyMap
	m.preSelectModel()
	return m
}

func (m Model) showPlanPicker(plans []provider.Plan) Model {
	m.plans = plans
	m.planCursor = 0
	// Pre-select the current plan if one is saved.
	if pc, ok := m.cfg.Providers[m.selected]; ok && pc.Plan != "" {
		for i, p := range plans {
			if p.Key == pc.Plan {
				m.planCursor = i
				break
			}
		}
	}
	m.phase = phaseSelectPlan
	return m
}

func (m Model) updateSelectPlan(msg tea.Msg) (tea.Model, tea.Cmd) {
	switch msg := msg.(type) {
	case tea.KeyMsg:
		switch msg.String() {
		case "ctrl+c", "q":
			m.quitting = true
			return m, tea.Quit
		case "esc":
			m.phase = phaseSelect
			return m, nil
		case "up", "k":
			if m.planCursor > 0 {
				m.planCursor--
			}
		case "down", "j":
			if m.planCursor < len(m.plans)-1 {
				m.planCursor++
			}
		case "enter":
			selected := m.plans[m.planCursor]
			pc := m.cfg.Providers[m.selected]
			pc.Plan = selected.Key
			m.cfg.Providers[m.selected] = pc
			// Continue to model picker if available.
			if models, ok := provider.StaticModels[m.selected]; ok {
				return m.showStaticModelPicker(models), nil
			}
			m.phase = phaseDone
			return m, tea.Quit
		}
	}
	return m, nil
}

func (m Model) viewSelectPlan() string {
	reg := provider.Registry[m.selected]
	var b strings.Builder
	b.WriteString(logoStyle.Render(logo))
	b.WriteString("\n\n")
	b.WriteString(promptStyle.Render(fmt.Sprintf(" Select plan for %s", reg.Name)))
	b.WriteString("\n\n")

	for i, plan := range m.plans {
		cur := "  "
		if i == m.planCursor {
			cur = cursorStyle.Render("▸ ")
		}
		name := plan.Name
		if i == m.planCursor {
			name = cursorStyle.Render(name)
		}
		desc := descStyle.Render("      " + plan.Description)
		b.WriteString(fmt.Sprintf(" %s%s\n%s\n", cur, name, desc))
	}

	b.WriteString("\n")
	b.WriteString(hintStyle.Render(" ↑/↓ navigate • enter select • esc back"))

	content := b.String()
	if m.width > 0 && m.height > 0 {
		return lipgloss.Place(m.width, m.height, lipgloss.Center, lipgloss.Center, content)
	}
	return content
}

func (m Model) loadVKProxyModels(forceRefresh bool) ([]vkproxy.ProxyModel, error) {
	// Try cache first (unless forcing refresh).
	if !forceRefresh && m.cache != nil {
		if data, ok := m.cache.GetModels("vkproxy"); ok {
			var models []vkproxy.ProxyModel
			if json.Unmarshal(data, &models) == nil && len(models) > 0 {
				return models, nil
			}
		}
	}

	// Parse from zip.
	zipPath := vkproxy.FindZip()
	if zipPath == "" {
		return nil, errZipNotFound
	}
	return m.loadVKProxyModelsFromPath(zipPath)
}

var errZipNotFound = fmt.Errorf("claude-code-config.zip not found")

func (m Model) loadVKProxyModelsFromPath(zipPath string) ([]vkproxy.ProxyModel, error) {
	models, err := vkproxy.ParseZip(zipPath)
	if err != nil {
		return nil, err
	}
	if len(models) == 0 {
		return nil, fmt.Errorf("no models found in zip")
	}

	// Update cache.
	if m.cache != nil {
		if data, err := json.Marshal(models); err == nil {
			m.cache.SetModels("vkproxy", data)
		}
	}
	return models, nil
}

func (m Model) startVKProxyPicker() (tea.Model, tea.Cmd) {
	return m.startVKProxyPickerWithRefresh(false)
}

func (m Model) startVKProxyPickerWithRefresh(forceRefresh bool) (tea.Model, tea.Cmd) {
	models, err := m.loadVKProxyModels(forceRefresh)
	if err == errZipNotFound {
		return m.showZipFilePicker()
	}
	if err != nil {
		m.modelsErr = err
		m.phase = phaseSelect
		return m, nil
	}
	return m.showVKProxyModels(models)
}

func (m Model) showZipFilePicker() (tea.Model, tea.Cmd) {
	fp := filepicker.New()
	fp.AllowedTypes = []string{".zip"}
	fp.ShowHidden = false
	fp.ShowSize = true
	fp.ShowPermissions = true
	fp.DirAllowed = false
	fp.FileAllowed = true
	fp.AutoHeight = false
	fp.Height = 20
	fp.Cursor = "▸"
	fp.Styles.Cursor = lipgloss.NewStyle().Foreground(lipgloss.Color("170")).Bold(true)
	fp.Styles.Selected = lipgloss.NewStyle().Foreground(lipgloss.Color("170")).Bold(true)
	fp.Styles.Directory = lipgloss.NewStyle().Foreground(lipgloss.Color("33")).Bold(true)
	fp.Styles.Symlink = lipgloss.NewStyle().Foreground(lipgloss.Color("36"))
	fp.Styles.File = lipgloss.NewStyle().Foreground(lipgloss.Color("255"))
	fp.Styles.DisabledFile = lipgloss.NewStyle().Foreground(lipgloss.Color("240"))
	fp.Styles.DisabledCursor = lipgloss.NewStyle().Foreground(lipgloss.Color("240"))
	fp.Styles.DisabledSelected = lipgloss.NewStyle().Foreground(lipgloss.Color("240"))
	fp.Styles.Permission = lipgloss.NewStyle().Foreground(lipgloss.Color("244"))
	fp.Styles.FileSize = lipgloss.NewStyle().Foreground(lipgloss.Color("244")).Width(7).Align(lipgloss.Right)
	home, _ := os.UserHomeDir()
	if home != "" {
		fp.CurrentDirectory = home
	} else {
		fp.CurrentDirectory, _ = os.Getwd()
	}
	m.filePicker = fp
	m.phase = phaseFilePicker
	return m, m.filePicker.Init()
}

func (m Model) updateFilePicker(msg tea.Msg) (tea.Model, tea.Cmd) {
	switch msg := msg.(type) {
	case tea.KeyMsg:
		if msg.String() == "ctrl+c" {
			m.quitting = true
			return m, tea.Quit
		}
		if msg.String() == "q" {
			m.phase = phaseSelect
			return m, nil
		}
	}

	var cmd tea.Cmd
	m.filePicker, cmd = m.filePicker.Update(msg)

	if didSelect, path := m.filePicker.DidSelectFile(msg); didSelect {
		models, err := m.loadVKProxyModelsFromPath(path)
		if err != nil {
			m.modelsErr = err
			m.phase = phaseSelect
			return m, nil
		}
		return m.showVKProxyModels(models)
	}

	return m, cmd
}

func (m Model) viewFilePicker() string {
	var b strings.Builder
	b.WriteString(logoStyle.Render(logo))
	b.WriteString("\n\n")
	b.WriteString(promptStyle.Render(" Select claude-code-config.zip"))
	b.WriteString("\n\n")

	// Shorten path: replace home dir with ~.
	dir := m.filePicker.CurrentDirectory
	if home, _ := os.UserHomeDir(); home != "" {
		if dir == home {
			dir = "~"
		} else if strings.HasPrefix(dir, home+"/") {
			dir = "~" + dir[len(home):]
		}
	}

	panelW := 64
	pathHeader := hintStyle.Render(fmt.Sprintf(" 📁 %s", dir))

	border := lipgloss.RoundedBorder()
	panel := lipgloss.NewStyle().
		Border(border).
		BorderForeground(lipgloss.Color("170")).
		Padding(0, 1).
		Width(panelW).
		Render(pathHeader + "\n" + strings.Repeat("─", panelW-4) + "\n" + m.filePicker.View())

	b.WriteString(panel)
	b.WriteString("\n")
	b.WriteString(hintStyle.Render(" ↑/↓/pgup/pgdn navigate • enter/→ open • ←/esc back • q cancel"))

	content := b.String()
	if m.width > 0 && m.height > 0 {
		return lipgloss.Place(m.width, m.height, lipgloss.Center, lipgloss.Center, content)
	}
	return content
}

func (m Model) showVKProxyModels(models []vkproxy.ProxyModel) (tea.Model, tea.Cmd) {
	// Save common config (auth, base_url, env) from first model.
	pc := m.cfg.Providers["vkproxy"]
	pc.APIKey = models[0].AuthToken
	pc.BaseURL = models[0].BaseURL
	if pc.Env == nil {
		pc.Env = make(map[string]string)
	}
	if models[0].CustomHeaders != "" {
		pc.Env["ANTHROPIC_CUSTOM_HEADERS"] = models[0].CustomHeaders
	}
	if models[0].ProxyUser != "" {
		pc.Env["VK_LLM_PROXY_USER"] = models[0].ProxyUser
	}
	m.cfg.Providers["vkproxy"] = pc
	m.cfg.ActiveProvider = "vkproxy"

	// Group models by provider for the two-column picker.
	providers, grouped := vkproxy.GroupByProvider(models)
	familyMap := make(map[string][]PickerItem)
	for prov, pms := range grouped {
		for _, pm := range pms {
			familyMap[prov] = append(familyMap[prov], PickerItem{
				ID:            pm.ModelID,
				Name:          pm.Name,
				ContextLength: pm.ContextWindow,
			})
		}
	}

	m.phase = phaseSelectModel
	m.pickerProvider = "vkproxy"
	m.families = providers
	m.familyModels = familyMap
	m.preSelectModel()
	return m, nil
}

func (m Model) startModelFetch(oauthToken string) (tea.Model, tea.Cmd) {
	m.phase = phaseLoadingModels
	m.pickerProvider = "copilot"
	cdb := m.cache
	return m, func() tea.Msg {
		var models []copilot.CopilotModel
		if cdb != nil {
			if data, ok := cdb.GetModels("copilot"); ok {
				if json.Unmarshal(data, &models) != nil {
					models = nil
				}
			}
		}
		if models == nil {
			var err error
			models, err = copilot.ListModels(oauthToken)
			if err != nil {
				return pickerModelsMsg{err: err}
			}
			if cdb != nil {
				if data, err := json.Marshal(models); err == nil {
					cdb.SetModels("copilot", data)
				}
			}
		}
		families, grouped := copilot.VendorFamilies(models)
		items := make(map[string][]PickerItem)
		for fam, cms := range grouped {
			for _, cm := range cms {
				items[fam] = append(items[fam], PickerItem{ID: cm.ID, Name: cm.DisplayName(), ContextLength: cm.ContextWindow})
			}
		}
		return pickerModelsMsg{families: families, models: items}
	}
}

func (m Model) startORModelFetch(apiKey string) (tea.Model, tea.Cmd) {
	m.phase = phaseLoadingModels
	m.pickerProvider = "openrouter"
	cdb := m.cache
	return m, func() tea.Msg {
		var models []openrouter.ORModel
		if cdb != nil {
			if data, ok := cdb.GetModels("openrouter"); ok {
				if json.Unmarshal(data, &models) != nil {
					models = nil
				} else {
					models = openrouter.FilterAgentCompatible(models)
				}
			}
		}
		if models == nil {
			var err error
			models, err = openrouter.ListModels(apiKey)
			if err != nil {
				return pickerModelsMsg{err: err}
			}
			if cdb != nil {
				if data, err := json.Marshal(models); err == nil {
					cdb.SetModels("openrouter", data)
				}
			}
		}

		categories, grouped := openrouter.CategorizeModels(models)
		items := make(map[string][]PickerItem)
		for cat, orms := range grouped {
			for _, orm := range orms {
				items[cat] = append(items[cat], PickerItem{ID: orm.ID, Name: orm.DisplayName(), ContextLength: orm.ContextLength})
			}
		}

		// Prepend "Recently Used" category if any exist.
		if cdb != nil {
			if used, err := cdb.UsedModels(); err == nil && len(used) > 0 {
				var usedItems []PickerItem
				for _, u := range used {
					usedItems = append(usedItems, PickerItem{ID: u.ID, Name: u.Name, ContextLength: 0})
				}
				items["Recently Used"] = usedItems
				categories = append([]string{"Recently Used"}, categories...)
			}
		}

		// Group popular models by provider for drill-down.
		provNames, provGrouped := openrouter.GroupPopularByProvider(models)
		provItems := make(map[string][]PickerItem)
		for prov, orms := range provGrouped {
			for _, orm := range orms {
				provItems[prov] = append(provItems[prov], PickerItem{ID: orm.ID, Name: orm.DisplayName(), ContextLength: orm.ContextLength})
			}
		}

		return pickerModelsMsg{
			families:              categories,
			models:                items,
			popularProviders:      provNames,
			popularProviderModels: provItems,
			allModelIDs:           openrouter.AllModelIDs(models),
		}
	}
}

func (m Model) startNvidiaModelFetch(apiKey string) (tea.Model, tea.Cmd) {
	m.phase = phaseLoadingModels
	m.pickerProvider = "nvidia"
	cdb := m.cache
	return m, func() tea.Msg {
		var models []nvidia.NIMModel
		if cdb != nil {
			if data, ok := cdb.GetModels("nvidia"); ok {
				if json.Unmarshal(data, &models) != nil {
					models = nil
				} else {
					models = nvidia.FilterChatModels(models)
				}
			}
		}
		if models == nil {
			var err error
			models, err = nvidia.ListModels(apiKey)
			if err != nil {
				return pickerModelsMsg{err: err}
			}
			if cdb != nil {
				if data, err := json.Marshal(models); err == nil {
					cdb.SetModels("nvidia", data)
				}
			}
		}

		categories, grouped := nvidia.CategorizeModels(models)
		items := make(map[string][]PickerItem)
		for cat, nms := range grouped {
			for _, nm := range nms {
				items[cat] = append(items[cat], PickerItem{ID: nm.ID, Name: nm.DisplayName()})
			}
		}

		// Prepend "Recently Used" category if any exist.
		if cdb != nil {
			if used, err := cdb.UsedModels(); err == nil && len(used) > 0 {
				var usedItems []PickerItem
				for _, u := range used {
					usedItems = append(usedItems, PickerItem{ID: u.ID, Name: u.Name})
				}
				items["Recently Used"] = usedItems
				categories = append([]string{"Recently Used"}, categories...)
			}
		}

		// Group popular models by provider for drill-down.
		provNames, provGrouped := nvidia.GroupPopularByProvider(models)
		provItems := make(map[string][]PickerItem)
		for prov, nms := range provGrouped {
			for _, nm := range nms {
				provItems[prov] = append(provItems[prov], PickerItem{ID: nm.ID, Name: nm.DisplayName()})
			}
		}

		return pickerModelsMsg{
			families:              categories,
			models:                items,
			popularProviders:      provNames,
			popularProviderModels: provItems,
			allModelIDs:           nvidia.AllModelIDs(models),
		}
	}
}

func (m Model) startOllamaModelFetch(apiKey, baseURL string) (tea.Model, tea.Cmd) {
	m.phase = phaseLoadingModels
	m.pickerProvider = m.selected
	cdb := m.cache
	provKey := m.selected
	return m, func() tea.Msg {
		var models []ollamaAPI.OllamaModel
		if cdb != nil {
			if data, ok := cdb.GetModels(provKey); ok {
				if json.Unmarshal(data, &models) != nil {
					models = nil
				}
			}
		}
		if models == nil {
			var err error
			models, err = ollamaAPI.ListModels(baseURL, apiKey)
			if err != nil {
				return pickerModelsMsg{err: err}
			}
			if cdb != nil {
				if data, err := json.Marshal(models); err == nil {
					cdb.SetModels(provKey, data)
				}
			}
		}

		// Fetch context lengths and capabilities via /api/show (cached per model+modified_at).
		ollamaAPI.FetchModelDetails(models, baseURL, apiKey, provKey, cdb)

		// For cloud instances, group by provider;
		// for local instances, group by family.
		var families []string
		var grouped map[string][]ollamaAPI.OllamaModel
		if provKey == "ollama-cloud" {
			// Fetch popular model names from ollama.com (cached).
			var popularNames []string
			if cdb != nil {
				if data, ok := cdb.GetModels("ollama-cloud-popular"); ok {
					_ = json.Unmarshal(data, &popularNames)
				}
			}
			if len(popularNames) == 0 {
				if names, err := ollamaAPI.FetchPopularNames(); err == nil && len(names) > 0 {
					popularNames = names
					if cdb != nil {
						if data, err := json.Marshal(popularNames); err == nil {
							cdb.SetModels("ollama-cloud-popular", data)
						}
					}
				}
			}
			families, grouped = ollamaAPI.CategorizeByProvider(models, popularNames)
		} else {
			families, grouped = ollamaAPI.CategorizeModels(models)
		}
		items := make(map[string][]PickerItem)
		for fam, oms := range grouped {
			for _, om := range oms {
				items[fam] = append(items[fam], PickerItem{ID: om.Name, Name: om.DisplayName(), ContextLength: om.ContextLength})
			}
		}

		// Prepend "Recent" category from provider-scoped used models.
		if cdb != nil {
			if used, err := cdb.UsedModelsForProvider(provKey); err == nil && len(used) > 0 {
				var usedItems []PickerItem
				for _, u := range used {
					usedItems = append(usedItems, PickerItem{ID: u.ID, Name: u.Name})
				}
				items["Recent"] = usedItems
				families = append([]string{"Recent", ollamaAPI.SeparatorCategory}, families...)
			}
		}

		return pickerModelsMsg{families: families, models: items}
	}
}

func (m Model) updateLoadingModels(msg tea.Msg) (tea.Model, tea.Cmd) {
	switch msg := msg.(type) {
	case tea.KeyMsg:
		if msg.String() == "ctrl+c" {
			m.quitting = true
			return m, tea.Quit
		}
	case pickerModelsMsg:
		if msg.err != nil {
			m.modelsErr = msg.err
			m.phase = phaseSelect
			return m, nil
		}
		if len(msg.families) == 0 {
			// No models available — just activate with defaults.
			m.phase = phaseDone
			return m, tea.Quit
		}
		m.families = msg.families
		m.familyModels = msg.models
		m.popularProviders = msg.popularProviders
		m.popularProviderModels = msg.popularProviderModels
		m.allModelIDs = msg.allModelIDs
		m.preSelectModel()
		m.phase = phaseSelectModel
		if m.pickerProvider == "openrouter" || m.pickerProvider == "nvidia" {
			m.initPickerInput()
		}
		return m, nil
	}
	return m, nil
}

func (m *Model) initPickerInput() {
	pi := textinput.New()
	switch m.pickerProvider {
	case "nvidia":
		pi.Placeholder = "e.g. nvidia/llama-3.1-nemotron-ultra-253b-v1"
	default:
		pi.Placeholder = "e.g. anthropic/claude-sonnet-4"
	}
	pi.CharLimit = 256
	pi.Width = 40
	m.pickerInput = pi
}

func (m Model) currentFamilyModels() []PickerItem {
	if m.familyCursor < len(m.families) {
		return m.familyModels[m.families[m.familyCursor]]
	}
	return nil
}

// currentRightPaneModels returns the models visible in the right pane,
// accounting for Popular provider drill-down.
func (m Model) currentRightPaneModels() []PickerItem {
	if m.isPopularCategory() && m.popularDrilldown && m.popularProviderCursor < len(m.popularProviders) {
		prov := m.popularProviders[m.popularProviderCursor]
		return m.popularProviderModels[prov]
	}
	return m.currentFamilyModels()
}

func (m Model) isSeparator(idx int) bool {
	return idx < len(m.families) && m.families[idx] == ollamaAPI.SeparatorCategory
}

func (m Model) isEnterByHand() bool {
	if m.familyCursor < len(m.families) {
		fam := m.families[m.familyCursor]
		return fam == openrouter.EnterByHandCategory || fam == nvidia.EnterByHandCategory
	}
	return false
}

func (m Model) isPopularCategory() bool {
	if m.familyCursor < len(m.families) {
		return m.families[m.familyCursor] == "Popular"
	}
	return false
}

// hasPopularDrilldown returns true when the Popular category uses a two-level
// provider→models drill-down (openrouter, nvidia). For ollama-cloud the
// Popular models are stored directly in familyModels and need no drill-down.
func (m Model) hasPopularDrilldown() bool {
	return len(m.popularProviders) > 0
}

// pickerVisibleFamilies returns indices into m.families to display.
// When filtering the left column, returns only matching indices; otherwise all.
func (m Model) pickerVisibleFamilies() []int {
	if m.pickerFilterActive && !m.pickerFilterRight {
		return m.pickerFilteredIdx
	}
	idx := make([]int, len(m.families))
	for i := range m.families {
		idx[i] = i
	}
	return idx
}

// pickerVisibleRightItems returns indices into the right-pane list to display.
// When filtering the right column, returns only matching indices; otherwise all.
func (m Model) pickerVisibleRightItems() []int {
	if m.pickerFilterActive && m.pickerFilterRight {
		return m.pickerFilteredIdx
	}
	var n int
	if m.isPopularCategory() && m.hasPopularDrilldown() && !m.popularDrilldown {
		n = len(m.popularProviders)
	} else {
		n = len(m.currentRightPaneModels())
	}
	idx := make([]int, n)
	for i := range idx {
		idx[i] = i
	}
	return idx
}

func (m *Model) recomputePickerFilter() {
	query := strings.ToLower(m.filterInput.Value())
	m.pickerFilteredIdx = nil
	if !m.pickerFilterRight {
		for i, fam := range m.families {
			if fam == ollamaAPI.SeparatorCategory {
				continue
			}
			if query == "" || strings.Contains(strings.ToLower(fam), query) {
				m.pickerFilteredIdx = append(m.pickerFilteredIdx, i)
			}
		}
	} else if m.isPopularCategory() && m.hasPopularDrilldown() && !m.popularDrilldown {
		for i, prov := range m.popularProviders {
			if query == "" || strings.Contains(strings.ToLower(prov), query) {
				m.pickerFilteredIdx = append(m.pickerFilteredIdx, i)
			}
		}
	} else {
		models := m.currentRightPaneModels()
		for i, item := range models {
			if query == "" || strings.Contains(strings.ToLower(item.DisplayName()), query) || strings.Contains(strings.ToLower(item.ID), query) {
				m.pickerFilteredIdx = append(m.pickerFilteredIdx, i)
			}
		}
	}
	if m.pickerFilterCursor >= len(m.pickerFilteredIdx) {
		m.pickerFilterCursor = max(0, len(m.pickerFilteredIdx)-1)
	}
}

func (m Model) updateSelectModel(msg tea.Msg) (tea.Model, tea.Cmd) {
	if m.pickerInputActive {
		return m.updatePickerInput(msg)
	}
	if m.pickerFilterActive {
		return m.updateSelectModelFilter(msg)
	}
	isPopular := m.isPopularCategory()

	switch msg := msg.(type) {
	case tea.KeyMsg:
		m.statusMsg = ""
		switch msg.String() {
		case "ctrl+c", "q":
			m.quitting = true
			return m, tea.Quit
		case "ctrl+r":
			if m.pickerProvider == "vkproxy" {
				result, cmd := m.startVKProxyPickerWithRefresh(true)
				rm := result.(Model)
				if rm.modelsErr == nil {
					rm.statusMsg = "✓ Refreshed from zip"
				}
				return rm, cmd
			}
		case "esc":
			if m.modelFocus {
				if isPopular && m.hasPopularDrilldown() && m.popularDrilldown {
					m.popularDrilldown = false
					return m, nil
				}
				m.modelFocus = false
				return m, nil
			}
			m.phase = phaseSelect
			return m, nil
		case "up", "k":
			if m.modelFocus {
				if isPopular && m.hasPopularDrilldown() && !m.popularDrilldown {
					if m.popularProviderCursor > 0 {
						m.popularProviderCursor--
					}
				} else {
					if m.modelCursor > 0 {
						m.modelCursor--
					}
				}
			} else {
				if m.familyCursor > 0 {
					m.familyCursor--
					// Skip separator categories.
					for m.familyCursor > 0 && m.isSeparator(m.familyCursor) {
						m.familyCursor--
					}
					m.modelCursor = 0
					m.popularDrilldown = false
				}
			}
		case "down", "j":
			if m.modelFocus {
				if isPopular && m.hasPopularDrilldown() && !m.popularDrilldown {
					if m.popularProviderCursor < len(m.popularProviders)-1 {
						m.popularProviderCursor++
					}
				} else {
					models := m.currentRightPaneModels()
					if m.modelCursor < len(models)-1 {
						m.modelCursor++
					}
				}
			} else {
				if m.familyCursor < len(m.families)-1 {
					m.familyCursor++
					// Skip separator categories.
					for m.familyCursor < len(m.families)-1 && m.isSeparator(m.familyCursor) {
						m.familyCursor++
					}
					m.modelCursor = 0
					m.popularDrilldown = false
				}
			}
		case "/":
			m.pickerFilterActive = true
			m.pickerFilterRight = m.modelFocus
			m.filterInput.SetValue("")
			m.filterInput.Focus()
			m.pickerFilterCursor = 0
			m.recomputePickerFilter()
			return m, m.filterInput.Cursor.BlinkCmd()
		case "right", "l", "tab":
			if !m.modelFocus {
				m.modelFocus = true
				if m.isEnterByHand() {
					m.pickerInputActive = true
					m.pickerInput.Focus()
					return m, m.pickerInput.Cursor.BlinkCmd()
				}
			} else if isPopular && m.hasPopularDrilldown() && !m.popularDrilldown {
				m.popularDrilldown = true
				m.modelCursor = 0
			}
		case "left", "h", "shift+tab":
			if m.modelFocus {
				if isPopular && m.hasPopularDrilldown() && m.popularDrilldown {
					m.popularDrilldown = false
				} else {
					m.modelFocus = false
				}
			}
		case "enter":
			if !m.modelFocus {
				if m.isEnterByHand() {
					m.modelFocus = true
					m.pickerInputActive = true
					m.pickerInput.Focus()
					return m, m.pickerInput.Cursor.BlinkCmd()
				}
				m.modelFocus = true
				return m, nil
			}
			// Drill into popular provider.
			if isPopular && m.hasPopularDrilldown() && !m.popularDrilldown {
				m.popularDrilldown = true
				m.modelCursor = 0
				return m, nil
			}
			// Select a model.
			models := m.currentRightPaneModels()
			if m.modelCursor < len(models) {
				selected := models[m.modelCursor]
				pc := m.cfg.Providers[m.pickerProvider]
				pc.Model = selected.ID
				pc.ContextWindow = selected.ContextLength
				if m.pickerProvider == "vkproxy" {
					pc.SmallModel = selected.ID
				}
				m.cfg.Providers[m.pickerProvider] = pc
				if m.cache != nil {
					switch m.pickerProvider {
					case "ollama", "ollama-cloud":
						m.cache.AddUsedModelForProvider(m.pickerProvider, selected.ID, selected.DisplayName())
					case "openrouter", "nvidia":
						m.cache.AddUsedModel(selected.ID, selected.DisplayName())
					}
				}
				m.phase = phaseDone
				return m, tea.Quit
			}
		}
	}
	return m, nil
}

func (m Model) updateSelectModelFilter(msg tea.Msg) (tea.Model, tea.Cmd) {
	switch msg := msg.(type) {
	case tea.KeyMsg:
		switch msg.String() {
		case "ctrl+c":
			m.quitting = true
			return m, tea.Quit
		case "esc":
			m.pickerFilterActive = false
			return m, nil
		case "up":
			if m.pickerFilterCursor > 0 {
				m.pickerFilterCursor--
			}
			return m, nil
		case "down":
			if m.pickerFilterCursor < len(m.pickerFilteredIdx)-1 {
				m.pickerFilterCursor++
			}
			return m, nil
		case "enter":
			if len(m.pickerFilteredIdx) == 0 {
				return m, nil
			}
			actualIdx := m.pickerFilteredIdx[m.pickerFilterCursor]
			m.pickerFilterActive = false
			if !m.pickerFilterRight {
				// Selected a family/category.
				m.familyCursor = actualIdx
				m.modelCursor = 0
				m.popularDrilldown = false
				m.modelFocus = true
				return m, nil
			}
			if m.isPopularCategory() && !m.popularDrilldown {
				// Selected a popular provider.
				m.popularProviderCursor = actualIdx
				m.popularDrilldown = true
				m.modelCursor = 0
				return m, nil
			}
			// Selected a model.
			models := m.currentRightPaneModels()
			if actualIdx < len(models) {
				selected := models[actualIdx]
				pc := m.cfg.Providers[m.pickerProvider]
				pc.Model = selected.ID
				pc.ContextWindow = selected.ContextLength
				if m.pickerProvider == "vkproxy" {
					pc.SmallModel = selected.ID
				}
				m.cfg.Providers[m.pickerProvider] = pc
				if m.cache != nil {
					switch m.pickerProvider {
					case "ollama", "ollama-cloud":
						m.cache.AddUsedModelForProvider(m.pickerProvider, selected.ID, selected.DisplayName())
					case "openrouter", "nvidia":
						m.cache.AddUsedModel(selected.ID, selected.DisplayName())
					}
				}
				m.phase = phaseDone
				return m, tea.Quit
			}
			return m, nil
		}
	}
	var cmd tea.Cmd
	m.filterInput, cmd = m.filterInput.Update(msg)
	m.recomputePickerFilter()
	return m, cmd
}

func (m Model) updatePickerInput(msg tea.Msg) (tea.Model, tea.Cmd) {
	if msg, ok := msg.(tea.KeyMsg); ok {
		switch msg.String() {
		case "ctrl+c":
			m.quitting = true
			return m, tea.Quit
		case "esc":
			m.pickerInputActive = false
			m.pickerInputErr = ""
			m.modelFocus = false
			return m, nil
		case "enter":
			id := strings.TrimSpace(m.pickerInput.Value())
			if id == "" {
				return m, nil
			}
			if len(m.allModelIDs) > 0 && !m.allModelIDs[id] {
				m.pickerInputErr = "Model not found"
				return m, nil
			}
			pc := m.cfg.Providers[m.pickerProvider]
			pc.Model = id
			m.cfg.Providers[m.pickerProvider] = pc
			if (m.pickerProvider == "openrouter" || m.pickerProvider == "nvidia") && m.cache != nil {
				m.cache.AddUsedModel(id, id)
			}
			m.phase = phaseDone
			return m, tea.Quit
		default:
			m.pickerInputErr = ""
		}
	}
	var cmd tea.Cmd
	m.pickerInput, cmd = m.pickerInput.Update(msg)
	return m, cmd
}

// ── styles ───────────────────────────────────────────────────

var (
	logoStyle = lipgloss.NewStyle().
			Foreground(lipgloss.Color("63")).
			Bold(true)

	greenBar = lipgloss.NewStyle().Foreground(lipgloss.Color("42"))
	blueBar  = lipgloss.NewStyle().Foreground(lipgloss.Color("33"))

	cursorStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("170")).Bold(true)
	nameStyle   = lipgloss.NewStyle()
	descStyle   = lipgloss.NewStyle().Foreground(lipgloss.Color("241"))
	hintStyle   = lipgloss.NewStyle().Foreground(lipgloss.Color("241"))
	errStyle    = lipgloss.NewStyle().Foreground(lipgloss.Color("196"))
	promptStyle = lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("99"))
)

func (m Model) View() string {
	switch m.phase {
	case phaseSelect:
		return m.viewSelect()
	case phaseInputKey:
		return m.viewInput()
	case phaseSelectPlan:
		return m.viewSelectPlan()
	case phaseLoadingModels:
		return m.viewLoadingModels()
	case phaseSelectModel:
		return m.viewSelectModel()
	case phaseFilePicker:
		return m.viewFilePicker()
	default:
		return ""
	}
}

func (m Model) viewSelect() string {
	var b strings.Builder

	b.WriteString(logoStyle.Render(logo))
	b.WriteString("\n\n")

	if m.filterActive {
		b.WriteString(fmt.Sprintf(" / %s\n\n", m.filterInput.View()))
	}

	// Determine which entries to display.
	type indexedEntry struct {
		idx   int
		entry entry
	}
	var visible []indexedEntry
	if m.filterActive {
		for _, idx := range m.filteredIdx {
			visible = append(visible, indexedEntry{idx: idx, entry: m.entries[idx]})
		}
	} else {
		for i, e := range m.entries {
			visible = append(visible, indexedEntry{idx: i, entry: e})
		}
	}

	for vi, ie := range visible {
		e := ie.entry
		isActive := e.Key == m.cfg.ActiveProvider
		hasKey := false
		isHidden := false
		if pc, ok := m.cfg.Providers[e.Key]; ok {
			hasKey = pc.APIKey != ""
			isHidden = pc.Hidden
		}
		var isCursor bool
		if m.filterActive {
			isCursor = m.cursor == vi
		} else {
			isCursor = m.cursor == ie.idx
		}

		// Cursor indicator.
		cur := "  "
		if isCursor {
			cur = cursorStyle.Render("▸ ")
		}

		// Status bar: green = active, blue = has key, space = unconfigured.
		bar := "  "
		if isActive {
			bar = greenBar.Render("▌ ")
		} else if hasKey {
			bar = blueBar.Render("▌ ")
		}

		// Name.
		name := e.Name
		if isHidden {
			name = descStyle.Render(name + " (hidden)")
		} else if isCursor {
			name = cursorStyle.Render(name)
		}

		// Description indented under the name.
		desc := descStyle.Render("      " + e.Description)

		b.WriteString(fmt.Sprintf(" %s%s%s\n%s\n", cur, bar, name, desc))
	}

	b.WriteString("\n")
	if m.modelsErr != nil {
		b.WriteString(errStyle.Render(fmt.Sprintf(" ⚠ Could not fetch models: %v", m.modelsErr)))
		b.WriteString("\n\n")
	}
	if m.filterActive {
		b.WriteString(hintStyle.Render(" ↑/↓ navigate • enter select • esc clear filter"))
	} else {
		hideHint := "x hide"
		if m.cursor < len(m.entries) {
			if pc, ok := m.cfg.Providers[m.entries[m.cursor].Key]; ok && pc.Hidden {
				hideHint = "x unhide"
			}
		}
		showAllHint := "H show hidden"
		if m.showHidden {
			showAllHint = "H hide hidden"
		}
		b.WriteString(hintStyle.Render(fmt.Sprintf(" ↑/↓ navigate • enter select • e edit key • %s • %s • / filter • q quit", hideHint, showAllHint)))
	}

	content := b.String()
	if m.width > 0 && m.height > 0 {
		return lipgloss.Place(m.width, m.height, lipgloss.Center, lipgloss.Center, content)
	}
	return content
}

func (m Model) viewInput() string {
	e := m.entries[m.cursor]
	var b strings.Builder
	b.WriteString(logoStyle.Render(logo))
	b.WriteString("\n\n")
	b.WriteString(promptStyle.Render(fmt.Sprintf(" API Key for %s", e.Name)))
	b.WriteString("\n\n ")
	b.WriteString(m.input.View())
	b.WriteString("\n\n")
	b.WriteString(hintStyle.Render(" enter confirm • esc back"))

	content := b.String()
	if m.width > 0 && m.height > 0 {
		return lipgloss.Place(m.width, m.height, lipgloss.Center, lipgloss.Center, content)
	}
	return content
}

func (m Model) pickerLabel() string {
	if reg, ok := provider.Registry[m.pickerProvider]; ok {
		return reg.Name
	}
	return m.pickerProvider
}

func (m Model) viewLoadingModels() string {
	label := m.pickerLabel()
	var b strings.Builder
	b.WriteString(logoStyle.Render(logo))
	b.WriteString("\n\n")
	b.WriteString(promptStyle.Render(fmt.Sprintf(" Fetching available %s models...", label)))
	content := b.String()
	if m.width > 0 && m.height > 0 {
		return lipgloss.Place(m.width, m.height, lipgloss.Center, lipgloss.Center, content)
	}
	return content
}

const maxVisibleModels = 20

func (m Model) viewSelectModel() string {
	label := m.pickerLabel()

	var b strings.Builder
	b.WriteString(logoStyle.Render(logo))
	b.WriteString("\n\n")
	b.WriteString(promptStyle.Render(fmt.Sprintf(" Select %s model", label)))
	b.WriteString("\n\n")

	if m.pickerFilterActive {
		b.WriteString(fmt.Sprintf(" / %s\n\n", m.filterInput.View()))
	}

	isPopular := m.isPopularCategory()

	// Determine current model for highlighting.
	pc := m.cfg.Providers[m.pickerProvider]
	currentModel := pc.Model
	if currentModel == "" {
		if reg, ok := provider.Registry[m.pickerProvider]; ok {
			currentModel = reg.Model
		}
	}

	// Compute dynamic column widths from content.
	// Left: widest family name + cursor prefix (2).
	leftContentWidth := 0
	for _, fam := range m.families {
		if len(fam) > leftContentWidth {
			leftContentWidth = len(fam)
		}
	}
	leftContentWidth += 2 // "▸ " prefix

	// Right: widest model display name + cursor (2) + bar (2).
	rightContentWidth := 0
	for _, fam := range m.families {
		for _, item := range m.familyModels[fam] {
			n := lipgloss.Width(item.DisplayName())
			if n > rightContentWidth {
				rightContentWidth = n
			}
		}
	}
	// Also account for popular provider names and their models.
	for _, prov := range m.popularProviders {
		if len(prov)+2 > rightContentWidth {
			rightContentWidth = len(prov) + 2
		}
		for _, item := range m.popularProviderModels[prov] {
			n := lipgloss.Width(item.DisplayName())
			if n > rightContentWidth {
				rightContentWidth = n
			}
		}
	}
	rightContentWidth += 4 // "▸ " prefix + "▌ " bar
	if rightContentWidth < 44 {
		rightContentWidth = 44
	}

	// Width includes padding (1 each side) + border (1 each side).
	leftW := leftContentWidth + 4
	rightW := rightContentWidth + 4

	// Build left column (families / categories).
	filterLeft := m.pickerFilterActive && !m.pickerFilterRight
	var leftBuf strings.Builder
	for vi, i := range m.pickerVisibleFamilies() {
		fam := m.families[i]

		// Render separator lines as non-selectable dividers.
		if fam == ollamaAPI.SeparatorCategory {
			leftBuf.WriteString(hintStyle.Render("  " + fam))
			leftBuf.WriteString("\n")
			continue
		}

		var isCursor bool
		if filterLeft {
			isCursor = m.pickerFilterCursor == vi
		} else {
			isCursor = m.familyCursor == i && !m.modelFocus
		}
		active := m.familyCursor == i

		cur := "  "
		if isCursor {
			cur = cursorStyle.Render("▸ ")
		}

		name := fam
		if isCursor {
			name = cursorStyle.Render(name)
		} else if active {
			name = lipgloss.NewStyle().Bold(true).Render(name)
		}

		leftBuf.WriteString(fmt.Sprintf("%s%s\n", cur, name))
	}

	// Build right column.
	var rightBuf strings.Builder
	if m.isEnterByHand() {
		// Show text input for manual model ID entry.
		if m.pickerInputActive {
			rightBuf.WriteString(" Enter model ID:\n\n")
			rightBuf.WriteString(fmt.Sprintf(" %s\n", m.pickerInput.View()))
			if m.pickerInputErr != "" {
				rightBuf.WriteString("\n")
				rightBuf.WriteString(errStyle.Render(fmt.Sprintf(" ⚠ %s", m.pickerInputErr)))
			}
			rightBuf.WriteString("\n")
			rightBuf.WriteString(hintStyle.Render(" enter confirm • esc back"))
		} else {
			rightBuf.WriteString(" Type a model ID manually\n\n")
			rightBuf.WriteString(hintStyle.Render(" press → or enter"))
		}
	} else if isPopular && m.hasPopularDrilldown() && !m.popularDrilldown {
		// Show provider list for Popular category.
		filterRight := m.pickerFilterActive && m.pickerFilterRight
		for vi, i := range m.pickerVisibleRightItems() {
			prov := m.popularProviders[i]
			var isCursor bool
			if filterRight {
				isCursor = m.pickerFilterCursor == vi
			} else {
				isCursor = m.popularProviderCursor == i && m.modelFocus
			}
			cur := "  "
			if isCursor {
				cur = cursorStyle.Render("▸ ")
			}
			name := prov
			if isCursor {
				name = cursorStyle.Render(name)
			}
			rightBuf.WriteString(fmt.Sprintf("%s%s\n", cur, name))
		}
	} else {
		// Show models (regular categories or drilled-down Popular).
		if isPopular && m.popularDrilldown && m.popularProviderCursor < len(m.popularProviders) {
			rightBuf.WriteString(promptStyle.Render(m.popularProviders[m.popularProviderCursor]))
			rightBuf.WriteString("\n\n")
		}

		models := m.currentRightPaneModels()
		filterRight := m.pickerFilterActive && m.pickerFilterRight
		visibleIndices := m.pickerVisibleRightItems()
		total := len(visibleIndices)

		// Determine the active cursor position within the visible list.
		activeCursor := m.modelCursor
		if filterRight {
			activeCursor = m.pickerFilterCursor
		}

		// Compute visible window for scrolling.
		start := 0
		if total > maxVisibleModels {
			start = max(activeCursor-maxVisibleModels/2, 0)
			if start+maxVisibleModels > total {
				start = total - maxVisibleModels
			}
		}
		end := min(start+maxVisibleModels, total)

		if start > 0 {
			rightBuf.WriteString(hintStyle.Render(fmt.Sprintf("  ↑ %d more", start)))
			rightBuf.WriteString("\n")
		}

		for vi := start; vi < end; vi++ {
			realIdx := visibleIndices[vi]
			item := models[realIdx]
			var isCursor bool
			if filterRight {
				isCursor = m.pickerFilterCursor == vi
			} else {
				isCursor = m.modelCursor == realIdx && m.modelFocus
			}
			isActive := item.ID == currentModel

			cur := "  "
			if isCursor {
				cur = cursorStyle.Render("▸ ")
			}

			bar := "  "
			if isActive {
				bar = greenBar.Render("▌ ")
			}

			name := item.DisplayName()
			if isCursor {
				name = cursorStyle.Render(name)
			}

			rightBuf.WriteString(fmt.Sprintf("%s%s%s\n", cur, bar, name))
		}

		if end < total {
			rightBuf.WriteString(hintStyle.Render(fmt.Sprintf("  ↓ %d more", total-end)))
			rightBuf.WriteString("\n")
		}
	}

	borderColor := lipgloss.Color("241")
	activeBorderColor := lipgloss.Color("170")

	leftBorder := lipgloss.RoundedBorder()
	leftBorderColor := borderColor
	if !m.modelFocus {
		leftBorderColor = activeBorderColor
	}
	leftPanel := lipgloss.NewStyle().
		Border(leftBorder).
		BorderForeground(leftBorderColor).
		Padding(0, 1).
		Width(leftW).
		Render(strings.TrimRight(leftBuf.String(), "\n"))

	rightBorder := lipgloss.RoundedBorder()
	rightBorderColor := borderColor
	if m.modelFocus {
		rightBorderColor = activeBorderColor
	}
	rightPanel := lipgloss.NewStyle().
		Border(rightBorder).
		BorderForeground(rightBorderColor).
		Padding(0, 1).
		Width(rightW).
		Render(strings.TrimRight(rightBuf.String(), "\n"))

	b.WriteString(lipgloss.JoinHorizontal(lipgloss.Top, leftPanel, " ", rightPanel))

	b.WriteString("\n")
	hint := " ←/→ switch column • ↑/↓ navigate • enter select • / filter • esc back"
	if m.pickerProvider == "vkproxy" {
		hint += " • ctrl+r refresh"
	}
	if m.pickerFilterActive {
		hint = " ↑/↓ navigate • enter select • esc clear filter"
	} else if m.pickerInputActive {
		hint = " enter confirm • esc back"
	} else if isPopular && m.hasPopularDrilldown() && m.modelFocus && !m.popularDrilldown {
		hint = " →/enter select provider • ↑/↓ navigate • / filter • ← back"
	} else if isPopular && m.hasPopularDrilldown() && m.modelFocus && m.popularDrilldown {
		hint = " enter select model • ↑/↓ navigate • / filter • ←/esc providers"
	}
	b.WriteString(hintStyle.Render(hint))
	if m.statusMsg != "" {
		b.WriteString("\n")
		b.WriteString(greenBar.Render(" " + m.statusMsg))
	}

	content := b.String()
	if m.width > 0 && m.height > 0 {
		return lipgloss.Place(m.width, m.height, lipgloss.Center, lipgloss.Center, content)
	}
	return content
}

Source Files

tui.go