git.stevedylan.dev

chore: refactor TUIs to use bubbletea standards d7e56ea6

Steve Simkins · 2026-05-17 16:50 24 file(s) · +1348 −1024

apps/jotts-go/go.mod +1 −0

	github.com/ncruces/go-strftime v0.1.9 // indirect
	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
	github.com/rivo/uniseg v0.4.7 // indirect
	github.com/sahilm/fuzzy v0.1.1 // indirect
	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
	github.com/yuin/goldmark-emoji v1.0.6 // indirect
	golang.org/x/crypto v0.39.0 // indirect

apps/jotts-go/go.sum +4 −0

github.com/gorilla/css v1.0.1/go.mod h1:BvnYkspnSzMmwRK+b8/xgNPLiIuNZr6vbZBTPQ2A3b0=
github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
github.com/lucasb-eyer/go-colorful v1.4.0 h1:UtrWVfLdarDgc44HcS7pYloGHJUjHV/4FwW4TvVgFr4=
github.com/lucasb-eyer/go-colorful v1.4.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=

github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
github.com/sahilm/fuzzy v0.1.1 h1:ceu5RHF8DGgoi+/dR5PsECjCDH1BE3Fnmpo7aVXOdRA=
github.com/sahilm/fuzzy v0.1.1/go.mod h1:VFvziUEIMCrT6A6tw2RFIXPXXmzXbOsSHF0DOI8ZK9Y=
github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=
github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=
github.com/yuin/goldmark v1.7.13 h1:GPddIs617DnBLFFVJFgpo1aBfe/4xcvMc3SB5t/D0pA=

apps/jotts-go/tui/commands.go (added) +62 −0

1	+	package tui
2	+
3	+	import (
4	+	"strings"
5	+
6	+	tea "charm.land/bubbletea/v2"
7	+	"github.com/atotto/clipboard"
8	+	)
9	+
10	+	func loadNotesCmd(b Backend) tea.Cmd {
11	+	return func() tea.Msg {
12	+	notes, err := b.List()
13	+	return notesLoadedMsg{notes: notes, err: err}
14	+	}
15	+	}
16	+
17	+	func saveNoteCmd(b Backend, shortID, title, content string) tea.Cmd {
18	+	return func() tea.Msg {
19	+	var (
20	+	note *Note
21	+	err error
22	+	)
23	+	if shortID == "" {
24	+	note, err = b.Create(title, content)
25	+	} else {
26	+	note, err = b.Update(shortID, title, content)
27	+	}
28	+	return noteSavedMsg{note: note, err: err}
29	+	}
30	+	}
31	+
32	+	func deleteNoteCmd(b Backend, shortID string) tea.Cmd {
33	+	return func() tea.Msg {
34	+	_, err := b.Delete(shortID)
35	+	return noteDeletedMsg{shortID: shortID, err: err}
36	+	}
37	+	}
38	+
39	+	func copyToClipboardCmd(text, okStatus string) tea.Cmd {
40	+	return func() tea.Msg {
41	+	if err := clipboard.WriteAll(text); err != nil {
42	+	return statusMsg{text: "clipboard: " + err.Error(), ok: false}
43	+	}
44	+	return statusMsg{text: okStatus, ok: true}
45	+	}
46	+	}
47	+
48	+	func openURLCmd(url string) tea.Cmd {
49	+	return func() tea.Msg {
50	+	if err := openURL(url); err != nil {
51	+	return statusMsg{text: "open: " + err.Error(), ok: false}
52	+	}
53	+	return statusMsg{text: "opened " + url, ok: true}
54	+	}
55	+	}
56	+
57	+	func noteLinkURL(remoteBase, shortID string) string {
58	+	if remoteBase == "" {
59	+	return ""
60	+	}
61	+	return strings.TrimRight(remoteBase, "/") + "/notes/" + shortID
62	+	}

apps/jotts-go/tui/content_model.go (added) +89 −0

1	+	package tui
2	+
3	+	import (
4	+	"charm.land/bubbles/v2/viewport"
5	+	tea "charm.land/bubbletea/v2"
6	+	)
7	+
8	+	type contentModel struct {
9	+	vp viewport.Model
10	+	renderer *mdRenderer
11	+	wrap bool
12	+
13	+	shortID string
14	+	title string
15	+	body string
16	+	}
17	+
18	+	func newContentModel() contentModel {
19	+	return contentModel{vp: viewport.New(), wrap: true}
20	+	}
21	+
22	+	func (c contentModel) Update(msg tea.Msg) (contentModel, tea.Cmd) {
23	+	var cmd tea.Cmd
24	+	c.vp, cmd = c.vp.Update(msg)
25	+	return c, cmd
26	+	}
27	+
28	+	func (c *contentModel) SetSize(w, h int) {
29	+	c.vp.SetWidth(w)
30	+	c.vp.SetHeight(h)
31	+	if c.renderer == nil {
32	+	c.renderer = newRenderer(w)
33	+	} else {
34	+	c.renderer.resize(w)
35	+	}
36	+	c.refresh()
37	+	}
38	+
39	+	func (c contentModel) SetNote(n Note) {
40	+	if n == nil {
41	+	c.shortID, c.title, c.body = "", "", ""
42	+	c.vp.SetContent("")
43	+	c.vp.GotoTop()
44	+	return
45	+	}
46	+	c.shortID = n.ShortID
47	+	c.title = n.Title
48	+	c.body = n.Content
49	+	c.vp.GotoTop()
50	+	c.refresh()
51	+	}
52	+
53	+	func (c *contentModel) ToggleWrap() {
54	+	c.wrap = !c.wrap
55	+	c.refresh()
56	+	}
57	+
58	+	func (c *contentModel) Wrap() bool { return c.wrap }
59	+
60	+	func (c *contentModel) Invalidate(shortID string) {
61	+	if c.renderer != nil {
62	+	c.renderer.invalidate(shortID)
63	+	}
64	+	}
65	+
66	+	func (c *contentModel) refresh() {
67	+	if c.body == "" {
68	+	c.vp.SetContent("")
69	+	return
70	+	}
71	+	if !c.wrap \|\| c.renderer == nil {
72	+	c.vp.SetContent(c.body)
73	+	return
74	+	}
75	+	c.vp.SetContent(c.renderer.render(c.shortID, c.body))
76	+	}
77	+
78	+	func (c contentModel) Title() string { return c.title }
79	+	func (c contentModel) View() string { return c.vp.View() }
80	+
81	+	func (c contentModel) ScrollUp(n int) contentModel {
82	+	c.vp.ScrollUp(n)
83	+	return c
84	+	}
85	+
86	+	func (c contentModel) ScrollDown(n int) contentModel {
87	+	c.vp.ScrollDown(n)
88	+	return c
89	+	}

apps/jotts-go/tui/form_model.go (added) +136 −0

1	+	package tui
2	+
3	+	import (
4	+	"strings"
5	+
6	+	"charm.land/bubbles/v2/key"
7	+	"charm.land/bubbles/v2/textarea"
8	+	"charm.land/bubbles/v2/textinput"
9	+	tea "charm.land/bubbletea/v2"
10	+	)
11	+
12	+	type formField uint8
13	+
14	+	const (
15	+	formFieldTitle formField = iota
16	+	formFieldContent
17	+	)
18	+
19	+	type formModel struct {
20	+	title textinput.Model
21	+	content textarea.Model
22	+
23	+	field formField
24	+	shortID string
25	+	isCreate bool
26	+
27	+	keys formKeys
28	+	}
29	+
30	+	type formKeys struct {
31	+	Save key.Binding
32	+	Cancel key.Binding
33	+	SwitchField key.Binding
34	+	}
35	+
36	+	func defaultFormKeys() formKeys {
37	+	return formKeys{
38	+	Save: key.NewBinding(key.WithKeys("ctrl+s"), key.WithHelp("⌃s", "save")),
39	+	Cancel: key.NewBinding(key.WithKeys("esc"), key.WithHelp("esc", "cancel")),
40	+	SwitchField: key.NewBinding(key.WithKeys("tab"), key.WithHelp("⇥", "switch field")),
41	+	}
42	+	}
43	+
44	+	func newFormModel() formModel {
45	+	ti := textinput.New()
46	+	ti.Placeholder = "Title"
47	+	ti.Prompt = ""
48	+	ti.CharLimit = 200
49	+
50	+	ta := textarea.New()
51	+	ta.Placeholder = "Write markdown..."
52	+	ta.ShowLineNumbers = false
53	+	ta.Prompt = ""
54	+
55	+	return formModel{title: ti, content: ta, keys: defaultFormKeys()}
56	+	}
57	+
58	+	func (f *formModel) StartCreate() {
59	+	f.shortID = ""
60	+	f.isCreate = true
61	+	f.title.SetValue("")
62	+	f.content.SetValue("")
63	+	f.field = formFieldTitle
64	+	f.applyFocus()
65	+	}
66	+
67	+	func (f *formModel) StartEdit(n Note) {
68	+	f.shortID = n.ShortID
69	+	f.isCreate = false
70	+	f.title.SetValue(n.Title)
71	+	f.content.SetValue(n.Content)
72	+	f.field = formFieldTitle
73	+	f.applyFocus()
74	+	}
75	+
76	+	func (f *formModel) SetContent(s string) { f.content.SetValue(s) }
77	+
78	+	func (f *formModel) Blur() {
79	+	f.title.Blur()
80	+	f.content.Blur()
81	+	}
82	+
83	+	func (f *formModel) applyFocus() {
84	+	switch f.field {
85	+	case formFieldTitle:
86	+	f.title.Focus()
87	+	f.content.Blur()
88	+	case formFieldContent:
89	+	f.content.Focus()
90	+	f.title.Blur()
91	+	}
92	+	}
93	+
94	+	func (f *formModel) SetSize(w, h int) {
95	+	f.title.SetWidth(max(w-4, 1))
96	+	f.content.SetWidth(max(w-2, 1))
97	+	f.content.SetHeight(max(h-6, 1))
98	+	}
99	+
100	+	func (f formModel) Update(msg tea.Msg) (formModel, tea.Cmd) {
101	+	if km, ok := msg.(tea.KeyPressMsg); ok {
102	+	switch {
103	+	case key.Matches(km, f.keys.Cancel):
104	+	f.Blur()
105	+	return f, func() tea.Msg { return cancelFormMsg{} }
106	+	case key.Matches(km, f.keys.Save):
107	+	title := strings.TrimSpace(f.title.Value())
108	+	if title == "" {
109	+	return f, func() tea.Msg { return statusMsg{text: "title required", ok: false} }
110	+	}
111	+	return f, func() tea.Msg {
112	+	return submitFormMsg{shortID: f.shortID, title: title, content: f.content.Value()}
113	+	}
114	+	case key.Matches(km, f.keys.SwitchField):
115	+	if f.field == formFieldTitle {
116	+	f.field = formFieldContent
117	+	} else {
118	+	f.field = formFieldTitle
119	+	}
120	+	f.applyFocus()
121	+	return f, nil
122	+	}
123	+	}
124	+
125	+	var cmd tea.Cmd
126	+	switch f.field {
127	+	case formFieldTitle:
128	+	f.title, cmd = f.title.Update(msg)
129	+	case formFieldContent:
130	+	f.content, cmd = f.content.Update(msg)
131	+	}
132	+	return f, cmd
133	+	}
134	+
135	+	func (f formModel) ActiveField() formField { return f.field }
136	+	func (f formModel) IsCreate() bool { return f.isCreate }

apps/jotts-go/tui/keys.go +11 −20

import "charm.land/bubbles/v2/key"

type keyMap struct {
	Up          key.Binding
	Down        key.Binding
	Open        key.Binding
	Back        key.Binding
	Quit        key.Binding

	Copy        key.Binding
	CopyLink    key.Binding
	OpenBrowser key.Binding
	Search      key.Binding
	Refresh     key.Binding
	Help        key.Binding
	Save        key.Binding
	ToggleWrap  key.Binding
	SwitchField key.Binding
	Cancel      key.Binding
	ScrollUp    key.Binding
	ScrollDown  key.Binding
}

func defaultKeys() keyMap {
	return keyMap{
		Up:          key.NewBinding(key.WithKeys("up", "k"), key.WithHelp("↑/k", "up")),
		Down:        key.NewBinding(key.WithKeys("down", "j"), key.WithHelp("↓/j", "down")),
		Open:        key.NewBinding(key.WithKeys("enter", "l"), key.WithHelp("⏎/l", "open")),
		Back:        key.NewBinding(key.WithKeys("h", "esc", " "), key.WithHelp("h/␣", "back")),
		Quit:        key.NewBinding(key.WithKeys("q"), key.WithHelp("q", "quit")),
		Back:        key.NewBinding(key.WithKeys("h", "esc"), key.WithHelp("h/esc", "back")),
		Quit:        key.NewBinding(key.WithKeys("q", "ctrl+c"), key.WithHelp("q", "quit")),
		Create:      key.NewBinding(key.WithKeys("c"), key.WithHelp("c", "create")),
		Edit:        key.NewBinding(key.WithKeys("e"), key.WithHelp("e", "edit")),
		ExtEdit:     key.NewBinding(key.WithKeys("E"), key.WithHelp("E", "$EDITOR")),

		Copy:        key.NewBinding(key.WithKeys("y"), key.WithHelp("y", "copy text")),
		CopyLink:    key.NewBinding(key.WithKeys("Y"), key.WithHelp("Y", "copy link")),
		OpenBrowser: key.NewBinding(key.WithKeys("o"), key.WithHelp("o", "browser")),
		Search:      key.NewBinding(key.WithKeys("/"), key.WithHelp("/", "search")),
		Refresh:     key.NewBinding(key.WithKeys("r"), key.WithHelp("r", "refresh")),
		Help:        key.NewBinding(key.WithKeys("?"), key.WithHelp("?", "help")),
		Save:        key.NewBinding(key.WithKeys("ctrl+s"), key.WithHelp("⌃s", "save")),
		ToggleWrap:  key.NewBinding(key.WithKeys("ctrl+w"), key.WithHelp("⌃w", "wrap")),
		SwitchField: key.NewBinding(key.WithKeys("tab"), key.WithHelp("⇥", "switch field")),
		Cancel:      key.NewBinding(key.WithKeys("esc"), key.WithHelp("esc", "cancel")),
		ScrollUp:    key.NewBinding(key.WithKeys("up", "k"), key.WithHelp("↑/k", "up")),
		ScrollDown:  key.NewBinding(key.WithKeys("down", "j"), key.WithHelp("↓/j", "down")),
	}
}

func (k keyMap) ShortHelp() []key.Binding {
	return []key.Binding{k.Open, k.Create, k.Edit, k.Delete, k.Search, k.Help, k.Quit}
	return []key.Binding{k.Open, k.Create, k.Edit, k.Delete, k.Help, k.Quit}
}

func (k keyMap) FullHelp() [][]key.Binding {
	return [][]key.Binding{
		{k.Up, k.Down, k.Open, k.Back},
		{k.Create, k.Edit, k.ExtEdit, k.Delete},
		{k.Copy, k.CopyLink, k.OpenBrowser, k.Search},
		{k.Refresh, k.Help, k.Save, k.ToggleWrap},
		{k.SwitchField, k.Cancel, k.Quit},
		{k.Open, k.Back, k.Create, k.Edit},
		{k.ExtEdit, k.Delete, k.Copy, k.CopyLink},
		{k.OpenBrowser, k.Refresh, k.ToggleWrap, k.Help},
		{k.ScrollUp, k.ScrollDown, k.Quit},
	}
}

apps/jotts-go/tui/list_model.go (added) +96 −0

1	+	package tui
2	+
3	+	import (
4	+	"charm.land/bubbles/v2/list"
5	+	tea "charm.land/bubbletea/v2"
6	+	"charm.land/lipgloss/v2"
7	+	)
8	+
9	+	func ansiListDelegate() list.DefaultDelegate {
10	+	d := list.NewDefaultDelegate()
11	+	d.ShowDescription = false
12	+	d.SetSpacing(0)
13	+	d.Styles.NormalTitle = lipgloss.NewStyle().Foreground(lipgloss.Color("7")).Padding(0, 0, 0, 2)
14	+	d.Styles.SelectedTitle = lipgloss.NewStyle().
15	+	Foreground(lipgloss.Color("3")).
16	+	Bold(true).
17	+	Border(lipgloss.NormalBorder(), false, false, false, true).
18	+	BorderForeground(lipgloss.Color("3")).
19	+	Padding(0, 0, 0, 1)
20	+	d.Styles.DimmedTitle = lipgloss.NewStyle().Foreground(lipgloss.Color("8")).Padding(0, 0, 0, 2)
21	+	d.Styles.FilterMatch = lipgloss.NewStyle().Underline(true).Foreground(lipgloss.Color("3"))
22	+	return d
23	+	}
24	+
25	+	func ansiListStyles() list.Styles {
26	+	s := list.DefaultStyles(true)
27	+	s.Title = lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("3")).Padding(0, 1)
28	+	s.TitleBar = lipgloss.NewStyle().Padding(0, 0, 1, 0)
29	+	s.NoItems = lipgloss.NewStyle().Foreground(lipgloss.Color("8")).Padding(0, 0, 0, 2)
30	+	s.DefaultFilterCharacterMatch = lipgloss.NewStyle().Underline(true).Foreground(lipgloss.Color("3"))
31	+	return s
32	+	}
33	+
34	+	type noteItem struct {
35	+	note Note
36	+	}
37	+
38	+	func (n noteItem) Title() string { return n.note.Title }
39	+	func (n noteItem) Description() string { return "" }
40	+	func (n noteItem) FilterValue() string { return n.note.Title }
41	+
42	+	type listModel struct {
43	+	inner list.Model
44	+	}
45	+
46	+	func newListModel(notes []Note) listModel {
47	+	items := make([]list.Item, 0, len(notes))
48	+	for _, n := range notes {
49	+	items = append(items, noteItem{note: n})
50	+	}
51	+
52	+	l := list.New(items, ansiListDelegate(), 0, 0)
53	+	l.Title = "notes"
54	+	l.Styles = ansiListStyles()
55	+	l.SetShowStatusBar(false)
56	+	l.SetShowPagination(false)
57	+	l.SetShowHelp(false)
58	+	l.SetFilteringEnabled(true)
59	+	l.DisableQuitKeybindings()
60	+
61	+	return listModel{inner: l}
62	+	}
63	+
64	+	func (l listModel) Update(msg tea.Msg) (listModel, tea.Cmd) {
65	+	var cmd tea.Cmd
66	+	l.inner, cmd = l.inner.Update(msg)
67	+	return l, cmd
68	+	}
69	+
70	+	func (l listModel) View() string { return l.inner.View() }
71	+
72	+	func (l *listModel) SetSize(w, h int) { l.inner.SetSize(w, h) }
73	+
74	+	func (l *listModel) SetNotes(notes []Note) tea.Cmd {
75	+	items := make([]list.Item, 0, len(notes))
76	+	for _, n := range notes {
77	+	items = append(items, noteItem{note: n})
78	+	}
79	+	return l.inner.SetItems(items)
80	+	}
81	+
82	+	func (l listModel) Selected() (Note, bool) {
83	+	it := l.inner.SelectedItem()
84	+	if it == nil {
85	+	return Note{}, false
86	+	}
87	+	n, ok := it.(noteItem)
88	+	if !ok {
89	+	return Note{}, false
90	+	}
91	+	return n.note, true
92	+	}
93	+
94	+	func (l listModel) IsFiltering() bool {
95	+	return l.inner.SettingFilter()
96	+	}

