643 lines
15 KiB
Go
643 lines
15 KiB
Go
package tui
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/charmbracelet/bubbles/list"
|
|
"github.com/charmbracelet/bubbles/textinput"
|
|
tea "github.com/charmbracelet/bubbletea"
|
|
"github.com/charmbracelet/lipgloss"
|
|
)
|
|
|
|
type listScreen struct {
|
|
state *wizardState
|
|
title string
|
|
desc []string
|
|
list list.Model
|
|
footer string
|
|
errText string
|
|
onPick func(optionItem) screen
|
|
onBack func() screen
|
|
}
|
|
|
|
func newListScreen(state *wizardState, title string, desc []string, items []optionItem, onPick func(optionItem) screen, onBack func() screen) *listScreen {
|
|
delegate := list.NewDefaultDelegate()
|
|
l := list.New(itemsToList(items), delegate, 0, 0)
|
|
l.DisableQuitKeybindings()
|
|
l.SetShowHelp(false)
|
|
l.SetFilteringEnabled(true)
|
|
l.SetShowStatusBar(false)
|
|
l.Title = title
|
|
return &listScreen{
|
|
state: state,
|
|
title: title,
|
|
desc: desc,
|
|
list: l,
|
|
footer: "enter select • esc back • / filter",
|
|
onPick: onPick,
|
|
onBack: onBack,
|
|
}
|
|
}
|
|
|
|
func (s *listScreen) Init() tea.Cmd {
|
|
return nil
|
|
}
|
|
|
|
func (s *listScreen) Update(msg tea.Msg) (screen, tea.Cmd) {
|
|
switch msg := msg.(type) {
|
|
case tea.WindowSizeMsg:
|
|
s.list.SetSize(msg.Width-4, msg.Height-8)
|
|
case tea.KeyMsg:
|
|
switch msg.String() {
|
|
case "enter":
|
|
if s.list.FilterState() != list.Filtering {
|
|
if item, ok := s.list.SelectedItem().(optionItem); ok {
|
|
if item.disabled {
|
|
s.errText = "That option isn't available in this environment."
|
|
break
|
|
}
|
|
if s.onPick != nil {
|
|
return s.onPick(item), nil
|
|
}
|
|
}
|
|
}
|
|
case "esc", "q":
|
|
if s.list.FilterState() == list.Unfiltered {
|
|
if s.onBack != nil {
|
|
return s.onBack(), nil
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
var cmd tea.Cmd
|
|
s.list, cmd = s.list.Update(msg)
|
|
return s, cmd
|
|
}
|
|
|
|
func (s *listScreen) View() string {
|
|
header := renderHeader(s.title, s.desc, s.errText)
|
|
footer := renderFooter(s.footer, s.list.FilterState() != list.Unfiltered)
|
|
return header + s.list.View() + "\n" + footer
|
|
}
|
|
|
|
type confirmScreen struct {
|
|
state *wizardState
|
|
title string
|
|
desc []string
|
|
list list.Model
|
|
footer string
|
|
onYes func() screen
|
|
onNo func() screen
|
|
onBack func() screen
|
|
errText string
|
|
}
|
|
|
|
func newConfirmScreen(state *wizardState, title string, desc []string, yesLabel, yesDesc, noLabel, noDesc string, onYes func() screen, onNo func() screen, onBack func() screen) *confirmScreen {
|
|
items := []optionItem{
|
|
{title: yesLabel, desc: yesDesc, value: "yes"},
|
|
{title: noLabel, desc: noDesc, value: "no"},
|
|
}
|
|
footer := "enter select • esc cancel"
|
|
if onBack != nil {
|
|
footer = "enter select • esc back"
|
|
}
|
|
delegate := list.NewDefaultDelegate()
|
|
l := list.New(itemsToList(items), delegate, 0, 0)
|
|
l.DisableQuitKeybindings()
|
|
l.SetShowHelp(false)
|
|
l.SetFilteringEnabled(false)
|
|
l.SetShowStatusBar(false)
|
|
l.Title = title
|
|
return &confirmScreen{state: state, title: title, desc: desc, list: l, footer: footer, onYes: onYes, onNo: onNo, onBack: onBack}
|
|
}
|
|
|
|
func (s *confirmScreen) Init() tea.Cmd { return nil }
|
|
|
|
func (s *confirmScreen) Update(msg tea.Msg) (screen, tea.Cmd) {
|
|
switch msg := msg.(type) {
|
|
case tea.WindowSizeMsg:
|
|
s.list.SetSize(msg.Width-4, msg.Height-8)
|
|
case tea.KeyMsg:
|
|
switch msg.String() {
|
|
case "enter":
|
|
if item, ok := s.list.SelectedItem().(optionItem); ok {
|
|
if item.value == "yes" && s.onYes != nil {
|
|
return s.onYes(), nil
|
|
}
|
|
if item.value == "no" && s.onNo != nil {
|
|
return s.onNo(), nil
|
|
}
|
|
}
|
|
case "esc", "q":
|
|
if s.onBack != nil {
|
|
return s.onBack(), nil
|
|
}
|
|
if s.onNo != nil {
|
|
return s.onNo(), nil
|
|
}
|
|
}
|
|
}
|
|
|
|
var cmd tea.Cmd
|
|
s.list, cmd = s.list.Update(msg)
|
|
return s, cmd
|
|
}
|
|
|
|
func (s *confirmScreen) View() string {
|
|
header := renderHeader(s.title, s.desc, s.errText)
|
|
footer := renderFooter(s.footer, false)
|
|
return header + s.list.View() + "\n" + footer
|
|
}
|
|
|
|
type inputScreen struct {
|
|
state *wizardState
|
|
title string
|
|
desc []string
|
|
input textinput.Model
|
|
footer string
|
|
errText string
|
|
onSubmit func(string) screen
|
|
onCancel func() screen
|
|
validateFn func(string) error
|
|
}
|
|
|
|
func newInputScreen(state *wizardState, title string, desc []string, value string, placeholder string, password bool, validateFn func(string) error, onSubmit func(string) screen, onCancel func() screen) *inputScreen {
|
|
input := textinput.New()
|
|
input.SetValue(value)
|
|
input.Placeholder = placeholder
|
|
if password {
|
|
input.EchoMode = textinput.EchoPassword
|
|
input.EchoCharacter = '*'
|
|
}
|
|
input.Focus()
|
|
input.CharLimit = 0
|
|
return &inputScreen{
|
|
state: state,
|
|
title: title,
|
|
desc: desc,
|
|
input: input,
|
|
footer: "enter save • esc back",
|
|
onSubmit: onSubmit,
|
|
onCancel: onCancel,
|
|
validateFn: validateFn,
|
|
}
|
|
}
|
|
|
|
func (s *inputScreen) Init() tea.Cmd { return textinput.Blink }
|
|
|
|
func (s *inputScreen) Update(msg tea.Msg) (screen, tea.Cmd) {
|
|
switch msg := msg.(type) {
|
|
case tea.KeyMsg:
|
|
switch msg.String() {
|
|
case "enter":
|
|
value := strings.TrimSpace(s.input.Value())
|
|
if s.validateFn != nil {
|
|
if err := s.validateFn(value); err != nil {
|
|
s.errText = err.Error()
|
|
break
|
|
}
|
|
}
|
|
if s.onSubmit != nil {
|
|
return s.onSubmit(value), nil
|
|
}
|
|
case "esc", "q":
|
|
if s.onCancel != nil {
|
|
return s.onCancel(), nil
|
|
}
|
|
}
|
|
}
|
|
|
|
var cmd tea.Cmd
|
|
s.input, cmd = s.input.Update(msg)
|
|
return s, cmd
|
|
}
|
|
|
|
func (s *inputScreen) View() string {
|
|
header := renderHeader(s.title, s.desc, s.errText)
|
|
footer := renderFooter(s.footer, false)
|
|
return header + s.input.View() + "\n\n" + footer
|
|
}
|
|
|
|
type multiSelectScreen struct {
|
|
state *wizardState
|
|
title string
|
|
desc []string
|
|
list list.Model
|
|
footer string
|
|
errText string
|
|
onSubmit func([]toggleItem) screen
|
|
onCancel func() screen
|
|
requireOne bool
|
|
}
|
|
|
|
func newMultiSelectScreen(state *wizardState, title string, desc []string, items []toggleItem, requireOne bool, onSubmit func([]toggleItem) screen, onCancel func() screen) *multiSelectScreen {
|
|
delegate := list.NewDefaultDelegate()
|
|
l := list.New(toggleItemsToList(items), delegate, 0, 0)
|
|
l.DisableQuitKeybindings()
|
|
l.SetShowHelp(false)
|
|
l.SetFilteringEnabled(true)
|
|
l.SetShowStatusBar(false)
|
|
l.Title = title
|
|
return &multiSelectScreen{
|
|
state: state,
|
|
title: title,
|
|
desc: desc,
|
|
list: l,
|
|
footer: "space toggle • enter save • esc back • / filter",
|
|
onSubmit: onSubmit,
|
|
onCancel: onCancel,
|
|
requireOne: requireOne,
|
|
}
|
|
}
|
|
|
|
func (s *multiSelectScreen) Init() tea.Cmd { return nil }
|
|
|
|
func (s *multiSelectScreen) Update(msg tea.Msg) (screen, tea.Cmd) {
|
|
switch msg := msg.(type) {
|
|
case tea.WindowSizeMsg:
|
|
s.list.SetSize(msg.Width-4, msg.Height-8)
|
|
case tea.KeyMsg:
|
|
switch msg.String() {
|
|
case " ":
|
|
idx := s.list.Index()
|
|
items := s.list.Items()
|
|
if idx >= 0 && idx < len(items) {
|
|
if item, ok := items[idx].(toggleItem); ok {
|
|
item.selected = !item.selected
|
|
items[idx] = item
|
|
s.list.SetItems(items)
|
|
}
|
|
}
|
|
case "enter":
|
|
items := listToToggleItems(s.list.Items())
|
|
if s.requireOne {
|
|
has := false
|
|
for _, item := range items {
|
|
if item.selected {
|
|
has = true
|
|
break
|
|
}
|
|
}
|
|
if !has {
|
|
s.errText = "Select at least one option to continue."
|
|
break
|
|
}
|
|
}
|
|
if s.onSubmit != nil {
|
|
return s.onSubmit(items), nil
|
|
}
|
|
case "esc", "q":
|
|
if s.list.FilterState() == list.Unfiltered {
|
|
if s.onCancel != nil {
|
|
return s.onCancel(), nil
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
var cmd tea.Cmd
|
|
s.list, cmd = s.list.Update(msg)
|
|
return s, cmd
|
|
}
|
|
|
|
func (s *multiSelectScreen) View() string {
|
|
header := renderHeader(s.title, s.desc, s.errText)
|
|
footer := renderFooter(s.footer, s.list.FilterState() != list.Unfiltered)
|
|
return header + s.list.View() + "\n" + footer
|
|
}
|
|
|
|
type infoScreen struct {
|
|
state *wizardState
|
|
title string
|
|
desc []string
|
|
footer string
|
|
next func() screen
|
|
back func() screen
|
|
}
|
|
|
|
func newInfoScreen(state *wizardState, title string, desc []string, next func() screen, back func() screen) *infoScreen {
|
|
return &infoScreen{state: state, title: title, desc: desc, footer: "enter continue • esc back", next: next, back: back}
|
|
}
|
|
|
|
func (s *infoScreen) Init() tea.Cmd {
|
|
return nil
|
|
}
|
|
|
|
func (s *infoScreen) Update(msg tea.Msg) (screen, tea.Cmd) {
|
|
switch msg := msg.(type) {
|
|
case tea.KeyMsg:
|
|
switch msg.String() {
|
|
case "enter":
|
|
if s.next != nil {
|
|
return s.next(), nil
|
|
}
|
|
case "esc", "q":
|
|
if s.back != nil {
|
|
return s.back(), nil
|
|
}
|
|
}
|
|
}
|
|
return s, nil
|
|
}
|
|
|
|
func (s *infoScreen) View() string {
|
|
header := renderHeader(s.title, s.desc, "")
|
|
footer := renderFooter(s.footer, false)
|
|
return header + "\n" + footer
|
|
}
|
|
|
|
type formField struct {
|
|
key string
|
|
label string
|
|
desc string
|
|
input textinput.Model
|
|
validate func(string) error
|
|
required bool
|
|
sensitive bool
|
|
}
|
|
|
|
type formScreen struct {
|
|
state *wizardState
|
|
title string
|
|
desc []string
|
|
fields []formField
|
|
focused int
|
|
footer string
|
|
errText string
|
|
onSubmit func(map[string]string) screen
|
|
onCancel func() screen
|
|
}
|
|
|
|
func newFormScreen(state *wizardState, title string, desc []string, fields []formField, onSubmit func(map[string]string) screen, onCancel func() screen) *formScreen {
|
|
if len(fields) > 0 {
|
|
fields[0].input.Focus()
|
|
}
|
|
return &formScreen{state: state, title: title, desc: desc, fields: fields, onSubmit: onSubmit, onCancel: onCancel}
|
|
}
|
|
|
|
func (s *formScreen) Init() tea.Cmd { return textinput.Blink }
|
|
|
|
func (s *formScreen) Update(msg tea.Msg) (screen, tea.Cmd) {
|
|
switch msg := msg.(type) {
|
|
case tea.KeyMsg:
|
|
switch msg.String() {
|
|
case "esc", "q":
|
|
if s.onCancel != nil {
|
|
return s.onCancel(), nil
|
|
}
|
|
case "tab", "down":
|
|
s.moveFocus(1)
|
|
case "shift+tab", "up":
|
|
s.moveFocus(-1)
|
|
case "enter":
|
|
if s.focused == len(s.fields)-1 {
|
|
values, err := s.validateAll()
|
|
if err != nil {
|
|
s.errText = err.Error()
|
|
break
|
|
}
|
|
if s.onSubmit != nil {
|
|
return s.onSubmit(values), nil
|
|
}
|
|
} else {
|
|
s.moveFocus(1)
|
|
}
|
|
}
|
|
}
|
|
|
|
var cmd tea.Cmd
|
|
if s.focused >= 0 && s.focused < len(s.fields) {
|
|
s.fields[s.focused].input, cmd = s.fields[s.focused].input.Update(msg)
|
|
}
|
|
return s, cmd
|
|
}
|
|
|
|
func (s *formScreen) View() string {
|
|
header := renderHeader(s.title, s.desc, s.errText)
|
|
body := strings.Builder{}
|
|
for i, field := range s.fields {
|
|
label := StyleLabel.Render(field.label)
|
|
if i == s.focused {
|
|
label = StyleHighlight.Render(field.label)
|
|
}
|
|
body.WriteString(label)
|
|
if field.desc != "" {
|
|
body.WriteString("\n")
|
|
body.WriteString(StyleSubtle.Render(field.desc))
|
|
}
|
|
body.WriteString("\n")
|
|
body.WriteString(field.input.View())
|
|
body.WriteString("\n\n")
|
|
}
|
|
footer := renderFooter(s.footer, false)
|
|
return header + body.String() + footer
|
|
}
|
|
|
|
func (s *formScreen) moveFocus(delta int) {
|
|
if len(s.fields) == 0 {
|
|
return
|
|
}
|
|
s.fields[s.focused].input.Blur()
|
|
s.focused = (s.focused + delta + len(s.fields)) % len(s.fields)
|
|
s.fields[s.focused].input.Focus()
|
|
}
|
|
|
|
func (s *formScreen) validateAll() (map[string]string, error) {
|
|
values := make(map[string]string, len(s.fields))
|
|
for _, field := range s.fields {
|
|
value := strings.TrimSpace(field.input.Value())
|
|
if field.required && value == "" {
|
|
return nil, fmt.Errorf("%s is required", field.label)
|
|
}
|
|
if field.validate != nil {
|
|
if err := field.validate(value); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
values[field.key] = value
|
|
}
|
|
return values, nil
|
|
}
|
|
|
|
type downloadProgressMsg struct {
|
|
downloaded int64
|
|
total int64
|
|
}
|
|
|
|
type downloadDoneMsg struct {
|
|
err error
|
|
}
|
|
|
|
type downloadScreen struct {
|
|
state *wizardState
|
|
title string
|
|
desc []string
|
|
modelID string
|
|
progress int
|
|
total int64
|
|
footer string
|
|
errText string
|
|
onSuccess func() screen
|
|
onCancel func() screen
|
|
updates chan tea.Msg
|
|
started bool
|
|
}
|
|
|
|
func newDownloadScreen(state *wizardState, title string, desc []string, modelID string, onSuccess func() screen, onCancel func() screen) *downloadScreen {
|
|
return &downloadScreen{
|
|
state: state,
|
|
title: title,
|
|
desc: desc,
|
|
modelID: modelID,
|
|
onSuccess: onSuccess,
|
|
onCancel: onCancel,
|
|
updates: make(chan tea.Msg),
|
|
}
|
|
}
|
|
|
|
func (s *downloadScreen) Init() tea.Cmd {
|
|
if s.started {
|
|
return listenForDownload(s.updates)
|
|
}
|
|
s.started = true
|
|
return tea.Batch(s.startDownloadCmd(), listenForDownload(s.updates))
|
|
}
|
|
|
|
func (s *downloadScreen) Update(msg tea.Msg) (screen, tea.Cmd) {
|
|
switch msg := msg.(type) {
|
|
case downloadProgressMsg:
|
|
s.total = msg.total
|
|
if msg.total > 0 {
|
|
s.progress = int(msg.downloaded * 100 / msg.total)
|
|
}
|
|
return s, listenForDownload(s.updates)
|
|
case downloadDoneMsg:
|
|
if msg.err != nil {
|
|
s.errText = msg.err.Error()
|
|
return s, nil
|
|
}
|
|
if s.onSuccess != nil {
|
|
return s.onSuccess(), nil
|
|
}
|
|
case tea.KeyMsg:
|
|
switch msg.String() {
|
|
case "esc", "q":
|
|
if s.onCancel != nil {
|
|
return s.onCancel(), nil
|
|
}
|
|
}
|
|
}
|
|
|
|
return s, nil
|
|
}
|
|
|
|
func (s *downloadScreen) View() string {
|
|
header := renderHeader(s.title, s.desc, s.errText)
|
|
progressLine := "Downloading"
|
|
if s.total > 0 {
|
|
progressLine = fmt.Sprintf("Downloading... %d%%", s.progress)
|
|
}
|
|
body := StyleMuted.Render(progressLine) + "\n\n"
|
|
footer := renderFooter(s.footer, false)
|
|
return header + body + footer
|
|
}
|
|
|
|
func (s *downloadScreen) startDownloadCmd() tea.Cmd {
|
|
modelID := s.modelID
|
|
ch := s.updates
|
|
return func() tea.Msg {
|
|
err := downloadWhisperModel(modelID, func(downloaded, total int64) {
|
|
ch <- downloadProgressMsg{downloaded: downloaded, total: total}
|
|
})
|
|
ch <- downloadDoneMsg{err: err}
|
|
return nil
|
|
}
|
|
}
|
|
|
|
func listenForDownload(ch <-chan tea.Msg) tea.Cmd {
|
|
return func() tea.Msg {
|
|
msg, ok := <-ch
|
|
if !ok {
|
|
return nil
|
|
}
|
|
return msg
|
|
}
|
|
}
|
|
|
|
func itemsToList(items []optionItem) []list.Item {
|
|
result := make([]list.Item, len(items))
|
|
for i, item := range items {
|
|
result[i] = item
|
|
}
|
|
return result
|
|
}
|
|
|
|
func toggleItemsToList(items []toggleItem) []list.Item {
|
|
result := make([]list.Item, len(items))
|
|
for i, item := range items {
|
|
result[i] = item
|
|
}
|
|
return result
|
|
}
|
|
|
|
func listToToggleItems(items []list.Item) []toggleItem {
|
|
result := make([]toggleItem, 0, len(items))
|
|
for _, item := range items {
|
|
if t, ok := item.(toggleItem); ok {
|
|
result = append(result, t)
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
func renderHeader(title string, desc []string, errText string) string {
|
|
var b strings.Builder
|
|
if title != "" {
|
|
b.WriteString(StyleHeader.Render(title))
|
|
b.WriteString("\n")
|
|
}
|
|
for _, line := range desc {
|
|
if line == "" {
|
|
continue
|
|
}
|
|
b.WriteString(StyleMuted.Render(line))
|
|
b.WriteString("\n")
|
|
}
|
|
if errText != "" {
|
|
b.WriteString("\n")
|
|
b.WriteString(StyleError.Render(errText))
|
|
b.WriteString("\n")
|
|
}
|
|
b.WriteString("\n")
|
|
return b.String()
|
|
}
|
|
|
|
func renderFooter(extra string, filtering bool) string {
|
|
if extra != "" {
|
|
return StyleSubtle.Render(extra)
|
|
}
|
|
if filtering {
|
|
return StyleSubtle.Render("enter apply • esc clear")
|
|
}
|
|
return StyleSubtle.Render("enter select • esc back")
|
|
}
|
|
|
|
func makeInputField(key, label, desc, value, placeholder string, validate func(string) error) formField {
|
|
input := textinput.New()
|
|
input.SetValue(value)
|
|
input.Placeholder = placeholder
|
|
input.Prompt = ""
|
|
input.Cursor.Style = lipgloss.NewStyle().Foreground(ColorPrimary)
|
|
return formField{key: key, label: label, desc: desc, input: input, validate: validate}
|
|
}
|
|
|
|
func parseDurationOrEmpty(value string) (time.Duration, error) {
|
|
if strings.TrimSpace(value) == "" {
|
|
return 0, fmt.Errorf("duration is required")
|
|
}
|
|
return time.ParseDuration(value)
|
|
}
|