feat(tui): expand input to fit message

Author: adamdotdevin

README.md

@@ -98,7 +98,7 @@ You can configure custom keybinds, the values listed below are the defaults.
     "input_clear": "ctrl+c",
     "input_paste": "ctrl+v",
     "input_submit": "enter",
-    "input_newline": "shift+enter",
+    "input_newline": "shift+enter,ctrl+j",
     "history_previous": "up",
     "history_next": "down",
     "messages_page_up": "pgup",

packages/tui/internal/commands/command.go

@@ -208,18 +208,18 @@ func LoadFromConfig(config *client.ConfigInfo) CommandRegistry {
 		{
 			Name:        InputNewlineCommand,
 			Description: "insert newline",
-			Keybindings: parseBindings("shift+enter"),
-		},
-		{
-			Name:        HistoryPreviousCommand,
-			Description: "previous prompt",
-			Keybindings: parseBindings("up"),
-		},
-		{
-			Name:        HistoryNextCommand,
-			Description: "next prompt",
-			Keybindings: parseBindings("down"),
+			Keybindings: parseBindings("shift+enter", "ctrl+j"),
 		},
+		// {
+		// 	Name:        HistoryPreviousCommand,
+		// 	Description: "previous prompt",
+		// 	Keybindings: parseBindings("up"),
+		// },
+		// {
+		// 	Name:        HistoryNextCommand,
+		// 	Description: "next prompt",
+		// 	Keybindings: parseBindings("down"),
+		// },
 		{
 			Name:        MessagesPageUpCommand,
 			Description: "page up",

packages/tui/internal/components/chat/editor.go

@@ -6,12 +6,12 @@ import (
 	"strings"
 
 	"github.com/charmbracelet/bubbles/v2/spinner"
-	"github.com/charmbracelet/bubbles/v2/textarea"
 	tea "github.com/charmbracelet/bubbletea/v2"
 	"github.com/charmbracelet/lipgloss/v2"
 	"github.com/sst/opencode/internal/app"
 	"github.com/sst/opencode/internal/commands"
 	"github.com/sst/opencode/internal/components/dialog"
+	"github.com/sst/opencode/internal/components/textarea"
 	"github.com/sst/opencode/internal/image"
 	"github.com/sst/opencode/internal/layout"
 	"github.com/sst/opencode/internal/styles"
@@ -23,6 +23,8 @@ type EditorComponent interface {
 	tea.Model
 	tea.ViewModel
 	layout.Sizeable
+	Content() string
+	Lines() int
 	Value() string
 	Submit() (tea.Model, tea.Cmd)
 	Clear() (tea.Model, tea.Cmd)
@@ -50,33 +52,27 @@ func (m *editorComponent) Init() tea.Cmd {
 func (m *editorComponent) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	var cmds []tea.Cmd
 	var cmd tea.Cmd
+
 	switch msg := msg.(type) {
 	case tea.KeyPressMsg:
 		// Maximize editor responsiveness for printable characters
 		if msg.Text != "" {
 			m.textarea, cmd = m.textarea.Update(msg)
-			return m, cmd
+			cmds = append(cmds, cmd)
+			return m, tea.Batch(cmds...)
 		}
-
-		// // TODO: ?
-		// if key.Matches(msg, messageKeys.PageUp) ||
-		// 	key.Matches(msg, messageKeys.PageDown) ||
-		// 	key.Matches(msg, messageKeys.HalfPageUp) ||
-		// 	key.Matches(msg, messageKeys.HalfPageDown) {
-		// 	return m, nil
-		// }
-
 	case dialog.ThemeSelectedMsg:
 		m.textarea = createTextArea(&m.textarea)
 		m.spinner = createSpinner()
 		return m, tea.Batch(m.spinner.Tick, textarea.Blink)
 	case dialog.CompletionSelectedMsg:
 		if msg.IsCommand {
 			commandName := strings.TrimPrefix(msg.CompletionValue, "/")
-			m.textarea.Reset()
-			return m, util.CmdHandler(
-				commands.ExecuteCommandMsg(m.app.Commands[commands.CommandName(commandName)]),
-			)
+			updated, cmd := m.Clear()
+			m = updated.(*editorComponent)
+			cmds = append(cmds, cmd)
+			cmds = append(cmds, util.CmdHandler(commands.ExecuteCommandMsg(m.app.Commands[commands.CommandName(commandName)])))
+			return m, tea.Batch(cmds...)
 		} else {
 			existingValue := m.textarea.Value()
 			modifiedValue := strings.Replace(existingValue, msg.SearchString, msg.CompletionValue, 1)
@@ -94,7 +90,7 @@ func (m *editorComponent) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	return m, tea.Batch(cmds...)
 }
 
-func (m *editorComponent) View() string {
+func (m *editorComponent) Content() string {
 	t := theme.CurrentTheme()
 	base := styles.BaseStyle().Background(t.Background()).Render
 	muted := styles.Muted().Background(t.Background()).Render
@@ -139,25 +135,35 @@ func (m *editorComponent) View() string {
 	return content
 }
 
+func (m *editorComponent) View() string {
+	if m.Lines() > 1 {
+		return ""
+	}
+	return m.Content()
+}
+
 func (m *editorComponent) GetSize() (width, height int) {
 	return m.width, m.height
 }
 
 func (m *editorComponent) SetSize(width, height int) tea.Cmd {
 	m.width = width
 	m.height = height
-	m.textarea.SetWidth(width - 5)   // account for the prompt and padding right
-	m.textarea.SetHeight(height - 4) // account for info underneath
+	m.textarea.SetWidth(width - 5) // account for the prompt and padding right
+	// m.textarea.SetHeight(height - 4)
 	return nil
 }
 
+func (m *editorComponent) Lines() int {
+	return m.textarea.LineCount()
+}
+
 func (m *editorComponent) Value() string {
 	return m.textarea.Value()
 }
 
 func (m *editorComponent) Submit() (tea.Model, tea.Cmd) {
 	value := strings.TrimSpace(m.Value())
-	m.textarea.Reset()
 	if value == "" {
 		return m, nil
 	}
@@ -167,6 +173,11 @@ func (m *editorComponent) Submit() (tea.Model, tea.Cmd) {
 		return m, nil
 	}
 
+	var cmds []tea.Cmd
+	updated, cmd := m.Clear()
+	m = updated.(*editorComponent)
+	cmds = append(cmds, cmd)
+
 	attachments := m.attachments
 
 	// Save to history if not empty and not a duplicate of the last entry
@@ -180,12 +191,8 @@ func (m *editorComponent) Submit() (tea.Model, tea.Cmd) {
 
 	m.attachments = nil
 
-	return m, tea.Batch(
-		util.CmdHandler(app.SendMsg{
-			Text:        value,
-			Attachments: attachments,
-		}),
-	)
+	cmds = append(cmds, util.CmdHandler(app.SendMsg{Text: value, Attachments: attachments}))
+	return m, tea.Batch(cmds...)
 }
 
 func (m *editorComponent) Clear() (tea.Model, tea.Cmd) {

packages/tui/internal/components/dialog/complete.go

@@ -101,10 +101,10 @@ type completionDialogKeyMap struct {
 
 var completionDialogKeys = completionDialogKeyMap{
 	Complete: key.NewBinding(
-		key.WithKeys("tab", "enter"),
+		key.WithKeys("tab", "enter", "right"),
 	),
 	Cancel: key.NewBinding(
-		key.WithKeys(" ", "esc", "backspace"),
+		key.WithKeys(" ", "esc", "backspace", "ctrl+c"),
 	),
 }
 
@@ -209,7 +209,7 @@ func (c *completionDialogComponent) View() string {
 		BorderRight(true).
 		BorderLeft(true).
 		BorderBackground(t.Background()).
-		BorderForeground(t.BackgroundSubtle()).
+		BorderForeground(t.BackgroundElement()).
 		Width(c.width).
 		Render(c.list.View())
 }

packages/tui/internal/components/textarea/memoization.go

@@ -0,0 +1,125 @@
+// Package memoization implement a simple memoization cache. It's designed to
+// improve performance in textarea.
+package textarea
+
+import (
+	"container/list"
+	"crypto/sha256"
+	"fmt"
+	"sync"
+)
+
+// Hasher is an interface that requires a Hash method. The Hash method is
+// expected to return a string representation of the hash of the object.
+type Hasher interface {
+	Hash() string
+}
+
+// entry is a struct that holds a key-value pair. It is used as an element
+// in the evictionList of the MemoCache.
+type entry[T any] struct {
+	key   string
+	value T
+}
+
+// MemoCache is a struct that represents a cache with a set capacity. It
+// uses an LRU (Least Recently Used) eviction policy. It is safe for
+// concurrent use.
+type MemoCache[H Hasher, T any] struct {
+	capacity      int
+	mutex         sync.Mutex
+	cache         map[string]*list.Element // The cache holding the results
+	evictionList  *list.List               // A list to keep track of the order for LRU
+	hashableItems map[string]T             // This map keeps track of the original hashable items (optional)
+}
+
+// NewMemoCache is a function that creates a new MemoCache with a given
+// capacity. It returns a pointer to the created MemoCache.
+func NewMemoCache[H Hasher, T any](capacity int) *MemoCache[H, T] {
+	return &MemoCache[H, T]{
+		capacity:      capacity,
+		cache:         make(map[string]*list.Element),
+		evictionList:  list.New(),
+		hashableItems: make(map[string]T),
+	}
+}
+
+// Capacity is a method that returns the capacity of the MemoCache.
+func (m *MemoCache[H, T]) Capacity() int {
+	return m.capacity
+}
+
+// Size is a method that returns the current size of the MemoCache. It is
+// the number of items currently stored in the cache.
+func (m *MemoCache[H, T]) Size() int {
+	m.mutex.Lock()
+	defer m.mutex.Unlock()
+	return m.evictionList.Len()
+}
+
+// Get is a method that returns the value associated with the given
+// hashable item in the MemoCache. If there is no corresponding value, the
+// method returns nil.
+func (m *MemoCache[H, T]) Get(h H) (T, bool) {
+	m.mutex.Lock()
+	defer m.mutex.Unlock()
+
+	hashedKey := h.Hash()
+	if element, found := m.cache[hashedKey]; found {
+		m.evictionList.MoveToFront(element)
+		return element.Value.(*entry[T]).value, true
+	}
+	var result T
+	return result, false
+}
+
+// Set is a method that sets the value for the given hashable item in the
+// MemoCache. If the cache is at capacity, it evicts the least recently
+// used item before adding the new item.
+func (m *MemoCache[H, T]) Set(h H, value T) {
+	m.mutex.Lock()
+	defer m.mutex.Unlock()
+
+	hashedKey := h.Hash()
+	if element, found := m.cache[hashedKey]; found {
+		m.evictionList.MoveToFront(element)
+		element.Value.(*entry[T]).value = value
+		return
+	}
+
+	// Check if the cache is at capacity
+	if m.evictionList.Len() >= m.capacity {
+		// Evict the least recently used item from the cache
+		toEvict := m.evictionList.Back()
+		if toEvict != nil {
+			evictedEntry := m.evictionList.Remove(toEvict).(*entry[T])
+			delete(m.cache, evictedEntry.key)
+			delete(m.hashableItems, evictedEntry.key) // if you're keeping track of original items
+		}
+	}
+
+	// Add the value to the cache and the evictionList
+	newEntry := &entry[T]{
+		key:   hashedKey,
+		value: value,
+	}
+	element := m.evictionList.PushFront(newEntry)
+	m.cache[hashedKey] = element
+	m.hashableItems[hashedKey] = value // if you're keeping track of original items
+}
+
+// HString is a type that implements the Hasher interface for strings.
+type HString string
+
+// Hash is a method that returns the hash of the string.
+func (h HString) Hash() string {
+	return fmt.Sprintf("%x", sha256.Sum256([]byte(h)))
+}
+
+// HInt is a type that implements the Hasher interface for integers.
+type HInt int
+
+// Hash is a method that returns the hash of the integer.
+func (h HInt) Hash() string {
+	return fmt.Sprintf("%x", sha256.Sum256([]byte(fmt.Sprintf("%d", h))))
+}