apps/jotts-go/tui/messages.go +8 −0

27	27		}
28	28
29	29		type clearStatusMsg struct{}
	30	+
	31	+	type submitFormMsg struct {
	32	+	shortID string
	33	+	title string
	34	+	content string
	35	+	}
	36	+
	37	+	type cancelFormMsg struct{}

apps/jotts-go/tui/model.go +25 −109

package tui

import (
	"strings"
	"time"

	"charm.land/bubbles/v2/help"
	"charm.land/bubbles/v2/textarea"
	"charm.land/bubbles/v2/textinput"
	"charm.land/bubbles/v2/viewport"
	tea "charm.land/bubbletea/v2"
)

type Focus int
type sessionState uint8

const (
	FocusList Focus = iota
	FocusContent
	FocusCreateTitle
	FocusCreateContent
	FocusEditTitle
	FocusEditContent
	FocusSearch
	stateList sessionState = iota
	stateContent
	stateForm
)

type Model struct {
	backend  Backend
	isRemote bool

	notes    []Note
	filtered []int
	cursor   int
	state sessionState
	list  listModel
	cont  contentModel
	form  formModel

	width, height int
	ready         bool

	focus         Focus
	showHelp      bool
	confirmDelete bool

	titleInput  textinput.Model
	contentArea textarea.Model
	searchInput textinput.Model
	contentVP   viewport.Model
	help        help.Model
	keys        keyMap

	renderer *mdRenderer
	wrap     bool

	editShortID string

	status      string
	statusOK    bool
	statusUntil time.Time

	width, height int
	ready         bool
	err           error
	help help.Model
	keys keyMap
}

func newModel(backend Backend, notes []Note, width, height int) Model {
	ti := textinput.New()
	ti.Placeholder = "Title"
	ti.Prompt = ""
	ti.CharLimit = 200

	ta := textarea.New()
	ta.Placeholder = "Write markdown..."
	ta.ShowLineNumbers = false
	ta.Prompt = ""

	si := textinput.New()
	si.Placeholder = "search titles"
	si.Prompt = "/ "

	vp := viewport.New()

	m := Model{
		backend:     backend,
		isRemote:    backend.RemoteURL() != "",
		notes:       notes,
		focus:       FocusList,
		titleInput:  ti,
		contentArea: ta,
		searchInput: si,
		contentVP:   vp,
		help:        help.New(),
		keys:        defaultKeys(),
		wrap:        true,
		width:       width,
		height:      height,
		ready:       true,
		backend:  backend,
		isRemote: backend.RemoteURL() != "",
		state:    stateList,
		list:     newListModel(notes),
		cont:     newContentModel(),
		form:     newFormModel(),
		help:     help.New(),
		keys:     defaultKeys(),
		width:    width,
		height:   height,
		ready:    true,
	}
	m.resizePanes()
	m.applyLayout()
	return m
}

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

func (m *Model) visibleNotes() []Note {
	if m.filtered == nil {
		return m.notes
	}
	out := make([]Note, 0, len(m.filtered))
	for _, i := range m.filtered {
		out = append(out, m.notes[i])
	}
	return out
}

func (m *Model) currentNote() *Note {
	notes := m.visibleNotes()
	if m.cursor < 0 || m.cursor >= len(notes) {
		return nil
	}
	return &notes[m.cursor]
}

func (m *Model) applyFilter(q string) {
	q = strings.TrimSpace(strings.ToLower(q))
	if q == "" {
		m.filtered = nil
		if m.cursor >= len(m.notes) {
			m.cursor = 0
		}
		return
	}
	idx := []int{}
	for i, n := range m.notes {
		if strings.Contains(strings.ToLower(n.Title), q) {
			idx = append(idx, i)
		}
	}
	m.filtered = idx
	if m.cursor >= len(idx) {
		m.cursor = 0
	}
}

func (m *Model) setStatus(text string, ok bool) tea.Cmd {
	m.status = text
	m.statusOK = ok
	m.statusUntil = time.Now().Add(2 * time.Second)
	return tea.Tick(2*time.Second, func(time.Time) tea.Msg { return clearStatusMsg{} })
}

apps/jotts-go/tui/render_md.go +26 −1

	"charm.land/glamour/v2/ansi"
)

const mdCacheMax = 64

type mdRenderer struct {
	r     *glamour.TermRenderer
	width int
	cache map[string]string
	order []string
}

func sp(s string) *string { return &s }

	return &mdRenderer{r: r, width: width, cache: map[string]string{}}
}

func (m *mdRenderer) store(key, value string) {
	if _, ok := m.cache[key]; !ok {
		m.order = append(m.order, key)
		if len(m.order) > mdCacheMax {
			drop := m.order[0]
			m.order = m.order[1:]
			delete(m.cache, drop)
		}
	}
	m.cache[key] = value
}

func (m *mdRenderer) resize(width int) {
	if width == m.width || width < 20 {
		return

	m.r = r
	m.width = width
	m.cache = map[string]string{}
	m.order = nil
}

func (m *mdRenderer) render(key, body string) string {

	if err != nil {
		out = fmt.Sprintf("render error: %v\n\n%s", err, body)
	}
	m.cache[key] = out
	m.store(key, out)
	return out
}

func (m *mdRenderer) invalidate(key string) {
	if _, ok := m.cache[key]; !ok {
		return
	}
	delete(m.cache, key)
	for i, k := range m.order {
		if k == key {
			m.order = append(m.order[:i], m.order[i+1:]...)
			break
		}
	}
}

apps/jotts-go/tui/update.go +148 −261


import (
	"strings"
	"time"

	"github.com/atotto/clipboard"
	"charm.land/bubbles/v2/key"
	tea "charm.land/bubbletea/v2"
)

func loadNotesCmd(b Backend) tea.Cmd {
	return func() tea.Msg {
		notes, err := b.List()
		return notesLoadedMsg{notes: notes, err: err}
	}
}

func saveNoteCmd(b Backend, shortID, title, content string) tea.Cmd {
	return func() tea.Msg {
		var (
			note *Note
			err  error
		)
		if shortID == "" {
			note, err = b.Create(title, content)
		} else {
			note, err = b.Update(shortID, title, content)
		}
		return noteSavedMsg{note: note, err: err}
	}
}

func deleteNoteCmd(b Backend, shortID string) tea.Cmd {
	return func() tea.Msg {
		_, err := b.Delete(shortID)
		return noteDeletedMsg{shortID: shortID, err: err}
	}
}

func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
	switch msg := msg.(type) {

	case tea.WindowSizeMsg:
		m.width, m.height = msg.Width, msg.Height
		m.ready = true
		m.resizePanes()
		m.applyLayout()
		return m, nil

	case notesLoadedMsg:
		if msg.err != nil {
			cmd := m.setStatus("load: "+msg.err.Error(), false)
			return m, cmd
			return m, m.setStatus("load: "+msg.err.Error(), false)
		}
		m.notes = msg.notes
		m.applyFilter(m.searchInput.Value())
		m.refreshPreview()
		return m, nil
		cmd := m.list.SetNotes(msg.notes)
		if n, ok := m.list.Selected(); ok {
			m.cont.SetNote(&n)
		} else {
			m.cont.SetNote(nil)
		}
		return m, cmd

	case noteSavedMsg:
		if msg.err != nil {
			return m, m.setStatus("save: "+msg.err.Error(), false)
		}
		if m.renderer != nil && msg.note != nil {
			m.renderer.invalidate(msg.note.ShortID)
		if msg.note != nil {
			m.cont.Invalidate(msg.note.ShortID)
		}
		m.focus = FocusList
		m.titleInput.Reset()
		m.contentArea.Reset()
		m.editShortID = ""
		return m, loadNotesCmd(m.backend)
		m.state = stateList
		m.form.Blur()
		return m, tea.Batch(loadNotesCmd(m.backend), m.setStatus("saved", true))

	case noteDeletedMsg:
		if msg.err != nil {
			return m, m.setStatus("delete: "+msg.err.Error(), false)
		}
		if m.renderer != nil {
			m.renderer.invalidate(msg.shortID)
		}
		m.cont.Invalidate(msg.shortID)
		m.state = stateList
		return m, tea.Batch(loadNotesCmd(m.backend), m.setStatus("deleted", true))

	case editorFinishedMsg:

			return m, m.setStatus("editor: "+msg.err.Error(), false)
		}
		if msg.shortID == "" {
			m.contentArea.SetValue(msg.content)
			m.form.SetContent(msg.content)
			return m, nil
		}
		var orig *Note
		for i := range m.notes {
			if m.notes[i].ShortID == msg.shortID {
				orig = &m.notes[i]
		for _, it := range m.list.inner.Items() {
			ni, ok := it.(noteItem)
			if ok && ni.note.ShortID == msg.shortID {
				n := ni.note
				orig = &n
				break
			}
		}

		}
		return m, saveNoteCmd(m.backend, msg.shortID, orig.Title, msg.content)

	case submitFormMsg:
		return m, saveNoteCmd(m.backend, msg.shortID, msg.title, msg.content)

	case cancelFormMsg:
		m.state = stateList
		return m, nil

	case statusMsg:
		return m, m.setStatus(msg.text, msg.ok)

	case clearStatusMsg:
		if time.Now().Before(m.statusUntil) {
			return m, nil
		}
		m.status = ""
		return m, nil


	return m, nil
}

func (m *Model) resizePanes() {
	if !m.ready {
		return
	}

	_, contentOuterW := splitWidths(m.width)
	bodyOuterH := splitBodyHeight(m.height)
	contentInnerW := maxInt(contentOuterW-paneFrameWidth(), 20)
	contentInnerH := maxInt(bodyOuterH-paneFrameHeight(), 3)

	m.contentVP.SetWidth(maxInt(contentInnerW, 1))
	m.contentVP.SetHeight(maxInt(contentInnerH-1, 1))

	m.titleInput.SetWidth(maxInt(contentInnerW-4, 1))
	m.contentArea.SetWidth(maxInt(contentInnerW-2, 1))
	m.contentArea.SetHeight(maxInt(contentInnerH-6, 1))

	listOuterW, _ := splitWidths(m.width)
	listInnerW := maxInt(listOuterW-paneFrameWidth(), 1)
	m.searchInput.SetWidth(maxInt(listInnerW-2, 1))

	if m.renderer == nil {
		m.renderer = newRenderer(contentInnerW)
	} else {
		m.renderer.resize(contentInnerW)
	}
	m.refreshPreview()
}

func (m *Model) refreshPreview() {
	if m.renderer == nil {
		return
	}
	n := m.currentNote()
	if n == nil {
		m.contentVP.SetContent("")
		return
	}
	body := n.Content
	if !m.wrap {
		// raw view: no rendering
		m.contentVP.SetContent(body)
		return
	}
	m.contentVP.SetContent(m.renderer.render(n.ShortID, body))
}

func (m Model) handleKey(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) {
	if m.confirmDelete {
		switch msg.String() {
		case "y", "Y":
			n := m.currentNote()
			m.confirmDelete = false
			if n == nil {
			n, ok := m.list.Selected()
			if !ok {
				return m, nil
			}
			return m, deleteNoteCmd(m.backend, n.ShortID)
		case "n", "N", "esc", "q":
			m.confirmDelete = false
			return m, nil
		}
		return m, nil
	}

		return m, nil
	}

	switch m.focus {
	case FocusList:
		return m.keyList(msg)
	case FocusContent:
		return m.keyContent(msg)
	case FocusCreateTitle, FocusCreateContent, FocusEditTitle, FocusEditContent:
		return m.keyForm(msg)
	case FocusSearch:
		return m.keySearch(msg)
	switch m.state {
	case stateList:
		return m.handleListKey(msg)
	case stateContent:
		return m.handleContentKey(msg)
	case stateForm:
		var cmd tea.Cmd
		m.form, cmd = m.form.Update(msg)
		return m, cmd
	}
	return m, nil
}

func (m Model) keyList(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) {
	notes := m.visibleNotes()
func (m Model) handleListKey(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) {
	// While the list is in filter-entry mode, route every key to it
	// so typing and esc/enter behave as expected.
	if m.list.IsFiltering() {
		var cmd tea.Cmd
		m.list, cmd = m.list.Update(msg)
		m.refreshContentFromSelection()
		return m, cmd
	}

	switch {
	case key.Matches(msg, m.keys.Quit):
		return m, tea.Quit
	case key.Matches(msg, m.keys.Down):
		if m.cursor < len(notes)-1 {
			m.cursor++
			m.refreshPreview()
		}
	case key.Matches(msg, m.keys.Up):
		if m.cursor > 0 {
			m.cursor--
			m.refreshPreview()
		}
	case key.Matches(msg, m.keys.Open):
		if len(notes) > 0 {
			m.focus = FocusContent
			m.contentVP.GotoTop()
		if n, ok := m.list.Selected(); ok {
			m.cont.SetNote(&n)
			m.state = stateContent
		}
		return m, nil
	case key.Matches(msg, m.keys.Create):
		m.focus = FocusCreateTitle
		m.editShortID = ""
		m.titleInput.SetValue("")
		m.contentArea.SetValue("")
		m.titleInput.Focus()
		m.contentArea.Blur()
		m.form.StartCreate()
		m.state = stateForm
		return m, nil
	case key.Matches(msg, m.keys.Edit):
		n := m.currentNote()
		if n != nil {
			m.focus = FocusEditTitle
			m.editShortID = n.ShortID
			m.titleInput.SetValue(n.Title)
			m.contentArea.SetValue(n.Content)
			m.titleInput.Focus()
			m.contentArea.Blur()
		if n, ok := m.list.Selected(); ok {
			m.form.StartEdit(n)
			m.state = stateForm
		}
		return m, nil
	case key.Matches(msg, m.keys.ExtEdit):
		n := m.currentNote()
		if n != nil {
		if n, ok := m.list.Selected(); ok {
			return m, openExternalEditor(n.ShortID, n.Content)
		}
		return m, nil
	case key.Matches(msg, m.keys.Delete):
		if m.currentNote() != nil {
		if _, ok := m.list.Selected(); ok {
			m.confirmDelete = true
		}
		return m, nil
	case key.Matches(msg, m.keys.Copy):
		n := m.currentNote()
		if n != nil {
			if err := clipboard.WriteAll(n.Content); err != nil {
				return m, m.setStatus("clipboard: "+err.Error(), false)
			}
			return m, m.setStatus("copied text", true)
		if n, ok := m.list.Selected(); ok {
			return m, copyToClipboardCmd(n.Content, "copied text")
		}
		return m, nil
	case key.Matches(msg, m.keys.CopyLink):
		n := m.currentNote()
		if n != nil && m.isRemote {
			link := strings.TrimRight(m.backend.RemoteURL(), "/") + "/notes/" + n.ShortID
			if err := clipboard.WriteAll(link); err != nil {
				return m, m.setStatus("clipboard: "+err.Error(), false)
			}
			return m, m.setStatus("copied link", true)
		if !m.isRemote {
			return m, m.setStatus("local mode: no link", false)
		}
		if n, ok := m.list.Selected(); ok {
			return m, copyToClipboardCmd(noteLinkURL(m.backend.RemoteURL(), n.ShortID), "copied link")
		}
		return m, m.setStatus("local mode: no link", false)
		return m, nil
	case key.Matches(msg, m.keys.OpenBrowser):
		n := m.currentNote()
		if n != nil && m.isRemote {
			link := strings.TrimRight(m.backend.RemoteURL(), "/") + "/notes/" + n.ShortID
			if err := openURL(link); err != nil {
				return m, m.setStatus("open: "+err.Error(), false)
			}
			return m, m.setStatus("opened "+link, true)
		if !m.isRemote {
			return m, nil
		}
		if n, ok := m.list.Selected(); ok {
			return m, openURLCmd(noteLinkURL(m.backend.RemoteURL(), n.ShortID))
		}
	case key.Matches(msg, m.keys.Search):
		m.focus = FocusSearch
		m.searchInput.Focus()
		return m, nil
	case key.Matches(msg, m.keys.Refresh):
		if m.isRemote {
			return m, loadNotesCmd(m.backend)
		}
		return m, nil
	case key.Matches(msg, m.keys.Help):
		m.showHelp = true
		return m, nil
	}
	return m, nil

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

func (m Model) keyContent(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) {
func (m Model) handleContentKey(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) {
	switch {
	case key.Matches(msg, m.keys.Quit), key.Matches(msg, m.keys.Back):
		m.focus = FocusList
		m.state = stateList
		return m, nil
	case key.Matches(msg, m.keys.ScrollDown):
		m.cont = m.cont.ScrollDown(1)
		return m, nil
	case key.Matches(msg, m.keys.Down):
		m.contentVP.ScrollDown(1)
	case key.Matches(msg, m.keys.Up):
		m.contentVP.ScrollUp(1)
	case key.Matches(msg, m.keys.ScrollUp):
		m.cont = m.cont.ScrollUp(1)
		return m, nil
	case key.Matches(msg, m.keys.Edit):
		n := m.currentNote()
		if n != nil {
			m.focus = FocusEditTitle
			m.editShortID = n.ShortID
			m.titleInput.SetValue(n.Title)
			m.contentArea.SetValue(n.Content)
			m.titleInput.Focus()
		if n, ok := m.list.Selected(); ok {
			m.form.StartEdit(n)
			m.state = stateForm
		}
		return m, nil
	case key.Matches(msg, m.keys.ExtEdit):
		n := m.currentNote()
		if n != nil {
		if n, ok := m.list.Selected(); ok {
			return m, openExternalEditor(n.ShortID, n.Content)
		}
		return m, nil
	case key.Matches(msg, m.keys.Copy):
		n := m.currentNote()
		if n != nil {
			clipboard.WriteAll(n.Content)
			return m, m.setStatus("copied text", true)
		if n, ok := m.list.Selected(); ok {
			return m, copyToClipboardCmd(n.Content, "copied text")
		}
		return m, nil
	case key.Matches(msg, m.keys.CopyLink):
		n := m.currentNote()
		if n != nil && m.isRemote {
			link := strings.TrimRight(m.backend.RemoteURL(), "/") + "/notes/" + n.ShortID
			clipboard.WriteAll(link)
			return m, m.setStatus("copied link", true)
		if !m.isRemote {
			return m, m.setStatus("local mode: no link", false)
		}
	case key.Matches(msg, m.keys.OpenBrowser):
		n := m.currentNote()
		if n != nil && m.isRemote {
			openURL(strings.TrimRight(m.backend.RemoteURL(), "/") + "/notes/" + n.ShortID)
		if n, ok := m.list.Selected(); ok {
			return m, copyToClipboardCmd(noteLinkURL(m.backend.RemoteURL(), n.ShortID), "copied link")
		}
	case key.Matches(msg, m.keys.Help):
		m.showHelp = true
	case key.Matches(msg, m.keys.ToggleWrap):
		m.wrap = !m.wrap
		m.refreshPreview()
	}
	var cmd tea.Cmd
	m.contentVP, cmd = m.contentVP.Update(msg)
	return m, cmd
}

func (m Model) keyForm(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) {
	switch {
	case key.Matches(msg, m.keys.Cancel):
		m.focus = FocusList
		m.titleInput.Blur()
		m.contentArea.Blur()
		return m, nil
	case key.Matches(msg, m.keys.Save):
		title := strings.TrimSpace(m.titleInput.Value())
		if title == "" {
			return m, m.setStatus("title required", false)
	case key.Matches(msg, m.keys.OpenBrowser):
		if !m.isRemote {
			return m, nil
		}
		return m, saveNoteCmd(m.backend, m.editShortID, title, m.contentArea.Value())
	case key.Matches(msg, m.keys.SwitchField):
		switch m.focus {
		case FocusCreateTitle:
			m.focus = FocusCreateContent
		case FocusCreateContent:
			m.focus = FocusCreateTitle
		case FocusEditTitle:
			m.focus = FocusEditContent
		case FocusEditContent:
			m.focus = FocusEditTitle
		if n, ok := m.list.Selected(); ok {
			return m, openURLCmd(noteLinkURL(m.backend.RemoteURL(), n.ShortID))
		}
		m.applyFormFocus()
		return m, nil
	case key.Matches(msg, m.keys.ToggleWrap):
		m.wrap = !m.wrap
		m.cont.ToggleWrap()
		return m, nil
	case key.Matches(msg, m.keys.Help):
		m.showHelp = true
		return m, nil
	}

	var cmd tea.Cmd
	switch m.focus {
	case FocusCreateTitle, FocusEditTitle:
		m.titleInput, cmd = m.titleInput.Update(msg)
	case FocusCreateContent, FocusEditContent:
		m.contentArea, cmd = m.contentArea.Update(msg)
	}
	m.cont, cmd = m.cont.Update(msg)
	return m, cmd
}

func (m *Model) applyFormFocus() {
	switch m.focus {
	case FocusCreateTitle, FocusEditTitle:
		m.titleInput.Focus()
		m.contentArea.Blur()
	case FocusCreateContent, FocusEditContent:
		m.contentArea.Focus()
		m.titleInput.Blur()
func (m *Model) refreshContentFromSelection() {
	if n, ok := m.list.Selected(); ok {
		m.cont.SetNote(&n)
	} else {
		m.cont.SetNote(nil)
	}
}

func (m Model) keySearch(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) {
	switch msg.String() {
	case "esc":
		m.searchInput.SetValue("")
		m.searchInput.Blur()
		m.focus = FocusList
		m.applyFilter("")
		m.refreshPreview()
		return m, nil
	case "enter":
		m.searchInput.Blur()
		m.focus = FocusList
		return m, nil
func (m *Model) applyLayout() {
	if !m.ready {
		return
	}
	var cmd tea.Cmd
	m.searchInput, cmd = m.searchInput.Update(msg)
	m.applyFilter(m.searchInput.Value())
	m.refreshPreview()
	return m, cmd
	listW, contentW := splitWidths(m.width)
	bodyH := splitBodyHeight(m.height)

	listInnerW := max(listW-paneFrameWidth(), 1)
	listInnerH := max(bodyH-paneFrameHeight(), 1)
	m.list.SetSize(listInnerW, listInnerH)

	contentInnerW := max(contentW-paneFrameWidth(), 20)
	contentInnerH := max(bodyH-paneFrameHeight(), 3)
	m.cont.SetSize(contentInnerW, max(contentInnerH-1, 1))
	m.form.SetSize(contentInnerW, contentInnerH)
}

func (m *Model) setStatus(text string, ok bool) tea.Cmd {
	m.status = text
	m.statusOK = ok
	m.statusUntil = time.Now().Add(2 * time.Second)
	return tea.Tick(2*time.Second, func(time.Time) tea.Msg { return clearStatusMsg{} })
}

apps/jotts-go/tui/view.go +60 −117


import (
	"fmt"
	"strings"

	tea "charm.land/bubbletea/v2"
	"charm.land/lipgloss/v2"

			Bold(true).
			Foreground(lipgloss.Color("3")).
			Padding(0, 1)
	itemStyle    = lipgloss.NewStyle().Padding(0, 1)
	itemSelected = lipgloss.NewStyle().
			Padding(0, 1).
			Bold(true).
			Foreground(lipgloss.Color("3"))
	statusOK = lipgloss.NewStyle().
	statusOKStyle = lipgloss.NewStyle().
			Foreground(lipgloss.Color("2")).
			Bold(true)
	statusErr = lipgloss.NewStyle().
	statusErrStyle = lipgloss.NewStyle().
			Foreground(lipgloss.Color("1")).
			Bold(true)
	hintStyle = lipgloss.NewStyle().
			Foreground(lipgloss.Color("8"))
	modalStyle = lipgloss.NewStyle().
			Border(lipgloss.RoundedBorder()).
			BorderForeground(lipgloss.Color("3")).

	listW, contentW := splitWidths(m.width)
	bodyH := splitBodyHeight(m.height)

	left := m.renderList(listW, bodyH)
	right := m.renderRight(contentW, bodyH)
	left := m.renderListPane(listW, bodyH)
	right := m.renderRightPane(contentW, bodyH)

	base := lipgloss.JoinHorizontal(lipgloss.Top, left, right)


			modalStyle.Render(m.help.FullHelpView(m.keys.FullHelp())), 1))
	}
	if m.confirmDelete {
		n := m.currentNote()
		title := ""
		if n != nil {
		if n, ok := m.list.Selected(); ok {
			title = n.Title
		}
		overlays = append(overlays, centerLayer(m.width, m.height,
			modalStyle.Render(fmt.Sprintf("Delete %q?\n\ny / n", title)), 2))
	}
	if m.status != "" {
		st := statusOK
		st := statusOKStyle
		if !m.statusOK {
			st = statusErr
			st = statusErrStyle
		}
		overlays = append(overlays, bottomCenterLayer(m.width, m.height,
			modalStyle.Render(st.Render(m.status)), 3))

	return tea.View{Content: content, AltScreen: true}
}

func centerLayer(w, h int, content string, z int) *lipgloss.Layer {
	cw, ch := lipgloss.Width(content), lipgloss.Height(content)
	x := (w - cw) / 2
	y := (h - ch) / 2
	if x < 0 {
		x = 0
	}
	if y < 0 {
		y = 0
	}
	return lipgloss.NewLayer(content).X(x).Y(y).Z(z)
}

func bottomCenterLayer(w, h int, content string, z int) *lipgloss.Layer {
	cw, ch := lipgloss.Width(content), lipgloss.Height(content)
	x := (w - cw) / 2
	y := h - ch - 1
	if x < 0 {
		x = 0
	}
	if y < 0 {
		y = 0
	}
	return lipgloss.NewLayer(content).X(x).Y(y).Z(z)
}

func (m Model) renderList(w, h int) string {
func (m Model) renderListPane(w, h int) string {
	style := borderStyle
	if m.focus == FocusList || m.focus == FocusSearch {
	if m.state == stateList {
		style = borderActive
	}

	notes := m.visibleNotes()
	rows := make([]string, 0, len(notes)+2)
	rows = append(rows, titleStyle.Render("notes"))
	if len(notes) == 0 {
		rows = append(rows, hintStyle.Render("  (empty — press c)"))
	}
	for i, n := range notes {
		line := truncate(n.Title, maxInt(w-paneFrameWidth()-4, 1))
		if i == m.cursor {
			rows = append(rows, itemSelected.Render("▶ "+line))
		} else {
			rows = append(rows, itemStyle.Render("  "+line))
		}
	}

	if m.focus == FocusSearch || m.searchInput.Value() != "" {
		rows = append(rows, "", hintStyle.Render(m.searchInput.View()))
	}

	content := strings.Join(rows, "\n")
	return style.
		Width(maxInt(w-paneFrameWidth(), 1)).
		Height(maxInt(h-paneFrameHeight(), 1)).
		Render(content)
		Width(max(w-paneFrameWidth(), 1)).
		Height(max(h-paneFrameHeight(), 1)).
		Render(m.list.View())
}

func (m Model) renderRight(w, h int) string {
	switch m.focus {
	case FocusCreateTitle, FocusCreateContent, FocusEditTitle, FocusEditContent:
func (m Model) renderRightPane(w, h int) string {
	if m.state == stateForm {
		return m.renderForm(w, h)
	}
	return m.renderContent(w, h)


func (m Model) renderContent(w, h int) string {
	style := borderStyle
	if m.focus == FocusContent {
	if m.state == stateContent {
		style = borderActive
	}
	header := "preview"
	n := m.currentNote()
	if n != nil {
		header = n.Title
	if t := m.cont.Title(); t != "" {
		header = t
	}
	body := m.contentVP.View()
	inner := lipgloss.JoinVertical(lipgloss.Left, titleStyle.Render(header), body)
	inner := lipgloss.JoinVertical(lipgloss.Left, titleStyle.Render(header), m.cont.View())
	return style.
		Width(maxInt(w-paneFrameWidth(), 1)).
		Height(maxInt(h-paneFrameHeight(), 1)).
		Width(max(w-paneFrameWidth(), 1)).
		Height(max(h-paneFrameHeight(), 1)).
		Render(inner)
}

func (m Model) renderForm(w, h int) string {
	header := "new note"
	if m.editShortID != "" {
	if !m.form.IsCreate() {
		header = "edit"
	}
	title := m.titleInput.View()
	if m.focus == FocusCreateTitle || m.focus == FocusEditTitle {
		title = borderActive.Render(title)

	titleField := m.form.title.View()
	if m.form.ActiveField() == formFieldTitle {
		titleField = borderActive.Render(titleField)
	} else {
		title = borderStyle.Render(title)
		titleField = borderStyle.Render(titleField)
	}

	body := m.contentArea.View()
	if m.focus == FocusCreateContent || m.focus == FocusEditContent {
	body := m.form.content.View()
	if m.form.ActiveField() == formFieldContent {
		body = borderActive.Render(body)
	} else {
		body = borderStyle.Render(body)
	}

	inner := lipgloss.JoinVertical(lipgloss.Left, titleStyle.Render(header), title, body)
	return borderStyle.
		Width(maxInt(w-paneFrameWidth(), 1)).
		Height(maxInt(h-paneFrameHeight(), 1)).
	inner := lipgloss.JoinVertical(lipgloss.Left, titleStyle.Render(header), titleField, body)
	return borderActive.
		Width(max(w-paneFrameWidth(), 1)).
		Height(max(h-paneFrameHeight(), 1)).
		Render(inner)
}

func centerLayer(w, h int, content string, z int) *lipgloss.Layer {
	cw, ch := lipgloss.Width(content), lipgloss.Height(content)
	x := (w - cw) / 2
	y := (h - ch) / 2
	if x < 0 {
		x = 0
	}
	if y < 0 {
		y = 0
	}
	return lipgloss.NewLayer(content).X(x).Y(y).Z(z)
}

func bottomCenterLayer(w, h int, content string, z int) *lipgloss.Layer {
	cw, ch := lipgloss.Width(content), lipgloss.Height(content)
	x := (w - cw) / 2
	y := h - ch - 1
	if x < 0 {
		x = 0
	}
	if y < 0 {
		y = 0
	}
	return lipgloss.NewLayer(content).X(x).Y(y).Z(z)
}

func splitWidths(total int) (int, int) {
	if total < 44 {
		return total / 2, total - (total / 2)

	return total
}

func paneFrameWidth() int {
	return borderStyle.GetHorizontalFrameSize()
}

func paneFrameHeight() int {
	return borderStyle.GetVerticalFrameSize()
}

func maxInt(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func truncate(s string, n int) string {
	if n < 1 {
		return ""
	}
	if len(s) <= n {
		return s
	}
	if n <= 1 {
		return "…"
	}
	return s[:n-1] + "…"
}
func paneFrameWidth() int  { return borderStyle.GetHorizontalFrameSize() }
func paneFrameHeight() int { return borderStyle.GetVerticalFrameSize() }

apps/sipp-go/go.mod +1 −0

	github.com/ncruces/go-strftime v0.1.9 // indirect
	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
	github.com/rivo/uniseg v0.4.7 // indirect
	github.com/sahilm/fuzzy v0.1.1 // indirect
	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
	golang.org/x/crypto v0.39.0 // indirect
	golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0 // indirect

apps/sipp-go/go.sum +4 −0

github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
github.com/lucasb-eyer/go-colorful v1.4.0 h1:UtrWVfLdarDgc44HcS7pYloGHJUjHV/4FwW4TvVgFr4=
github.com/lucasb-eyer/go-colorful v1.4.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=

github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
github.com/sahilm/fuzzy v0.1.1 h1:ceu5RHF8DGgoi+/dR5PsECjCDH1BE3Fnmpo7aVXOdRA=
github.com/sahilm/fuzzy v0.1.1/go.mod h1:VFvziUEIMCrT6A6tw2RFIXPXXmzXbOsSHF0DOI8ZK9Y=
github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=
github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=
golang.org/x/crypto v0.39.0 h1:SHs+kF4LP+f+p14esP5jAoDpHU8Gu/v9lFRK6IT5imM=

apps/sipp-go/tui/commands.go (added) +62 −0

1	+	package tui
2	+
3	+	import (
4	+	"strings"
5	+
6	+	tea "charm.land/bubbletea/v2"
7	+	"github.com/atotto/clipboard"
8	+	)
9	+
10	+	func loadSnippetsCmd(b Backend) tea.Cmd {
11	+	return func() tea.Msg {
12	+	list, err := b.List()
13	+	return snippetsLoadedMsg{snippets: list, err: err}
14	+	}
15	+	}
16	+
17	+	func saveSnippetCmd(b Backend, shortID, name, content string) tea.Cmd {
18	+	return func() tea.Msg {
19	+	var (
20	+	s *Snippet
21	+	err error
22	+	)
23	+	if shortID == "" {
24	+	s, err = b.Create(name, content)
25	+	} else {
26	+	s, err = b.Update(shortID, name, content)
27	+	}
28	+	return snippetSavedMsg{snippet: s, err: err}
29	+	}
30	+	}
31	+
32	+	func deleteSnippetCmd(b Backend, shortID string) tea.Cmd {
33	+	return func() tea.Msg {
34	+	_, err := b.Delete(shortID)
35	+	return snippetDeletedMsg{shortID: shortID, err: err}
36	+	}
37	+	}
38	+
39	+	func copyToClipboardCmd(text, okStatus string) tea.Cmd {
40	+	return func() tea.Msg {
41	+	if err := clipboard.WriteAll(text); err != nil {
42	+	return statusMsg{text: "clipboard: " + err.Error(), ok: false}
43	+	}
44	+	return statusMsg{text: okStatus, ok: true}
45	+	}
46	+	}
47	+
48	+	func openURLCmd(url string) tea.Cmd {
49	+	return func() tea.Msg {
50	+	if err := openURL(url); err != nil {
51	+	return statusMsg{text: "open: " + err.Error(), ok: false}
52	+	}
53	+	return statusMsg{text: "opened " + url, ok: true}
54	+	}
55	+	}
56	+
57	+	func shareLinkURL(remoteBase, shortID string) string {
58	+	if remoteBase == "" {
59	+	return ""
60	+	}
61	+	return strings.TrimRight(remoteBase, "/") + "/s/" + shortID
62	+	}

apps/sipp-go/tui/content_model.go (added) +95 −0

1	+	package tui
2	+
3	+	import (
4	+	"charm.land/bubbles/v2/viewport"
5	+	tea "charm.land/bubbletea/v2"
6	+	"charm.land/lipgloss/v2"
7	+	)
8	+
9	+	type contentModel struct {
10	+	vp viewport.Model
11	+	highlighter *highlighter
12	+	wrap bool
13	+
14	+	shortID string
15	+	name string
16	+	body string
17	+	}
18	+
19	+	func newContentModel() contentModel {
20	+	return contentModel{vp: viewport.New(), highlighter: newHighlighter(), wrap: true}
21	+	}
22	+
23	+	func (c contentModel) Update(msg tea.Msg) (contentModel, tea.Cmd) {
24	+	var cmd tea.Cmd
25	+	c.vp, cmd = c.vp.Update(msg)
26	+	return c, cmd
27	+	}
28	+
29	+	func (c *contentModel) SetSize(w, h int) {
30	+	c.vp.SetWidth(w)
31	+	c.vp.SetHeight(h)
32	+	c.refresh()
33	+	}
34	+
35	+	func (c contentModel) SetSnippet(s Snippet) {
36	+	if s == nil {
37	+	c.shortID, c.name, c.body = "", "", ""
38	+	c.vp.SetContent("")
39	+	c.vp.GotoTop()
40	+	return
41	+	}
42	+	c.shortID = s.ShortID
43	+	c.name = s.Name
44	+	c.body = s.Content
45	+	c.vp.GotoTop()
46	+	c.refresh()
47	+	}
48	+
49	+	func (c *contentModel) ToggleWrap() {
50	+	c.wrap = !c.wrap
51	+	c.vp.GotoTop()
52	+	c.refresh()
53	+	}
54	+
55	+	func (c *contentModel) Wrap() bool { return c.wrap }
56	+
57	+	func (c *contentModel) Invalidate(shortID string) {
58	+	if c.highlighter != nil {
59	+	c.highlighter.invalidate(shortID)
60	+	}
61	+	}
62	+
63	+	func (c *contentModel) refresh() {
64	+	if c.body == "" {
65	+	c.vp.SetContent("")
66	+	return
67	+	}
68	+	body := c.body
69	+	if c.highlighter != nil {
70	+	body = c.highlighter.render(c.shortID, c.name, c.body)
71	+	}
72	+	if c.wrap && c.vp.Width() > 0 {
73	+	body = lipgloss.NewStyle().Width(c.vp.Width()).Render(body)
74	+	}
75	+	c.vp.SetContent(body)
76	+	}
77	+
78	+	func (c contentModel) Header() string {
79	+	if c.name != "" {
80	+	return c.name
81	+	}
82	+	return c.shortID
83	+	}
84	+
85	+	func (c contentModel) View() string { return c.vp.View() }
86	+
87	+	func (c contentModel) ScrollUp(n int) contentModel {
88	+	c.vp.ScrollUp(n)
89	+	return c
90	+	}
91	+
92	+	func (c contentModel) ScrollDown(n int) contentModel {
93	+	c.vp.ScrollDown(n)
94	+	return c
95	+	}

apps/sipp-go/tui/form_model.go (added) +140 −0

1	+	package tui
2	+
3	+	import (
4	+	"strings"
5	+
6	+	"charm.land/bubbles/v2/key"
7	+	"charm.land/bubbles/v2/textarea"
8	+	"charm.land/bubbles/v2/textinput"
9	+	tea "charm.land/bubbletea/v2"
10	+	)
11	+
12	+	type formField uint8
13	+
14	+	const (
15	+	formFieldName formField = iota
16	+	formFieldContent
17	+	)
18	+
19	+	type formModel struct {
20	+	name textinput.Model
21	+	content textarea.Model
22	+
23	+	field formField
24	+	shortID string
25	+	isCreate bool
26	+
27	+	keys formKeys
28	+	}
29	+
30	+	type formKeys struct {
31	+	Save key.Binding
32	+	Cancel key.Binding
33	+	SwitchField key.Binding
34	+	}
35	+
36	+	func defaultFormKeys() formKeys {
37	+	return formKeys{
38	+	Save: key.NewBinding(key.WithKeys("ctrl+s"), key.WithHelp("⌃s", "save")),
39	+	Cancel: key.NewBinding(key.WithKeys("esc"), key.WithHelp("esc", "cancel")),
40	+	SwitchField: key.NewBinding(key.WithKeys("tab"), key.WithHelp("⇥", "switch field")),
41	+	}
42	+	}
43	+
44	+	func newFormModel() formModel {
45	+	ti := textinput.New()
46	+	ti.Placeholder = "name.ext"
47	+	ti.Prompt = ""
48	+	ti.CharLimit = 200
49	+
50	+	ta := textarea.New()
51	+	ta.Placeholder = "Paste code..."
52	+	ta.ShowLineNumbers = true
53	+	ta.Prompt = ""
54	+
55	+	return formModel{name: ti, content: ta, keys: defaultFormKeys()}
56	+	}
57	+
58	+	func (f *formModel) StartCreate() {
59	+	f.shortID = ""
60	+	f.isCreate = true
61	+	f.name.SetValue("")
62	+	f.content.SetValue("")
63	+	f.field = formFieldName
64	+	f.applyFocus()
65	+	}
66	+
67	+	func (f *formModel) StartEdit(s Snippet) {
68	+	f.shortID = s.ShortID
69	+	f.isCreate = false
70	+	f.name.SetValue(s.Name)
71	+	f.content.SetValue(s.Content)
72	+	f.field = formFieldName
73	+	f.applyFocus()
74	+	}
75	+
76	+	func (f *formModel) SetContent(s string) { f.content.SetValue(s) }
77	+
78	+	func (f *formModel) Blur() {
79	+	f.name.Blur()
80	+	f.content.Blur()
81	+	}
82	+
83	+	func (f *formModel) applyFocus() {
84	+	switch f.field {
85	+	case formFieldName:
86	+	f.name.Focus()
87	+	f.content.Blur()
88	+	case formFieldContent:
89	+	f.content.Focus()
90	+	f.name.Blur()
91	+	}
92	+	}
93	+
94	+	func (f *formModel) SetSize(w, h int) {
95	+	f.name.SetWidth(max(w-4, 1))
96	+	f.content.SetWidth(max(w-2, 1))
97	+	f.content.SetHeight(max(h-5, 1))
98	+	}
99	+
100	+	func (f formModel) Update(msg tea.Msg) (formModel, tea.Cmd) {
101	+	if km, ok := msg.(tea.KeyPressMsg); ok {
102	+	switch {
103	+	case key.Matches(km, f.keys.Cancel):
104	+	f.Blur()
105	+	return f, func() tea.Msg { return cancelFormMsg{} }
106	+	case key.Matches(km, f.keys.Save):
107	+	name := strings.TrimSpace(f.name.Value())
108	+	if name == "" {
109	+	return f, func() tea.Msg { return statusMsg{text: "name required", ok: false} }
110	+	}
111	+	content := f.content.Value()
112	+	if strings.TrimSpace(content) == "" {
113	+	return f, func() tea.Msg { return statusMsg{text: "content required", ok: false} }
114	+	}
115	+	return f, func() tea.Msg {
116	+	return submitFormMsg{shortID: f.shortID, name: name, content: content}
117	+	}
118	+	case key.Matches(km, f.keys.SwitchField):
119	+	if f.field == formFieldName {
120	+	f.field = formFieldContent
121	+	} else {
122	+	f.field = formFieldName
123	+	}
124	+	f.applyFocus()
125	+	return f, nil
126	+	}
127	+	}
128	+
129	+	var cmd tea.Cmd
130	+	switch f.field {
131	+	case formFieldName:
132	+	f.name, cmd = f.name.Update(msg)
133	+	case formFieldContent:
134	+	f.content, cmd = f.content.Update(msg)
135	+	}
136	+	return f, cmd
137	+	}
138	+
139	+	func (f formModel) ActiveField() formField { return f.field }
140	+	func (f formModel) IsCreate() bool { return f.isCreate }

apps/sipp-go/tui/highlight.go +20 −2

	"github.com/alecthomas/chroma/v2/styles"
)

const highlightCacheMax = 64

type highlighter struct {
	cache map[string]string
	order []string
}

func newHighlighter() *highlighter {

	}
	out := highlightCode(name, content)
	h.cache[shortID] = out
	h.order = append(h.order, shortID)
	if len(h.order) > highlightCacheMax {
		drop := h.order[0]
		h.order = h.order[1:]
		delete(h.cache, drop)
	}
	return out
}

func (h *highlighter) invalidate(shortID string) {
	if _, ok := h.cache[shortID]; !ok {
		return
	}
	delete(h.cache, shortID)
	for i, k := range h.order {
		if k == shortID {
			h.order = append(h.order[:i], h.order[i+1:]...)
			break
		}
	}
}

func highlightCode(name, content string) string {

	if lexer == nil {
		lexer = lexers.Fallback
	}
	style := styles.Get("monokai")
	style := styles.Get("vim")
	if style == nil {
		style = styles.Fallback
	}
	formatter := formatters.Get("terminal256")
	formatter := formatters.Get("terminal16")
	if formatter == nil {
		formatter = formatters.Fallback
	}

apps/sipp-go/tui/keys.go +10 −19

import "charm.land/bubbles/v2/key"

type keyMap struct {
	Up          key.Binding
	Down        key.Binding
	Open        key.Binding
	Back        key.Binding
	Quit        key.Binding

	Copy        key.Binding
	CopyLink    key.Binding
	OpenBrowser key.Binding
	Search      key.Binding
	Refresh     key.Binding
	WrapToggle  key.Binding
	Help        key.Binding
	Save        key.Binding
	SwitchField key.Binding
	Cancel      key.Binding
	ScrollUp    key.Binding
	ScrollDown  key.Binding
}

func defaultKeys() keyMap {
	return keyMap{
		Up:          key.NewBinding(key.WithKeys("up", "k"), key.WithHelp("↑/k", "up")),
		Down:        key.NewBinding(key.WithKeys("down", "j"), key.WithHelp("↓/j", "down")),
		Open:        key.NewBinding(key.WithKeys("enter", "l"), key.WithHelp("⏎/l", "open")),
		Back:        key.NewBinding(key.WithKeys("h", "esc"), key.WithHelp("h/esc", "back")),
		Quit:        key.NewBinding(key.WithKeys("q"), key.WithHelp("q", "quit")),
		Quit:        key.NewBinding(key.WithKeys("q", "ctrl+c"), key.WithHelp("q", "quit")),
		Create:      key.NewBinding(key.WithKeys("c"), key.WithHelp("c", "create")),
		Edit:        key.NewBinding(key.WithKeys("e"), key.WithHelp("e", "edit")),
		ExtEdit:     key.NewBinding(key.WithKeys("E"), key.WithHelp("E", "$EDITOR")),

		Copy:        key.NewBinding(key.WithKeys("y"), key.WithHelp("y", "copy text")),
		CopyLink:    key.NewBinding(key.WithKeys("Y"), key.WithHelp("Y", "copy link")),
		OpenBrowser: key.NewBinding(key.WithKeys("o"), key.WithHelp("o", "browser")),
		Search:      key.NewBinding(key.WithKeys("/"), key.WithHelp("/", "search")),
		Refresh:     key.NewBinding(key.WithKeys("r"), key.WithHelp("r", "refresh")),
		WrapToggle:  key.NewBinding(key.WithKeys("ctrl+w"), key.WithHelp("⌃w", "wrap")),
		Help:        key.NewBinding(key.WithKeys("?"), key.WithHelp("?", "help")),
		Save:        key.NewBinding(key.WithKeys("ctrl+s"), key.WithHelp("⌃s", "save")),
		SwitchField: key.NewBinding(key.WithKeys("tab"), key.WithHelp("⇥", "switch field")),
		Cancel:      key.NewBinding(key.WithKeys("esc"), key.WithHelp("esc", "cancel")),
		ScrollUp:    key.NewBinding(key.WithKeys("up", "k"), key.WithHelp("↑/k", "up")),
		ScrollDown:  key.NewBinding(key.WithKeys("down", "j"), key.WithHelp("↓/j", "down")),
	}
}

func (k keyMap) ShortHelp() []key.Binding {
	return []key.Binding{k.Open, k.Create, k.Edit, k.Delete, k.Search, k.Help, k.Quit}
	return []key.Binding{k.Open, k.Create, k.Edit, k.Delete, k.Help, k.Quit}
}

func (k keyMap) FullHelp() [][]key.Binding {
	return [][]key.Binding{
		{k.Up, k.Down, k.Open, k.Back},
		{k.Create, k.Edit, k.ExtEdit, k.Delete},
		{k.Copy, k.CopyLink, k.OpenBrowser, k.Search},
		{k.Refresh, k.WrapToggle, k.Help, k.Save, k.SwitchField},
		{k.Cancel, k.Quit},
		{k.Open, k.Back, k.Create, k.Edit},
		{k.ExtEdit, k.Delete, k.Copy, k.CopyLink},
		{k.OpenBrowser, k.Refresh, k.WrapToggle, k.Help},
		{k.ScrollUp, k.ScrollDown, k.Quit},
	}
}

apps/sipp-go/tui/list_model.go (added) +110 −0

1	+	package tui
2	+
3	+	import (
4	+	"charm.land/bubbles/v2/list"
5	+	tea "charm.land/bubbletea/v2"
6	+	"charm.land/lipgloss/v2"
7	+	)
8	+
9	+	var listIDStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("8"))
10	+
11	+	func ansiListDelegate() list.DefaultDelegate {
12	+	d := list.NewDefaultDelegate()
13	+	d.ShowDescription = false
14	+	d.SetSpacing(0)
15	+	d.Styles.NormalTitle = lipgloss.NewStyle().Foreground(lipgloss.Color("7")).Padding(0, 0, 0, 2)
16	+	d.Styles.SelectedTitle = lipgloss.NewStyle().
17	+	Foreground(lipgloss.Color("3")).
18	+	Bold(true).
19	+	Border(lipgloss.NormalBorder(), false, false, false, true).
20	+	BorderForeground(lipgloss.Color("3")).
21	+	Padding(0, 0, 0, 1)
22	+	d.Styles.DimmedTitle = lipgloss.NewStyle().Foreground(lipgloss.Color("8")).Padding(0, 0, 0, 2)
23	+	d.Styles.FilterMatch = lipgloss.NewStyle().Underline(true).Foreground(lipgloss.Color("3"))
24	+	return d
25	+	}
26	+
27	+	func ansiListStyles() list.Styles {
28	+	s := list.DefaultStyles(true)
29	+	s.Title = lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("3")).Padding(0, 1)
30	+	s.TitleBar = lipgloss.NewStyle().Padding(0, 0, 1, 0)
31	+	s.NoItems = lipgloss.NewStyle().Foreground(lipgloss.Color("8")).Padding(0, 0, 0, 2)
32	+	s.DefaultFilterCharacterMatch = lipgloss.NewStyle().Underline(true).Foreground(lipgloss.Color("3"))
33	+	return s
34	+	}
35	+
36	+	type snippetItem struct {
37	+	snippet Snippet
38	+	}
39	+
40	+	func (s snippetItem) Title() string {
41	+	label := s.snippet.Name
42	+	if label == "" {
43	+	label = s.snippet.ShortID
44	+	return label
45	+	}
46	+	return label + listIDStyle.Render(" "+s.snippet.ShortID)
47	+	}
48	+	func (s snippetItem) Description() string { return "" }
49	+	func (s snippetItem) FilterValue() string {
50	+	if s.snippet.Name != "" {
51	+	return s.snippet.Name + " " + s.snippet.ShortID
52	+	}
53	+	return s.snippet.ShortID
54	+	}
55	+
56	+	type listModel struct {
57	+	inner list.Model
58	+	}
59	+
60	+	func newListModel(snippets []Snippet) listModel {
61	+	items := make([]list.Item, 0, len(snippets))
62	+	for _, s := range snippets {
63	+	items = append(items, snippetItem{snippet: s})
64	+	}
65	+
66	+	l := list.New(items, ansiListDelegate(), 0, 0)
67	+	l.Title = "snippets"
68	+	l.Styles = ansiListStyles()
69	+	l.SetShowStatusBar(false)
70	+	l.SetShowPagination(false)
71	+	l.SetShowHelp(false)
72	+	l.SetFilteringEnabled(true)
73	+	l.DisableQuitKeybindings()
74	+
75	+	return listModel{inner: l}
76	+	}
77	+
78	+	func (l listModel) Update(msg tea.Msg) (listModel, tea.Cmd) {
79	+	var cmd tea.Cmd
80	+	l.inner, cmd = l.inner.Update(msg)
81	+	return l, cmd
82	+	}
83	+
84	+	func (l listModel) View() string { return l.inner.View() }
85	+
86	+	func (l *listModel) SetSize(w, h int) { l.inner.SetSize(w, h) }
87	+
88	+	func (l *listModel) SetSnippets(snippets []Snippet) tea.Cmd {
89	+	items := make([]list.Item, 0, len(snippets))
90	+	for _, s := range snippets {
91	+	items = append(items, snippetItem{snippet: s})
92	+	}
93	+	return l.inner.SetItems(items)
94	+	}
95	+
96	+	func (l listModel) Selected() (Snippet, bool) {
97	+	it := l.inner.SelectedItem()
98	+	if it == nil {
99	+	return Snippet{}, false
100	+	}
101	+	s, ok := it.(snippetItem)
102	+	if !ok {
103	+	return Snippet{}, false
104	+	}
105	+	return s.snippet, true
106	+	}
107	+
108	+	func (l listModel) IsFiltering() bool {
109	+	return l.inner.SettingFilter()
110	+	}

apps/sipp-go/tui/messages.go +8 −0

27	27		}
28	28
29	29		type clearStatusMsg struct{}
	30	+
	31	+	type submitFormMsg struct {
	32	+	shortID string
	33	+	name string
	34	+	content string
	35	+	}
	36	+
	37	+	type cancelFormMsg struct{}

apps/sipp-go/tui/model.go +23 −111

package tui

import (
	"strings"
	"time"

	"charm.land/bubbles/v2/help"
	"charm.land/bubbles/v2/textarea"
	"charm.land/bubbles/v2/textinput"
	"charm.land/bubbles/v2/viewport"
	tea "charm.land/bubbletea/v2"
)

type Focus int
type sessionState uint8

const (
	FocusList Focus = iota
	FocusContent
	FocusCreateName
	FocusCreateContent
	FocusEditName
	FocusEditContent
	FocusSearch
	stateList sessionState = iota
	stateContent
	stateForm
)

type Model struct {
	backend  Backend
	isRemote bool

	snippets []Snippet
	filtered []int
	cursor   int
	state sessionState
	list  listModel
	cont  contentModel
	form  formModel

	width, height int
	ready         bool
	loading       bool

	focus         Focus
	showHelp      bool
	confirmDelete bool
	wrapContent   bool

	nameInput   textinput.Model
	contentArea textarea.Model
	searchInput textinput.Model
	contentVP   viewport.Model
	help        help.Model
	keys        keyMap

	highlighter *highlighter

	editShortID string

	status      string
	statusOK    bool
	statusUntil time.Time

	width, height int
	ready         bool
	loading       bool
	help help.Model
	keys keyMap
}

func newModel(backend Backend) Model {
	ti := textinput.New()
	ti.Placeholder = "name.ext"
	ti.Prompt = ""
	ti.CharLimit = 200

	ta := textarea.New()
	ta.Placeholder = "Paste code..."
	ta.ShowLineNumbers = true
	ta.Prompt = ""

	si := textinput.New()
	si.Placeholder = "search names"
	si.Prompt = "/ "

	vp := viewport.New()

	return Model{
		backend:     backend,
		isRemote:    backend.RemoteURL() != "",
		focus:       FocusList,
		nameInput:   ti,
		contentArea: ta,
		searchInput: si,
		contentVP:   vp,
		help:        help.New(),
		keys:        defaultKeys(),
		highlighter: newHighlighter(),
		backend:  backend,
		isRemote: backend.RemoteURL() != "",
		state:    stateList,
		list:     newListModel(nil),
		cont:     newContentModel(),
		form:     newFormModel(),
		help:     help.New(),
		keys:     defaultKeys(),
		loading:  true,
	}
}

func (m Model) Init() tea.Cmd {
	return tea.Batch(tea.RequestWindowSize, loadSnippetsCmd(m.backend))
}

func (m *Model) visible() []Snippet {
	if m.filtered == nil {
		return m.snippets
	}
	out := make([]Snippet, 0, len(m.filtered))
	for _, i := range m.filtered {
		out = append(out, m.snippets[i])
	}
	return out
}

func (m *Model) current() *Snippet {
	list := m.visible()
	if m.cursor < 0 || m.cursor >= len(list) {
		return nil
	}
	return &list[m.cursor]
}

func (m *Model) applyFilter(q string) {
	q = strings.TrimSpace(strings.ToLower(q))
	if q == "" {
		m.filtered = nil
		if m.cursor >= len(m.snippets) {
			m.cursor = 0
		}
		return
	}
	idx := []int{}
	for i, s := range m.snippets {
		if strings.Contains(strings.ToLower(s.Name), q) || strings.Contains(strings.ToLower(s.ShortID), q) {
			idx = append(idx, i)
		}
	}
	m.filtered = idx
	if m.cursor >= len(idx) {
		m.cursor = 0
	}
}

func (m *Model) setStatus(text string, ok bool) tea.Cmd {
	m.status = text
	m.statusOK = ok
	m.statusUntil = time.Now().Add(2 * time.Second)
	return tea.Tick(2*time.Second, func(time.Time) tea.Msg { return clearStatusMsg{} })
}

func (m *Model) shareURL(shortID string) string {
	if m.backend.RemoteURL() == "" {
		return ""
	}
	return strings.TrimRight(m.backend.RemoteURL(), "/") + "/s/" + shortID
}

apps/sipp-go/tui/update.go +145 −272


import (
	"strings"
	"time"

	"github.com/atotto/clipboard"
	"charm.land/bubbles/v2/key"
	tea "charm.land/bubbletea/v2"
	"charm.land/lipgloss/v2"
)

func loadSnippetsCmd(b Backend) tea.Cmd {
	return func() tea.Msg {
		list, err := b.List()
		return snippetsLoadedMsg{snippets: list, err: err}
	}
}

func saveSnippetCmd(b Backend, shortID, name, content string) tea.Cmd {
	return func() tea.Msg {
		var (
			s   *Snippet
			err error
		)
		if shortID == "" {
			s, err = b.Create(name, content)
		} else {
			s, err = b.Update(shortID, name, content)
		}
		return snippetSavedMsg{snippet: s, err: err}
	}
}

func deleteSnippetCmd(b Backend, shortID string) tea.Cmd {
	return func() tea.Msg {
		_, err := b.Delete(shortID)
		return snippetDeletedMsg{shortID: shortID, err: err}
	}
}

func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
	switch msg := msg.(type) {

	case tea.WindowSizeMsg:
		m.width, m.height = msg.Width, msg.Height
		m.ready = true
		m.resizePanes()
		m.applyLayout()
		return m, nil

	case snippetsLoadedMsg:

		if msg.err != nil {
			return m, m.setStatus("load: "+msg.err.Error(), false)
		}
		m.snippets = msg.snippets
		m.applyFilter(m.searchInput.Value())
		m.refreshPreview()
		return m, nil
		cmd := m.list.SetSnippets(msg.snippets)
		m.refreshContentFromSelection()
		return m, cmd

	case snippetSavedMsg:
		if msg.err != nil {
			return m, m.setStatus("save: "+msg.err.Error(), false)
		}
		if msg.snippet != nil && m.highlighter != nil {
			m.highlighter.invalidate(msg.snippet.ShortID)
		if msg.snippet != nil {
			m.cont.Invalidate(msg.snippet.ShortID)
		}
		m.focus = FocusList
		m.nameInput.Reset()
		m.contentArea.Reset()
		m.editShortID = ""
		m.state = stateList
		m.form.Blur()
		return m, tea.Batch(loadSnippetsCmd(m.backend), m.setStatus("saved", true))

	case snippetDeletedMsg:
		if msg.err != nil {
			return m, m.setStatus("delete: "+msg.err.Error(), false)
		}
		if m.highlighter != nil {
			m.highlighter.invalidate(msg.shortID)
		}
		m.cont.Invalidate(msg.shortID)
		m.state = stateList
		return m, tea.Batch(loadSnippetsCmd(m.backend), m.setStatus("deleted", true))

	case editorFinishedMsg:

			return m, m.setStatus("editor: "+msg.err.Error(), false)
		}
		if msg.shortID == "" {
			m.contentArea.SetValue(msg.content)
			m.form.SetContent(msg.content)
			return m, nil
		}
		var orig *Snippet
		for i := range m.snippets {
			if m.snippets[i].ShortID == msg.shortID {
				orig = &m.snippets[i]
		for _, it := range m.list.inner.Items() {
			si, ok := it.(snippetItem)
			if ok && si.snippet.ShortID == msg.shortID {
				s := si.snippet
				orig = &s
				break
			}
		}

		}
		return m, saveSnippetCmd(m.backend, msg.shortID, orig.Name, msg.content)

	case submitFormMsg:
		return m, saveSnippetCmd(m.backend, msg.shortID, msg.name, msg.content)

	case cancelFormMsg:
		m.state = stateList
		return m, nil

	case statusMsg:
		return m, m.setStatus(msg.text, msg.ok)

	case clearStatusMsg:
		if time.Now().Before(m.statusUntil) {
			return m, nil
		}
		m.status = ""
		return m, nil


	return m, nil
}

func (m *Model) resizePanes() {
	if !m.ready {
		return
	}
	listW := m.width * 30 / 100
	if listW < 24 {
		listW = 24
	}
	contentW := m.width - listW - 2
	if contentW < 20 {
		contentW = 20
	}
	bodyH := m.height - 2
	if bodyH < 5 {
		bodyH = 5
	}

	m.contentVP.SetWidth(contentW - 2)
	m.contentVP.SetHeight(bodyH - 2)

	m.nameInput.SetWidth(contentW - 4)
	if m.wrapContent {
		m.contentArea.SetWidth(contentW - 2)
	} else {
		m.contentArea.SetWidth(10000)
	}
	m.contentArea.SetHeight(bodyH - 5)

	m.searchInput.SetWidth(listW - 4)

	m.refreshPreview()
}

func (m *Model) refreshPreview() {
	s := m.current()
	if s == nil {
		m.contentVP.SetContent("")
		return
	}
	body := s.Content
	if m.highlighter != nil {
		body = m.highlighter.render(s.ShortID, s.Name, s.Content)
	}
	if m.wrapContent && m.contentVP.Width() > 0 {
		body = lipgloss.NewStyle().Width(m.contentVP.Width()).Render(body)
	}
	m.contentVP.SetContent(body)
}

func (m Model) handleKey(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) {
	if msg.String() == "ctrl+c" {
		return m, tea.Quit

	if m.confirmDelete {
		switch msg.String() {
		case "y", "Y":
			s := m.current()
			m.confirmDelete = false
			if s == nil {
			s, ok := m.list.Selected()
			if !ok {
				return m, nil
			}
			return m, deleteSnippetCmd(m.backend, s.ShortID)
		case "n", "N", "esc", "q":
			m.confirmDelete = false
			return m, nil
		}
		return m, nil
	}

		return m, nil
	}

	switch m.focus {
	case FocusList:
		return m.keyList(msg)
	case FocusContent:
		return m.keyContent(msg)
	case FocusCreateName, FocusCreateContent, FocusEditName, FocusEditContent:
		return m.keyForm(msg)
	case FocusSearch:
		return m.keySearch(msg)
	switch m.state {
	case stateList:
		return m.handleListKey(msg)
	case stateContent:
		return m.handleContentKey(msg)
	case stateForm:
		var cmd tea.Cmd
		m.form, cmd = m.form.Update(msg)
		return m, cmd
	}
	return m, nil
}

func (m Model) keyList(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) {
	list := m.visible()
func (m Model) handleListKey(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) {
	if m.list.IsFiltering() {
		var cmd tea.Cmd
		m.list, cmd = m.list.Update(msg)
		m.refreshContentFromSelection()
		return m, cmd
	}

	switch {
	case key.Matches(msg, m.keys.Quit):
		return m, tea.Quit
	case key.Matches(msg, m.keys.Down):
		if m.cursor < len(list)-1 {
			m.cursor++
			m.refreshPreview()
		}
	case key.Matches(msg, m.keys.Up):
		if m.cursor > 0 {
			m.cursor--
			m.refreshPreview()
		}
	case key.Matches(msg, m.keys.Open):
		if len(list) > 0 {
			m.focus = FocusContent
			m.contentVP.GotoTop()
		if s, ok := m.list.Selected(); ok {
			m.cont.SetSnippet(&s)
			m.state = stateContent
		}
		return m, nil
	case key.Matches(msg, m.keys.Create):
		m.focus = FocusCreateName
		m.editShortID = ""
		m.nameInput.SetValue("")
		m.contentArea.SetValue("")
		m.nameInput.Focus()
		m.contentArea.Blur()
		m.form.StartCreate()
		m.state = stateForm
		return m, nil
	case key.Matches(msg, m.keys.Edit):
		s := m.current()
		if s != nil {
			m.focus = FocusEditName
			m.editShortID = s.ShortID
			m.nameInput.SetValue(s.Name)
			m.contentArea.SetValue(s.Content)
			m.nameInput.Focus()
			m.contentArea.Blur()
		if s, ok := m.list.Selected(); ok {
			m.form.StartEdit(s)
			m.state = stateForm
		}
		return m, nil
	case key.Matches(msg, m.keys.ExtEdit):
		s := m.current()
		if s != nil {
		if s, ok := m.list.Selected(); ok {
			return m, openExternalEditor(s.ShortID, s.Name, s.Content)
		}
		return m, nil
	case key.Matches(msg, m.keys.Delete):
		if m.current() != nil {
		if _, ok := m.list.Selected(); ok {
			m.confirmDelete = true
		}
		return m, nil
	case key.Matches(msg, m.keys.Copy):
		s := m.current()
		if s != nil {
			if err := clipboard.WriteAll(s.Content); err != nil {
				return m, m.setStatus("clipboard: "+err.Error(), false)
			}
			return m, m.setStatus("copied text", true)
		if s, ok := m.list.Selected(); ok {
			return m, copyToClipboardCmd(s.Content, "copied text")
		}
		return m, nil
	case key.Matches(msg, m.keys.CopyLink):
		s := m.current()
		if s != nil && m.isRemote {
			link := m.shareURL(s.ShortID)
			if err := clipboard.WriteAll(link); err != nil {
				return m, m.setStatus("clipboard: "+err.Error(), false)
			}
			return m, m.setStatus("copied link", true)
		if !m.isRemote {
			return m, m.setStatus("local mode: no link", false)
		}
		return m, m.setStatus("local mode: no link", false)
		if s, ok := m.list.Selected(); ok {
			return m, copyToClipboardCmd(shareLinkURL(m.backend.RemoteURL(), s.ShortID), "copied link")
		}
		return m, nil
	case key.Matches(msg, m.keys.OpenBrowser):
		s := m.current()
		if s != nil && m.isRemote {
			link := m.shareURL(s.ShortID)
			if err := openURL(link); err != nil {
				return m, m.setStatus("open: "+err.Error(), false)
			}
			return m, m.setStatus("opened "+link, true)
		if !m.isRemote {
			return m, nil
		}
	case key.Matches(msg, m.keys.Search):
		m.focus = FocusSearch
		m.searchInput.Focus()
		if s, ok := m.list.Selected(); ok {
			return m, openURLCmd(shareLinkURL(m.backend.RemoteURL(), s.ShortID))
		}
		return m, nil
	case key.Matches(msg, m.keys.Refresh):
		m.loading = true
		return m, loadSnippetsCmd(m.backend)
	case key.Matches(msg, m.keys.Help):
		m.showHelp = true
		return m, nil
	}
	return m, nil

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

func (m Model) keyContent(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) {
func (m Model) handleContentKey(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) {
	switch {
	case key.Matches(msg, m.keys.WrapToggle):
		m.wrapContent = !m.wrapContent
		m.contentVP.GotoTop()
		m.refreshPreview()
		if m.wrapContent {
		m.cont.ToggleWrap()
		if m.cont.Wrap() {
			return m, m.setStatus("wrap on", true)
		}
		return m, m.setStatus("wrap off", true)
	case key.Matches(msg, m.keys.Quit), key.Matches(msg, m.keys.Back):
		m.focus = FocusList
		m.state = stateList
		return m, nil
	case key.Matches(msg, m.keys.Down):
		m.contentVP.ScrollDown(1)
	case key.Matches(msg, m.keys.Up):
		m.contentVP.ScrollUp(1)
	case key.Matches(msg, m.keys.ScrollDown):
		m.cont = m.cont.ScrollDown(1)
		return m, nil
	case key.Matches(msg, m.keys.ScrollUp):
		m.cont = m.cont.ScrollUp(1)
		return m, nil
	case key.Matches(msg, m.keys.Edit):
		s := m.current()
		if s != nil {
			m.focus = FocusEditName
			m.editShortID = s.ShortID
			m.nameInput.SetValue(s.Name)
			m.contentArea.SetValue(s.Content)
			m.nameInput.Focus()
		if s, ok := m.list.Selected(); ok {
			m.form.StartEdit(s)
			m.state = stateForm
		}
		return m, nil
	case key.Matches(msg, m.keys.ExtEdit):
		s := m.current()
		if s != nil {
		if s, ok := m.list.Selected(); ok {
			return m, openExternalEditor(s.ShortID, s.Name, s.Content)
		}
		return m, nil
	case key.Matches(msg, m.keys.Copy):
		s := m.current()
		if s != nil {
			clipboard.WriteAll(s.Content)
			return m, m.setStatus("copied text", true)
		if s, ok := m.list.Selected(); ok {
			return m, copyToClipboardCmd(s.Content, "copied text")
		}
		return m, nil
	case key.Matches(msg, m.keys.CopyLink):
		s := m.current()
		if s != nil && m.isRemote {
			clipboard.WriteAll(m.shareURL(s.ShortID))
			return m, m.setStatus("copied link", true)
		}
	case key.Matches(msg, m.keys.OpenBrowser):
		s := m.current()
		if s != nil && m.isRemote {
			openURL(m.shareURL(s.ShortID))
		if !m.isRemote {
			return m, m.setStatus("local mode: no link", false)
		}
	case key.Matches(msg, m.keys.Help):
		m.showHelp = true
	}
	var cmd tea.Cmd
	m.contentVP, cmd = m.contentVP.Update(msg)
	return m, cmd
}

func (m Model) keyForm(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) {
	switch {
	case key.Matches(msg, m.keys.WrapToggle):
		m.wrapContent = !m.wrapContent
		if m.wrapContent {
			m.contentArea.SetWidth(m.contentVP.Width())
			return m, m.setStatus("wrap on", true)
		if s, ok := m.list.Selected(); ok {
			return m, copyToClipboardCmd(shareLinkURL(m.backend.RemoteURL(), s.ShortID), "copied link")
		}
		m.contentArea.SetWidth(10000)
		return m, m.setStatus("wrap off", true)
	case key.Matches(msg, m.keys.Cancel):
		m.focus = FocusList
		m.nameInput.Blur()
		m.contentArea.Blur()
		return m, nil
	case key.Matches(msg, m.keys.Save):
		name := strings.TrimSpace(m.nameInput.Value())
		if name == "" {
			return m, m.setStatus("name required", false)
	case key.Matches(msg, m.keys.OpenBrowser):
		if !m.isRemote {
			return m, nil
		}
		content := m.contentArea.Value()
		if strings.TrimSpace(content) == "" {
			return m, m.setStatus("content required", false)
		}
		return m, saveSnippetCmd(m.backend, m.editShortID, name, content)
	case key.Matches(msg, m.keys.SwitchField):
		switch m.focus {
		case FocusCreateName:
			m.focus = FocusCreateContent
		case FocusCreateContent:
			m.focus = FocusCreateName
		case FocusEditName:
			m.focus = FocusEditContent
		case FocusEditContent:
			m.focus = FocusEditName
		if s, ok := m.list.Selected(); ok {
			return m, openURLCmd(shareLinkURL(m.backend.RemoteURL(), s.ShortID))
		}
		m.applyFormFocus()
		return m, nil
	case key.Matches(msg, m.keys.Help):
		m.showHelp = true
		return m, nil
	}

	var cmd tea.Cmd
	switch m.focus {
	case FocusCreateName, FocusEditName:
		m.nameInput, cmd = m.nameInput.Update(msg)
	case FocusCreateContent, FocusEditContent:
		m.contentArea, cmd = m.contentArea.Update(msg)
	}
	m.cont, cmd = m.cont.Update(msg)
	return m, cmd
}

func (m *Model) applyFormFocus() {
	switch m.focus {
	case FocusCreateName, FocusEditName:
		m.nameInput.Focus()
		m.contentArea.Blur()
	case FocusCreateContent, FocusEditContent:
		m.contentArea.Focus()
		m.nameInput.Blur()
func (m *Model) refreshContentFromSelection() {
	if s, ok := m.list.Selected(); ok {
		m.cont.SetSnippet(&s)
	} else {
		m.cont.SetSnippet(nil)
	}
}

func (m Model) keySearch(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) {
	switch msg.String() {
	case "esc":
		m.searchInput.SetValue("")
		m.searchInput.Blur()
		m.focus = FocusList
		m.applyFilter("")
		m.refreshPreview()
		return m, nil
	case "enter":
		m.searchInput.Blur()
		m.focus = FocusList
		return m, nil
func (m *Model) applyLayout() {
	if !m.ready {
		return
	}
	var cmd tea.Cmd
	m.searchInput, cmd = m.searchInput.Update(msg)
	m.applyFilter(m.searchInput.Value())
	m.refreshPreview()
	return m, cmd
	listW := m.width * 30 / 100
	if listW < 24 {
		listW = 24
	}
	contentW := m.width - listW - 2
	if contentW < 20 {
		contentW = 20
	}
	bodyH := m.height - 2
	if bodyH < 5 {
		bodyH = 5
	}

	m.list.SetSize(max(listW-paneFrameWidth(), 1), max(bodyH-paneFrameHeight(), 1))
	m.cont.SetSize(max(contentW-paneFrameWidth(), 1), max(bodyH-paneFrameHeight()-1, 1))
	m.form.SetSize(max(contentW-paneFrameWidth(), 1), max(bodyH-paneFrameHeight(), 1))
}

func (m *Model) setStatus(text string, ok bool) tea.Cmd {
	m.status = text
	m.statusOK = ok
	m.statusUntil = time.Now().Add(2 * time.Second)
	return tea.Tick(2*time.Second, func(time.Time) tea.Msg { return clearStatusMsg{} })
}

apps/sipp-go/tui/view.go +64 −112


import (
	"fmt"
	"strings"

	tea "charm.land/bubbletea/v2"
	"charm.land/lipgloss/v2"

var (
	borderStyle = lipgloss.NewStyle().
			Border(lipgloss.RoundedBorder()).
			BorderForeground(lipgloss.Color("240"))
			BorderForeground(lipgloss.Color("8"))
	borderActive = lipgloss.NewStyle().
			Border(lipgloss.RoundedBorder()).
			BorderForeground(lipgloss.Color("214"))
			BorderForeground(lipgloss.Color("3"))
	titleStyle = lipgloss.NewStyle().
			Bold(true).
			Foreground(lipgloss.Color("214")).
			Foreground(lipgloss.Color("3")).
			Padding(0, 1)
	itemStyle    = lipgloss.NewStyle().Padding(0, 1)
	itemSelected = lipgloss.NewStyle().
			Padding(0, 1).
			Bold(true).
			Foreground(lipgloss.Color("214"))
	dimStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("244"))
	statusOK = lipgloss.NewStyle().
			Foreground(lipgloss.Color("82")).
	statusOKStyle = lipgloss.NewStyle().
			Foreground(lipgloss.Color("2")).
			Bold(true)
	statusErr = lipgloss.NewStyle().
			Foreground(lipgloss.Color("196")).
	statusErrStyle = lipgloss.NewStyle().
			Foreground(lipgloss.Color("1")).
			Bold(true)
	hintStyle = lipgloss.NewStyle().
			Foreground(lipgloss.Color("244"))
			Foreground(lipgloss.Color("8"))
	modalStyle = lipgloss.NewStyle().
			Border(lipgloss.RoundedBorder()).
			BorderForeground(lipgloss.Color("214")).
			Padding(1, 2).
			Background(lipgloss.Color("236"))
			BorderForeground(lipgloss.Color("3")).
			Padding(1, 2)
)

func (m Model) View() tea.View {

	contentW := m.width - listW - 2
	bodyH := m.height - 2

	left := m.renderList(listW, bodyH)
	right := m.renderRight(contentW, bodyH)
	left := m.renderListPane(listW, bodyH)
	right := m.renderRightPane(contentW, bodyH)

	body := lipgloss.JoinHorizontal(lipgloss.Top, left, right)
	footer := m.renderFooter()

	base := lipgloss.JoinVertical(lipgloss.Left, body, footer)

	var overlays []*lipgloss.Layer

			modalStyle.Render(m.help.FullHelpView(m.keys.FullHelp())), 1))
	}
	if m.confirmDelete {
		s := m.current()
		name := ""
		if s != nil {
		if s, ok := m.list.Selected(); ok {
			name = s.Name
			if name == "" {
				name = s.ShortID
			}
		}
		overlays = append(overlays, centerLayer(m.width, m.height,
			modalStyle.Render(fmt.Sprintf("Delete %q?\n\ny / n", name)), 2))
	}
	if m.status != "" {
		st := statusOK
		st := statusOKStyle
		if !m.statusOK {
			st = statusErr
			st = statusErrStyle
		}
		overlays = append(overlays, bottomCenterLayer(m.width, m.height,
			modalStyle.Render(st.Render(m.status)), 3))

	return tea.View{Content: content, AltScreen: true}
}

func centerLayer(w, h int, content string, z int) *lipgloss.Layer {
	cw, ch := lipgloss.Width(content), lipgloss.Height(content)
	x := (w - cw) / 2
	y := (h - ch) / 2
	if x < 0 {
		x = 0
	}
	if y < 0 {
		y = 0
	}
	return lipgloss.NewLayer(content).X(x).Y(y).Z(z)
}

func bottomCenterLayer(w, h int, content string, z int) *lipgloss.Layer {
	cw, ch := lipgloss.Width(content), lipgloss.Height(content)
	x := (w - cw) / 2
	y := h - ch - 1
	if x < 0 {
		x = 0
	}
	if y < 0 {
		y = 0
	}
	return lipgloss.NewLayer(content).X(x).Y(y).Z(z)
}

func (m Model) renderList(w, h int) string {
func (m Model) renderListPane(w, h int) string {
	style := borderStyle
	if m.focus == FocusList || m.focus == FocusSearch {
	if m.state == stateList {
		style = borderActive
	}

	list := m.visible()
	rows := make([]string, 0, len(list)+2)
	rows = append(rows, titleStyle.Render("snippets"))
	if len(list) == 0 {
		rows = append(rows, hintStyle.Render("  (empty — press c)"))
	}
	for i, s := range list {
		label := s.Name
		if label == "" {
			label = s.ShortID
		}
		line := truncate(label, w-6)
		id := dimStyle.Render(" " + s.ShortID)
		if i == m.cursor {
			rows = append(rows, itemSelected.Render("▶ "+line)+id)
		} else {
			rows = append(rows, itemStyle.Render("  "+line)+id)
		}
	}

	if m.focus == FocusSearch || m.searchInput.Value() != "" {
		rows = append(rows, "", hintStyle.Render(m.searchInput.View()))
	}

	content := strings.Join(rows, "\n")
	return style.Width(w).Height(h).Render(content)
	return style.Width(w).Height(h).Render(m.list.View())
}

func (m Model) renderRight(w, h int) string {
	switch m.focus {
	case FocusCreateName, FocusCreateContent, FocusEditName, FocusEditContent:
func (m Model) renderRightPane(w, h int) string {
	if m.state == stateForm {
		return m.renderForm(w, h)
	}
	return m.renderContent(w, h)


func (m Model) renderContent(w, h int) string {
	style := borderStyle
	if m.focus == FocusContent {
	if m.state == stateContent {
		style = borderActive
	}
	header := "preview"
	if m.wrapContent {
	if m.cont.Wrap() {
		header += " (wrap)"
	}
	s := m.current()
	if s != nil {
		header = s.Name
		if header == "" {
			header = s.ShortID
	if t := m.cont.Header(); t != "" {
		header = t
		if m.cont.Wrap() {
			header += " (wrap)"
		}
	}
	body := m.contentVP.View()
	inner := lipgloss.JoinVertical(lipgloss.Left, titleStyle.Render(header), body)
	inner := lipgloss.JoinVertical(lipgloss.Left, titleStyle.Render(header), m.cont.View())
	return style.Width(w).Height(h).Render(inner)
}

func (m Model) renderForm(w, h int) string {
	header := "new snippet"
	if m.editShortID != "" {
	if !m.form.IsCreate() {
		header = "edit"
	}
	if m.wrapContent {
		header += " (wrap)"
	}
	name := m.nameInput.View()
	if m.focus == FocusCreateName || m.focus == FocusEditName {
		name = borderActive.Render(name)

	nameField := m.form.name.View()
	if m.form.ActiveField() == formFieldName {
		nameField = borderActive.Render(nameField)
	} else {
		name = borderStyle.Render(name)
		nameField = borderStyle.Render(nameField)
	}

	body := m.contentArea.View()
	if m.focus == FocusCreateContent || m.focus == FocusEditContent {
	body := m.form.content.View()
	if m.form.ActiveField() == formFieldContent {
		body = borderActive.Render(body)
	} else {
		body = borderStyle.Render(body)
	}

	inner := lipgloss.JoinVertical(lipgloss.Left, titleStyle.Render(header), name, body)
	return borderStyle.Width(w).Height(h).Render(inner)
	inner := lipgloss.JoinVertical(lipgloss.Left, titleStyle.Render(header), nameField, body)
	return borderActive.Width(w).Height(h).Render(inner)
}

func (m Model) renderFooter() string {

	return hintStyle.Render(fmt.Sprintf("[%s] %s", mode, help))
}

func truncate(s string, n int) string {
	if n < 1 {
		return ""
func centerLayer(w, h int, content string, z int) *lipgloss.Layer {
	cw, ch := lipgloss.Width(content), lipgloss.Height(content)
	x := (w - cw) / 2
	y := (h - ch) / 2
	if x < 0 {
		x = 0
	}
	if len(s) <= n {
		return s
	if y < 0 {
		y = 0
	}
	if n <= 1 {
		return "…"
	return lipgloss.NewLayer(content).X(x).Y(y).Z(z)
}

func bottomCenterLayer(w, h int, content string, z int) *lipgloss.Layer {
	cw, ch := lipgloss.Width(content), lipgloss.Height(content)
	x := (w - cw) / 2
	y := h - ch - 1
	if x < 0 {
		x = 0
	}
	if y < 0 {
		y = 0
	}
	return s[:n-1] + "…"
	return lipgloss.NewLayer(content).X(x).Y(y).Z(z)
}

func paneFrameWidth() int  { return borderStyle.GetHorizontalFrameSize() }
func paneFrameHeight() int { return borderStyle.GetVerticalFrameSize() }

51	51		github.com/ncruces/go-strftime v0.1.9 // indirect
52	52		github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
53	53		github.com/rivo/uniseg v0.4.7 // indirect
	54	+	github.com/sahilm/fuzzy v0.1.1 // indirect
54	55		github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
55	56		github.com/yuin/goldmark-emoji v1.0.6 // indirect
56	57		golang.org/x/crypto v0.39.0 // indirect

54	54		github.com/gorilla/css v1.0.1/go.mod h1:BvnYkspnSzMmwRK+b8/xgNPLiIuNZr6vbZBTPQ2A3b0=
55	55		github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
56	56		github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
	57	+	github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
	58	+	github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
57	59		github.com/lucasb-eyer/go-colorful v1.4.0 h1:UtrWVfLdarDgc44HcS7pYloGHJUjHV/4FwW4TvVgFr4=
58	60		github.com/lucasb-eyer/go-colorful v1.4.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
59	61		github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=

72	74		github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
73	75		github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
74	76		github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
	77	+	github.com/sahilm/fuzzy v0.1.1 h1:ceu5RHF8DGgoi+/dR5PsECjCDH1BE3Fnmpo7aVXOdRA=
	78	+	github.com/sahilm/fuzzy v0.1.1/go.mod h1:VFvziUEIMCrT6A6tw2RFIXPXXmzXbOsSHF0DOI8ZK9Y=
75	79		github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=
76	80		github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=
77	81		github.com/yuin/goldmark v1.7.13 h1:GPddIs617DnBLFFVJFgpo1aBfe/4xcvMc3SB5t/D0pA=

3	3		import "charm.land/bubbles/v2/key"
4	4
5	5		type keyMap struct {
6		-	Up key.Binding
7		-	Down key.Binding
8	6		Open key.Binding
9	7		Back key.Binding
10	8		Quit key.Binding

15	13		Copy key.Binding
16	14		CopyLink key.Binding
17	15		OpenBrowser key.Binding
18		-	Search key.Binding
19	16		Refresh key.Binding
20	17		Help key.Binding
21		-	Save key.Binding
22	18		ToggleWrap key.Binding
23		-	SwitchField key.Binding
24		-	Cancel key.Binding
	19	+	ScrollUp key.Binding
	20	+	ScrollDown key.Binding
25	21		}
26	22
27	23		func defaultKeys() keyMap {
28	24		return keyMap{
29		-	Up: key.NewBinding(key.WithKeys("up", "k"), key.WithHelp("↑/k", "up")),
30		-	Down: key.NewBinding(key.WithKeys("down", "j"), key.WithHelp("↓/j", "down")),
31	25		Open: key.NewBinding(key.WithKeys("enter", "l"), key.WithHelp("⏎/l", "open")),
32		-	Back: key.NewBinding(key.WithKeys("h", "esc", " "), key.WithHelp("h/␣", "back")),
33		-	Quit: key.NewBinding(key.WithKeys("q"), key.WithHelp("q", "quit")),
	26	+	Back: key.NewBinding(key.WithKeys("h", "esc"), key.WithHelp("h/esc", "back")),
	27	+	Quit: key.NewBinding(key.WithKeys("q", "ctrl+c"), key.WithHelp("q", "quit")),
34	28		Create: key.NewBinding(key.WithKeys("c"), key.WithHelp("c", "create")),
35	29		Edit: key.NewBinding(key.WithKeys("e"), key.WithHelp("e", "edit")),
36	30		ExtEdit: key.NewBinding(key.WithKeys("E"), key.WithHelp("E", "$EDITOR")),

38	32		Copy: key.NewBinding(key.WithKeys("y"), key.WithHelp("y", "copy text")),
39	33		CopyLink: key.NewBinding(key.WithKeys("Y"), key.WithHelp("Y", "copy link")),
40	34		OpenBrowser: key.NewBinding(key.WithKeys("o"), key.WithHelp("o", "browser")),
41		-	Search: key.NewBinding(key.WithKeys("/"), key.WithHelp("/", "search")),
42	35		Refresh: key.NewBinding(key.WithKeys("r"), key.WithHelp("r", "refresh")),
43	36		Help: key.NewBinding(key.WithKeys("?"), key.WithHelp("?", "help")),
44		-	Save: key.NewBinding(key.WithKeys("ctrl+s"), key.WithHelp("⌃s", "save")),
45	37		ToggleWrap: key.NewBinding(key.WithKeys("ctrl+w"), key.WithHelp("⌃w", "wrap")),
46		-	SwitchField: key.NewBinding(key.WithKeys("tab"), key.WithHelp("⇥", "switch field")),
47		-	Cancel: key.NewBinding(key.WithKeys("esc"), key.WithHelp("esc", "cancel")),
	38	+	ScrollUp: key.NewBinding(key.WithKeys("up", "k"), key.WithHelp("↑/k", "up")),
	39	+	ScrollDown: key.NewBinding(key.WithKeys("down", "j"), key.WithHelp("↓/j", "down")),
48	40		}
49	41		}
50	42
51	43		func (k keyMap) ShortHelp() []key.Binding {
52		-	return []key.Binding{k.Open, k.Create, k.Edit, k.Delete, k.Search, k.Help, k.Quit}
	44	+	return []key.Binding{k.Open, k.Create, k.Edit, k.Delete, k.Help, k.Quit}
53	45		}
54	46
55	47		func (k keyMap) FullHelp() [][]key.Binding {
56	48		return [][]key.Binding{
57		-	{k.Up, k.Down, k.Open, k.Back},
58		-	{k.Create, k.Edit, k.ExtEdit, k.Delete},
59		-	{k.Copy, k.CopyLink, k.OpenBrowser, k.Search},
60		-	{k.Refresh, k.Help, k.Save, k.ToggleWrap},
61		-	{k.SwitchField, k.Cancel, k.Quit},
	49	+	{k.Open, k.Back, k.Create, k.Edit},
	50	+	{k.ExtEdit, k.Delete, k.Copy, k.CopyLink},
	51	+	{k.OpenBrowser, k.Refresh, k.ToggleWrap, k.Help},
	52	+	{k.ScrollUp, k.ScrollDown, k.Quit},
62	53		}
63	54		}

7	7		"charm.land/glamour/v2/ansi"
8	8		)
9	9
	10	+	const mdCacheMax = 64
	11	+
10	12		type mdRenderer struct {
11	13		r *glamour.TermRenderer
12	14		width int
13	15		cache map[string]string
	16	+	order []string
14	17		}
15	18
16	19		func sp(s string) *string { return &s }

92	95		return &mdRenderer{r: r, width: width, cache: map[string]string{}}
93	96		}
94	97
	98	+	func (m *mdRenderer) store(key, value string) {
	99	+	if _, ok := m.cache[key]; !ok {
	100	+	m.order = append(m.order, key)
	101	+	if len(m.order) > mdCacheMax {
	102	+	drop := m.order[0]
	103	+	m.order = m.order[1:]
	104	+	delete(m.cache, drop)
	105	+	}
	106	+	}
	107	+	m.cache[key] = value
	108	+	}
	109	+
95	110		func (m *mdRenderer) resize(width int) {
96	111		if width == m.width \|\| width < 20 {
97	112		return

104	119		m.r = r
105	120		m.width = width
106	121		m.cache = map[string]string{}
	122	+	m.order = nil
107	123		}
108	124
109	125		func (m *mdRenderer) render(key, body string) string {

117	133		if err != nil {
118	134		out = fmt.Sprintf("render error: %v\n\n%s", err, body)
119	135		}
120		-	m.cache[key] = out
	136	+	m.store(key, out)
121	137		return out
122	138		}
123	139
124	140		func (m *mdRenderer) invalidate(key string) {
	141	+	if _, ok := m.cache[key]; !ok {
	142	+	return
	143	+	}
125	144		delete(m.cache, key)
	145	+	for i, k := range m.order {
	146	+	if k == key {
	147	+	m.order = append(m.order[:i], m.order[i+1:]...)
	148	+	break
	149	+	}
	150	+	}
126	151		}

2	2
3	3		import (
4	4		"strings"
	5	+	"time"
5	6
6		-	"github.com/atotto/clipboard"
7	7		"charm.land/bubbles/v2/key"
8	8		tea "charm.land/bubbletea/v2"
9	9		)
10	10
11		-	func loadNotesCmd(b Backend) tea.Cmd {
12		-	return func() tea.Msg {
13		-	notes, err := b.List()
14		-	return notesLoadedMsg{notes: notes, err: err}
15		-	}
16		-	}
17		-
18		-	func saveNoteCmd(b Backend, shortID, title, content string) tea.Cmd {
19		-	return func() tea.Msg {
20		-	var (
21		-	note *Note
22		-	err error
23		-	)
24		-	if shortID == "" {
25		-	note, err = b.Create(title, content)
26		-	} else {
27		-	note, err = b.Update(shortID, title, content)
28		-	}
29		-	return noteSavedMsg{note: note, err: err}
30		-	}
31		-	}
32		-
33		-	func deleteNoteCmd(b Backend, shortID string) tea.Cmd {
34		-	return func() tea.Msg {
35		-	_, err := b.Delete(shortID)
36		-	return noteDeletedMsg{shortID: shortID, err: err}
37		-	}
38		-	}
39		-
40	11		func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
41	12		switch msg := msg.(type) {
42	13
43	14		case tea.WindowSizeMsg:
44	15		m.width, m.height = msg.Width, msg.Height
45	16		m.ready = true
46		-	m.resizePanes()
	17	+	m.applyLayout()
47	18		return m, nil
48	19
49	20		case notesLoadedMsg:
50	21		if msg.err != nil {
51		-	cmd := m.setStatus("load: "+msg.err.Error(), false)
52		-	return m, cmd
	22	+	return m, m.setStatus("load: "+msg.err.Error(), false)
53	23		}
54		-	m.notes = msg.notes
55		-	m.applyFilter(m.searchInput.Value())
56		-	m.refreshPreview()
57		-	return m, nil
	24	+	cmd := m.list.SetNotes(msg.notes)
	25	+	if n, ok := m.list.Selected(); ok {
	26	+	m.cont.SetNote(&n)
	27	+	} else {
	28	+	m.cont.SetNote(nil)
	29	+	}
	30	+	return m, cmd
58	31
59	32		case noteSavedMsg:
60	33		if msg.err != nil {
61	34		return m, m.setStatus("save: "+msg.err.Error(), false)
62	35		}
63		-	if m.renderer != nil && msg.note != nil {
64		-	m.renderer.invalidate(msg.note.ShortID)
	36	+	if msg.note != nil {
	37	+	m.cont.Invalidate(msg.note.ShortID)
65	38		}
66		-	m.focus = FocusList
67		-	m.titleInput.Reset()
68		-	m.contentArea.Reset()
69		-	m.editShortID = ""
70		-	return m, loadNotesCmd(m.backend)
	39	+	m.state = stateList
	40	+	m.form.Blur()
	41	+	return m, tea.Batch(loadNotesCmd(m.backend), m.setStatus("saved", true))
71	42
72	43		case noteDeletedMsg:
73	44		if msg.err != nil {
74	45		return m, m.setStatus("delete: "+msg.err.Error(), false)
75	46		}
76		-	if m.renderer != nil {
77		-	m.renderer.invalidate(msg.shortID)
78		-	}
	47	+	m.cont.Invalidate(msg.shortID)
	48	+	m.state = stateList
79	49		return m, tea.Batch(loadNotesCmd(m.backend), m.setStatus("deleted", true))
80	50
81	51		case editorFinishedMsg:

83	53		return m, m.setStatus("editor: "+msg.err.Error(), false)
84	54		}
85	55		if msg.shortID == "" {
86		-	m.contentArea.SetValue(msg.content)
	56	+	m.form.SetContent(msg.content)
87	57		return m, nil
88	58		}
89	59		var orig *Note
90		-	for i := range m.notes {
91		-	if m.notes[i].ShortID == msg.shortID {
92		-	orig = &m.notes[i]
	60	+	for _, it := range m.list.inner.Items() {
	61	+	ni, ok := it.(noteItem)
	62	+	if ok && ni.note.ShortID == msg.shortID {
	63	+	n := ni.note
	64	+	orig = &n
93	65		break
94	66		}
95	67		}

98	70		}
99	71		return m, saveNoteCmd(m.backend, msg.shortID, orig.Title, msg.content)
100	72
	73	+	case submitFormMsg:
	74	+	return m, saveNoteCmd(m.backend, msg.shortID, msg.title, msg.content)
	75	+
	76	+	case cancelFormMsg:
	77	+	m.state = stateList
	78	+	return m, nil
	79	+
101	80		case statusMsg:
102	81		return m, m.setStatus(msg.text, msg.ok)
103	82
104	83		case clearStatusMsg:
	84	+	if time.Now().Before(m.statusUntil) {
	85	+	return m, nil
	86	+	}
105	87		m.status = ""
106	88		return m, nil
107	89

112	94		return m, nil
113	95		}
114	96
115		-	func (m *Model) resizePanes() {
116		-	if !m.ready {
117		-	return
118		-	}
119		-
120		-	_, contentOuterW := splitWidths(m.width)
121		-	bodyOuterH := splitBodyHeight(m.height)
122		-	contentInnerW := maxInt(contentOuterW-paneFrameWidth(), 20)
123		-	contentInnerH := maxInt(bodyOuterH-paneFrameHeight(), 3)
124		-
125		-	m.contentVP.SetWidth(maxInt(contentInnerW, 1))
126		-	m.contentVP.SetHeight(maxInt(contentInnerH-1, 1))
127		-
128		-	m.titleInput.SetWidth(maxInt(contentInnerW-4, 1))
129		-	m.contentArea.SetWidth(maxInt(contentInnerW-2, 1))
130		-	m.contentArea.SetHeight(maxInt(contentInnerH-6, 1))
131		-
132		-	listOuterW, _ := splitWidths(m.width)
133		-	listInnerW := maxInt(listOuterW-paneFrameWidth(), 1)
134		-	m.searchInput.SetWidth(maxInt(listInnerW-2, 1))
135		-
136		-	if m.renderer == nil {
137		-	m.renderer = newRenderer(contentInnerW)
138		-	} else {
139		-	m.renderer.resize(contentInnerW)
140		-	}
141		-	m.refreshPreview()
142		-	}
143		-
144		-	func (m *Model) refreshPreview() {
145		-	if m.renderer == nil {
146		-	return
147		-	}
148		-	n := m.currentNote()
149		-	if n == nil {
150		-	m.contentVP.SetContent("")
151		-	return
152		-	}
153		-	body := n.Content
154		-	if !m.wrap {
155		-	// raw view: no rendering
156		-	m.contentVP.SetContent(body)
157		-	return
158		-	}
159		-	m.contentVP.SetContent(m.renderer.render(n.ShortID, body))
160		-	}
161		-
162	97		func (m Model) handleKey(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) {
163	98		if m.confirmDelete {
164	99		switch msg.String() {
165	100		case "y", "Y":
166		-	n := m.currentNote()
167	101		m.confirmDelete = false
168		-	if n == nil {
	102	+	n, ok := m.list.Selected()
	103	+	if !ok {
169	104		return m, nil
170	105		}
171	106		return m, deleteNoteCmd(m.backend, n.ShortID)
172	107		case "n", "N", "esc", "q":
173	108		m.confirmDelete = false
174		-	return m, nil
175	109		}
176	110		return m, nil
177	111		}

183	117		return m, nil
184	118		}
185	119
186		-	switch m.focus {
187		-	case FocusList:
188		-	return m.keyList(msg)
189		-	case FocusContent:
190		-	return m.keyContent(msg)
191		-	case FocusCreateTitle, FocusCreateContent, FocusEditTitle, FocusEditContent:
192		-	return m.keyForm(msg)
193		-	case FocusSearch:
194		-	return m.keySearch(msg)
	120	+	switch m.state {
	121	+	case stateList:
	122	+	return m.handleListKey(msg)
	123	+	case stateContent:
	124	+	return m.handleContentKey(msg)
	125	+	case stateForm:
	126	+	var cmd tea.Cmd
	127	+	m.form, cmd = m.form.Update(msg)
	128	+	return m, cmd
195	129		}
196	130		return m, nil
197	131		}
198	132
199		-	func (m Model) keyList(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) {
200		-	notes := m.visibleNotes()
	133	+	func (m Model) handleListKey(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) {
	134	+	// While the list is in filter-entry mode, route every key to it
	135	+	// so typing and esc/enter behave as expected.
	136	+	if m.list.IsFiltering() {
	137	+	var cmd tea.Cmd
	138	+	m.list, cmd = m.list.Update(msg)
	139	+	m.refreshContentFromSelection()
	140	+	return m, cmd
	141	+	}
	142	+
201	143		switch {
202	144		case key.Matches(msg, m.keys.Quit):
203	145		return m, tea.Quit
204		-	case key.Matches(msg, m.keys.Down):
205		-	if m.cursor < len(notes)-1 {
206		-	m.cursor++
207		-	m.refreshPreview()
208		-	}
209		-	case key.Matches(msg, m.keys.Up):
210		-	if m.cursor > 0 {
211		-	m.cursor--
212		-	m.refreshPreview()
213		-	}
214	146		case key.Matches(msg, m.keys.Open):
215		-	if len(notes) > 0 {
216		-	m.focus = FocusContent
217		-	m.contentVP.GotoTop()
	147	+	if n, ok := m.list.Selected(); ok {
	148	+	m.cont.SetNote(&n)
	149	+	m.state = stateContent
218	150		}
	151	+	return m, nil
219	152		case key.Matches(msg, m.keys.Create):
220		-	m.focus = FocusCreateTitle
221		-	m.editShortID = ""
222		-	m.titleInput.SetValue("")
223		-	m.contentArea.SetValue("")
224		-	m.titleInput.Focus()
225		-	m.contentArea.Blur()
	153	+	m.form.StartCreate()
	154	+	m.state = stateForm
	155	+	return m, nil
226	156		case key.Matches(msg, m.keys.Edit):
227		-	n := m.currentNote()
228		-	if n != nil {
229		-	m.focus = FocusEditTitle
230		-	m.editShortID = n.ShortID
231		-	m.titleInput.SetValue(n.Title)
232		-	m.contentArea.SetValue(n.Content)
233		-	m.titleInput.Focus()
234		-	m.contentArea.Blur()
	157	+	if n, ok := m.list.Selected(); ok {
	158	+	m.form.StartEdit(n)
	159	+	m.state = stateForm
235	160		}
	161	+	return m, nil
236	162		case key.Matches(msg, m.keys.ExtEdit):
237		-	n := m.currentNote()
238		-	if n != nil {
	163	+	if n, ok := m.list.Selected(); ok {
239	164		return m, openExternalEditor(n.ShortID, n.Content)
240	165		}
	166	+	return m, nil
241	167		case key.Matches(msg, m.keys.Delete):
242		-	if m.currentNote() != nil {
	168	+	if _, ok := m.list.Selected(); ok {
243	169		m.confirmDelete = true
244	170		}
	171	+	return m, nil
245	172		case key.Matches(msg, m.keys.Copy):
246		-	n := m.currentNote()
247		-	if n != nil {
248		-	if err := clipboard.WriteAll(n.Content); err != nil {
249		-	return m, m.setStatus("clipboard: "+err.Error(), false)
250		-	}
251		-	return m, m.setStatus("copied text", true)
	173	+	if n, ok := m.list.Selected(); ok {
	174	+	return m, copyToClipboardCmd(n.Content, "copied text")
252	175		}
	176	+	return m, nil
253	177		case key.Matches(msg, m.keys.CopyLink):
254		-	n := m.currentNote()
255		-	if n != nil && m.isRemote {
256		-	link := strings.TrimRight(m.backend.RemoteURL(), "/") + "/notes/" + n.ShortID
257		-	if err := clipboard.WriteAll(link); err != nil {
258		-	return m, m.setStatus("clipboard: "+err.Error(), false)
259		-	}
260		-	return m, m.setStatus("copied link", true)
	178	+	if !m.isRemote {
	179	+	return m, m.setStatus("local mode: no link", false)
	180	+	}
	181	+	if n, ok := m.list.Selected(); ok {
	182	+	return m, copyToClipboardCmd(noteLinkURL(m.backend.RemoteURL(), n.ShortID), "copied link")
261	183		}
262		-	return m, m.setStatus("local mode: no link", false)
	184	+	return m, nil
263	185		case key.Matches(msg, m.keys.OpenBrowser):
264		-	n := m.currentNote()
265		-	if n != nil && m.isRemote {
266		-	link := strings.TrimRight(m.backend.RemoteURL(), "/") + "/notes/" + n.ShortID
267		-	if err := openURL(link); err != nil {
268		-	return m, m.setStatus("open: "+err.Error(), false)
269		-	}
270		-	return m, m.setStatus("opened "+link, true)
	186	+	if !m.isRemote {
	187	+	return m, nil
	188	+	}
	189	+	if n, ok := m.list.Selected(); ok {
	190	+	return m, openURLCmd(noteLinkURL(m.backend.RemoteURL(), n.ShortID))
271	191		}
272		-	case key.Matches(msg, m.keys.Search):
273		-	m.focus = FocusSearch
274		-	m.searchInput.Focus()
	192	+	return m, nil
275	193		case key.Matches(msg, m.keys.Refresh):
276	194		if m.isRemote {
277	195		return m, loadNotesCmd(m.backend)
278	196		}
	197	+	return m, nil
279	198		case key.Matches(msg, m.keys.Help):
280	199		m.showHelp = true
	200	+	return m, nil
281	201		}
282		-	return m, nil
	202	+
	203	+	var cmd tea.Cmd
	204	+	m.list, cmd = m.list.Update(msg)
	205	+	m.refreshContentFromSelection()
	206	+	return m, cmd
283	207		}
284	208
285		-	func (m Model) keyContent(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) {
	209	+	func (m Model) handleContentKey(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) {
286	210		switch {
287	211		case key.Matches(msg, m.keys.Quit), key.Matches(msg, m.keys.Back):
288		-	m.focus = FocusList
	212	+	m.state = stateList
	213	+	return m, nil
	214	+	case key.Matches(msg, m.keys.ScrollDown):
	215	+	m.cont = m.cont.ScrollDown(1)
289	216		return m, nil
290		-	case key.Matches(msg, m.keys.Down):
291		-	m.contentVP.ScrollDown(1)
292		-	case key.Matches(msg, m.keys.Up):
293		-	m.contentVP.ScrollUp(1)
	217	+	case key.Matches(msg, m.keys.ScrollUp):
	218	+	m.cont = m.cont.ScrollUp(1)
	219	+	return m, nil
294	220		case key.Matches(msg, m.keys.Edit):
295		-	n := m.currentNote()
296		-	if n != nil {
297		-	m.focus = FocusEditTitle
298		-	m.editShortID = n.ShortID
299		-	m.titleInput.SetValue(n.Title)
300		-	m.contentArea.SetValue(n.Content)
301		-	m.titleInput.Focus()
	221	+	if n, ok := m.list.Selected(); ok {
	222	+	m.form.StartEdit(n)
	223	+	m.state = stateForm
302	224		}
	225	+	return m, nil
303	226		case key.Matches(msg, m.keys.ExtEdit):
304		-	n := m.currentNote()
305		-	if n != nil {
	227	+	if n, ok := m.list.Selected(); ok {
306	228		return m, openExternalEditor(n.ShortID, n.Content)
307	229		}
	230	+	return m, nil
308	231		case key.Matches(msg, m.keys.Copy):
309		-	n := m.currentNote()
310		-	if n != nil {
311		-	clipboard.WriteAll(n.Content)
312		-	return m, m.setStatus("copied text", true)
	232	+	if n, ok := m.list.Selected(); ok {
	233	+	return m, copyToClipboardCmd(n.Content, "copied text")
313	234		}
	235	+	return m, nil
314	236		case key.Matches(msg, m.keys.CopyLink):
315		-	n := m.currentNote()
316		-	if n != nil && m.isRemote {
317		-	link := strings.TrimRight(m.backend.RemoteURL(), "/") + "/notes/" + n.ShortID
318		-	clipboard.WriteAll(link)
319		-	return m, m.setStatus("copied link", true)
	237	+	if !m.isRemote {
	238	+	return m, m.setStatus("local mode: no link", false)
320	239		}
321		-	case key.Matches(msg, m.keys.OpenBrowser):
322		-	n := m.currentNote()
323		-	if n != nil && m.isRemote {
324		-	openURL(strings.TrimRight(m.backend.RemoteURL(), "/") + "/notes/" + n.ShortID)
	240	+	if n, ok := m.list.Selected(); ok {
	241	+	return m, copyToClipboardCmd(noteLinkURL(m.backend.RemoteURL(), n.ShortID), "copied link")
325	242		}
326		-	case key.Matches(msg, m.keys.Help):
327		-	m.showHelp = true
328		-	case key.Matches(msg, m.keys.ToggleWrap):
329		-	m.wrap = !m.wrap
330		-	m.refreshPreview()
331		-	}
332		-	var cmd tea.Cmd
333		-	m.contentVP, cmd = m.contentVP.Update(msg)
334		-	return m, cmd
335		-	}
336		-
337		-	func (m Model) keyForm(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) {
338		-	switch {
339		-	case key.Matches(msg, m.keys.Cancel):
340		-	m.focus = FocusList
341		-	m.titleInput.Blur()
342		-	m.contentArea.Blur()
343	243		return m, nil
344		-	case key.Matches(msg, m.keys.Save):
345		-	title := strings.TrimSpace(m.titleInput.Value())
346		-	if title == "" {
347		-	return m, m.setStatus("title required", false)
	244	+	case key.Matches(msg, m.keys.OpenBrowser):
	245	+	if !m.isRemote {
	246	+	return m, nil
348	247		}
349		-	return m, saveNoteCmd(m.backend, m.editShortID, title, m.contentArea.Value())
350		-	case key.Matches(msg, m.keys.SwitchField):
351		-	switch m.focus {
352		-	case FocusCreateTitle:
353		-	m.focus = FocusCreateContent
354		-	case FocusCreateContent:
355		-	m.focus = FocusCreateTitle
356		-	case FocusEditTitle:
357		-	m.focus = FocusEditContent
358		-	case FocusEditContent:
359		-	m.focus = FocusEditTitle
	248	+	if n, ok := m.list.Selected(); ok {
	249	+	return m, openURLCmd(noteLinkURL(m.backend.RemoteURL(), n.ShortID))
360	250		}
361		-	m.applyFormFocus()
362	251		return m, nil
363	252		case key.Matches(msg, m.keys.ToggleWrap):
364		-	m.wrap = !m.wrap
	253	+	m.cont.ToggleWrap()
	254	+	return m, nil
	255	+	case key.Matches(msg, m.keys.Help):
	256	+	m.showHelp = true
365	257		return m, nil
366	258		}
367	259
368	260		var cmd tea.Cmd
369		-	switch m.focus {
370		-	case FocusCreateTitle, FocusEditTitle:
371		-	m.titleInput, cmd = m.titleInput.Update(msg)
372		-	case FocusCreateContent, FocusEditContent:
373		-	m.contentArea, cmd = m.contentArea.Update(msg)
374		-	}
	261	+	m.cont, cmd = m.cont.Update(msg)
375	262		return m, cmd
376	263		}
377	264
378		-	func (m *Model) applyFormFocus() {
379		-	switch m.focus {
380		-	case FocusCreateTitle, FocusEditTitle:
381		-	m.titleInput.Focus()
382		-	m.contentArea.Blur()
383		-	case FocusCreateContent, FocusEditContent:
384		-	m.contentArea.Focus()
385		-	m.titleInput.Blur()
	265	+	func (m *Model) refreshContentFromSelection() {
	266	+	if n, ok := m.list.Selected(); ok {
	267	+	m.cont.SetNote(&n)
	268	+	} else {
	269	+	m.cont.SetNote(nil)
386	270		}
387	271		}
388	272
389		-	func (m Model) keySearch(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) {
390		-	switch msg.String() {
391		-	case "esc":
392		-	m.searchInput.SetValue("")
393		-	m.searchInput.Blur()
394		-	m.focus = FocusList
395		-	m.applyFilter("")
396		-	m.refreshPreview()
397		-	return m, nil
398		-	case "enter":
399		-	m.searchInput.Blur()
400		-	m.focus = FocusList
401		-	return m, nil
	273	+	func (m *Model) applyLayout() {
	274	+	if !m.ready {
	275	+	return
402	276		}
403		-	var cmd tea.Cmd
404		-	m.searchInput, cmd = m.searchInput.Update(msg)
405		-	m.applyFilter(m.searchInput.Value())
406		-	m.refreshPreview()
407		-	return m, cmd
	277	+	listW, contentW := splitWidths(m.width)
	278	+	bodyH := splitBodyHeight(m.height)
	279	+
	280	+	listInnerW := max(listW-paneFrameWidth(), 1)
	281	+	listInnerH := max(bodyH-paneFrameHeight(), 1)
	282	+	m.list.SetSize(listInnerW, listInnerH)
	283	+
	284	+	contentInnerW := max(contentW-paneFrameWidth(), 20)
	285	+	contentInnerH := max(bodyH-paneFrameHeight(), 3)
	286	+	m.cont.SetSize(contentInnerW, max(contentInnerH-1, 1))
	287	+	m.form.SetSize(contentInnerW, contentInnerH)
	288	+	}
	289	+
	290	+	func (m *Model) setStatus(text string, ok bool) tea.Cmd {
	291	+	m.status = text
	292	+	m.statusOK = ok
	293	+	m.statusUntil = time.Now().Add(2 * time.Second)
	294	+	return tea.Tick(2*time.Second, func(time.Time) tea.Msg { return clearStatusMsg{} })
408	295		}

2	2
3	3		import (
4	4		"fmt"
5		-	"strings"
6	5
7	6		tea "charm.land/bubbletea/v2"
8	7		"charm.land/lipgloss/v2"

19	18		Bold(true).
20	19		Foreground(lipgloss.Color("3")).
21	20		Padding(0, 1)
22		-	itemStyle = lipgloss.NewStyle().Padding(0, 1)
23		-	itemSelected = lipgloss.NewStyle().
24		-	Padding(0, 1).
25		-	Bold(true).
26		-	Foreground(lipgloss.Color("3"))
27		-	statusOK = lipgloss.NewStyle().
	21	+	statusOKStyle = lipgloss.NewStyle().
28	22		Foreground(lipgloss.Color("2")).
29	23		Bold(true)
30		-	statusErr = lipgloss.NewStyle().
	24	+	statusErrStyle = lipgloss.NewStyle().
31	25		Foreground(lipgloss.Color("1")).
32	26		Bold(true)
33		-	hintStyle = lipgloss.NewStyle().
34		-	Foreground(lipgloss.Color("8"))
35	27		modalStyle = lipgloss.NewStyle().
36	28		Border(lipgloss.RoundedBorder()).
37	29		BorderForeground(lipgloss.Color("3")).

42	34		listW, contentW := splitWidths(m.width)
43	35		bodyH := splitBodyHeight(m.height)
44	36
45		-	left := m.renderList(listW, bodyH)
46		-	right := m.renderRight(contentW, bodyH)
	37	+	left := m.renderListPane(listW, bodyH)
	38	+	right := m.renderRightPane(contentW, bodyH)
47	39
48	40		base := lipgloss.JoinHorizontal(lipgloss.Top, left, right)
49	41

53	45		modalStyle.Render(m.help.FullHelpView(m.keys.FullHelp())), 1))
54	46		}
55	47		if m.confirmDelete {
56		-	n := m.currentNote()
57	48		title := ""
58		-	if n != nil {
	49	+	if n, ok := m.list.Selected(); ok {
59	50		title = n.Title
60	51		}
61	52		overlays = append(overlays, centerLayer(m.width, m.height,
62	53		modalStyle.Render(fmt.Sprintf("Delete %q?\n\ny / n", title)), 2))
63	54		}
64	55		if m.status != "" {
65		-	st := statusOK
	56	+	st := statusOKStyle
66	57		if !m.statusOK {
67		-	st = statusErr
	58	+	st = statusErrStyle
68	59		}
69	60		overlays = append(overlays, bottomCenterLayer(m.width, m.height,
70	61		modalStyle.Render(st.Render(m.status)), 3))

81	72		return tea.View{Content: content, AltScreen: true}
82	73		}
83	74
84		-	func centerLayer(w, h int, content string, z int) *lipgloss.Layer {
85		-	cw, ch := lipgloss.Width(content), lipgloss.Height(content)
86		-	x := (w - cw) / 2
87		-	y := (h - ch) / 2
88		-	if x < 0 {
89		-	x = 0
90		-	}
91		-	if y < 0 {
92		-	y = 0
93		-	}
94		-	return lipgloss.NewLayer(content).X(x).Y(y).Z(z)
95		-	}
96		-
97		-	func bottomCenterLayer(w, h int, content string, z int) *lipgloss.Layer {
98		-	cw, ch := lipgloss.Width(content), lipgloss.Height(content)
99		-	x := (w - cw) / 2
100		-	y := h - ch - 1
101		-	if x < 0 {
102		-	x = 0
103		-	}
104		-	if y < 0 {
105		-	y = 0
106		-	}
107		-	return lipgloss.NewLayer(content).X(x).Y(y).Z(z)
108		-	}
109		-
110		-	func (m Model) renderList(w, h int) string {
	75	+	func (m Model) renderListPane(w, h int) string {
111	76		style := borderStyle
112		-	if m.focus == FocusList \|\| m.focus == FocusSearch {
	77	+	if m.state == stateList {
113	78		style = borderActive
114	79		}
115		-
116		-	notes := m.visibleNotes()
117		-	rows := make([]string, 0, len(notes)+2)
118		-	rows = append(rows, titleStyle.Render("notes"))
119		-	if len(notes) == 0 {
120		-	rows = append(rows, hintStyle.Render(" (empty — press c)"))
121		-	}
122		-	for i, n := range notes {
123		-	line := truncate(n.Title, maxInt(w-paneFrameWidth()-4, 1))
124		-	if i == m.cursor {
125		-	rows = append(rows, itemSelected.Render("▶ "+line))
126		-	} else {
127		-	rows = append(rows, itemStyle.Render(" "+line))
128		-	}
129		-	}
130		-
131		-	if m.focus == FocusSearch \|\| m.searchInput.Value() != "" {
132		-	rows = append(rows, "", hintStyle.Render(m.searchInput.View()))
133		-	}
134		-
135		-	content := strings.Join(rows, "\n")
136	80		return style.
137		-	Width(maxInt(w-paneFrameWidth(), 1)).
138		-	Height(maxInt(h-paneFrameHeight(), 1)).
139		-	Render(content)
	81	+	Width(max(w-paneFrameWidth(), 1)).
	82	+	Height(max(h-paneFrameHeight(), 1)).
	83	+	Render(m.list.View())
140	84		}
141	85
142		-	func (m Model) renderRight(w, h int) string {
143		-	switch m.focus {
144		-	case FocusCreateTitle, FocusCreateContent, FocusEditTitle, FocusEditContent:
	86	+	func (m Model) renderRightPane(w, h int) string {
	87	+	if m.state == stateForm {
145	88		return m.renderForm(w, h)
146	89		}
147	90		return m.renderContent(w, h)

149	92
150	93		func (m Model) renderContent(w, h int) string {
151	94		style := borderStyle
152		-	if m.focus == FocusContent {
	95	+	if m.state == stateContent {
153	96		style = borderActive
154	97		}
155	98		header := "preview"
156		-	n := m.currentNote()
157		-	if n != nil {
158		-	header = n.Title
	99	+	if t := m.cont.Title(); t != "" {
	100	+	header = t
159	101		}
160		-	body := m.contentVP.View()
161		-	inner := lipgloss.JoinVertical(lipgloss.Left, titleStyle.Render(header), body)
	102	+	inner := lipgloss.JoinVertical(lipgloss.Left, titleStyle.Render(header), m.cont.View())
162	103		return style.
163		-	Width(maxInt(w-paneFrameWidth(), 1)).
164		-	Height(maxInt(h-paneFrameHeight(), 1)).
	104	+	Width(max(w-paneFrameWidth(), 1)).
	105	+	Height(max(h-paneFrameHeight(), 1)).
165	106		Render(inner)
166	107		}
167	108
168	109		func (m Model) renderForm(w, h int) string {
169	110		header := "new note"
170		-	if m.editShortID != "" {
	111	+	if !m.form.IsCreate() {
171	112		header = "edit"
172	113		}
173		-	title := m.titleInput.View()
174		-	if m.focus == FocusCreateTitle \|\| m.focus == FocusEditTitle {
175		-	title = borderActive.Render(title)
	114	+
	115	+	titleField := m.form.title.View()
	116	+	if m.form.ActiveField() == formFieldTitle {
	117	+	titleField = borderActive.Render(titleField)
176	118		} else {
177		-	title = borderStyle.Render(title)
	119	+	titleField = borderStyle.Render(titleField)
178	120		}
179	121
180		-	body := m.contentArea.View()
181		-	if m.focus == FocusCreateContent \|\| m.focus == FocusEditContent {
	122	+	body := m.form.content.View()
	123	+	if m.form.ActiveField() == formFieldContent {
182	124		body = borderActive.Render(body)
183	125		} else {
184	126		body = borderStyle.Render(body)
185	127		}
186	128
187		-	inner := lipgloss.JoinVertical(lipgloss.Left, titleStyle.Render(header), title, body)
188		-	return borderStyle.
189		-	Width(maxInt(w-paneFrameWidth(), 1)).
190		-	Height(maxInt(h-paneFrameHeight(), 1)).
	129	+	inner := lipgloss.JoinVertical(lipgloss.Left, titleStyle.Render(header), titleField, body)
	130	+	return borderActive.
	131	+	Width(max(w-paneFrameWidth(), 1)).
	132	+	Height(max(h-paneFrameHeight(), 1)).
191	133		Render(inner)
192	134		}
193	135
	136	+	func centerLayer(w, h int, content string, z int) *lipgloss.Layer {
	137	+	cw, ch := lipgloss.Width(content), lipgloss.Height(content)
	138	+	x := (w - cw) / 2
	139	+	y := (h - ch) / 2
	140	+	if x < 0 {
	141	+	x = 0
	142	+	}
	143	+	if y < 0 {
	144	+	y = 0
	145	+	}
	146	+	return lipgloss.NewLayer(content).X(x).Y(y).Z(z)
	147	+	}
	148	+
	149	+	func bottomCenterLayer(w, h int, content string, z int) *lipgloss.Layer {
	150	+	cw, ch := lipgloss.Width(content), lipgloss.Height(content)
	151	+	x := (w - cw) / 2
	152	+	y := h - ch - 1
	153	+	if x < 0 {
	154	+	x = 0
	155	+	}
	156	+	if y < 0 {
	157	+	y = 0
	158	+	}
	159	+	return lipgloss.NewLayer(content).X(x).Y(y).Z(z)
	160	+	}
	161	+
194	162		func splitWidths(total int) (int, int) {
195	163		if total < 44 {
196	164		return total / 2, total - (total / 2)

215	183		return total
216	184		}
217	185
218		-	func paneFrameWidth() int {
219		-	return borderStyle.GetHorizontalFrameSize()
220		-	}
221		-
222		-	func paneFrameHeight() int {
223		-	return borderStyle.GetVerticalFrameSize()
224		-	}
225		-
226		-	func maxInt(a, b int) int {
227		-	if a > b {
228		-	return a
229		-	}
230		-	return b
231		-	}
232		-
233		-	func truncate(s string, n int) string {
234		-	if n < 1 {
235		-	return ""
236		-	}
237		-	if len(s) <= n {
238		-	return s
239		-	}
240		-	if n <= 1 {
241		-	return "…"
242		-	}
243		-	return s[:n-1] + "…"
244		-	}
	186	+	func paneFrameWidth() int { return borderStyle.GetHorizontalFrameSize() }
	187	+	func paneFrameHeight() int { return borderStyle.GetVerticalFrameSize() }

46	46		github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
47	47		github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
48	48		github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
	49	+	github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
	50	+	github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
49	51		github.com/lucasb-eyer/go-colorful v1.4.0 h1:UtrWVfLdarDgc44HcS7pYloGHJUjHV/4FwW4TvVgFr4=
50	52		github.com/lucasb-eyer/go-colorful v1.4.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
51	53		github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=

60	62		github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
61	63		github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
62	64		github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
	65	+	github.com/sahilm/fuzzy v0.1.1 h1:ceu5RHF8DGgoi+/dR5PsECjCDH1BE3Fnmpo7aVXOdRA=
	66	+	github.com/sahilm/fuzzy v0.1.1/go.mod h1:VFvziUEIMCrT6A6tw2RFIXPXXmzXbOsSHF0DOI8ZK9Y=
63	67		github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=
64	68		github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=
65	69		golang.org/x/crypto v0.39.0 h1:SHs+kF4LP+f+p14esP5jAoDpHU8Gu/v9lFRK6IT5imM=

10	10		"github.com/alecthomas/chroma/v2/styles"
11	11		)
12	12
	13	+	const highlightCacheMax = 64
	14	+
13	15		type highlighter struct {
14	16		cache map[string]string
	17	+	order []string
15	18		}
16	19
17	20		func newHighlighter() *highlighter {

24	27		}
25	28		out := highlightCode(name, content)
26	29		h.cache[shortID] = out
	30	+	h.order = append(h.order, shortID)
	31	+	if len(h.order) > highlightCacheMax {
	32	+	drop := h.order[0]
	33	+	h.order = h.order[1:]
	34	+	delete(h.cache, drop)
	35	+	}
27	36		return out
28	37		}
29	38
30	39		func (h *highlighter) invalidate(shortID string) {
	40	+	if _, ok := h.cache[shortID]; !ok {
	41	+	return
	42	+	}
31	43		delete(h.cache, shortID)
	44	+	for i, k := range h.order {
	45	+	if k == shortID {
	46	+	h.order = append(h.order[:i], h.order[i+1:]...)
	47	+	break
	48	+	}
	49	+	}
32	50		}
33	51
34	52		func highlightCode(name, content string) string {

42	60		if lexer == nil {
43	61		lexer = lexers.Fallback
44	62		}
45		-	style := styles.Get("monokai")
	63	+	style := styles.Get("vim")
46	64		if style == nil {
47	65		style = styles.Fallback
48	66		}
49		-	formatter := formatters.Get("terminal256")
	67	+	formatter := formatters.Get("terminal16")
50	68		if formatter == nil {
51	69		formatter = formatters.Fallback
52	70		}