fix: Linter errors

Author: lazysegtree

plan.md

@@ -0,0 +1,331 @@
+# Plan: Make Zoxide Queries Async
+
+## Problem
+Currently, zoxide queries are synchronous and block the UI thread on every keystroke:
+- `updateSuggestions()` in `src/internal/ui/zoxide/model.go:109-135` calls `m.zClient.QueryAll()` directly
+- This happens in `handleNormalKeyInput()` which is called from `HandleUpdate()` on every key press
+- Causes UI lag when typing quickly or when zoxide has many entries
+
+## Solution Overview
+Follow the ProcessBar pattern: UI package defines its own message type, internal package wraps it in a `ModelUpdateMessage` implementation.
+
+## Architecture Pattern (from ProcessBar)
+
+ProcessBar demonstrates this pattern:
+1. `processbar.UpdateMsg` - message type in UI package with `Apply(m *Model)` method
+2. `ProcessBarUpdateMsg` - wrapper in internal package implementing `ModelUpdateMessage`
+3. `processCmdToTeaCmd()` - helper that wraps processbar.Cmd to return ProcessBarUpdateMsg
+4. Flow: processbar returns Cmd → wrapped → goroutine → processbar.UpdateMsg → wrapped in ProcessBarUpdateMsg → routed via ModelUpdateMessage
+
+## Detailed Implementation Steps
+
+### 1. Define Message Type in Zoxide Package
+
+**File:** `src/internal/ui/zoxide/type.go`
+
+Add new types after the `Model` struct:
+
+```go
+// Cmd is a function that returns an UpdateMsg
+type Cmd func() UpdateMsg
+
+// UpdateMsg represents an async query result
+type UpdateMsg struct {
+	query   string
+	results []zoxidelib.Result
+	reqID   int
+}
+
+func NewUpdateMsg(query string, results []zoxidelib.Result, reqID int) UpdateMsg {
+	return UpdateMsg{
+		query:   query,
+		results: results,
+		reqID:   reqID,
+	}
+}
+
+func (msg UpdateMsg) GetReqID() int {
+	return msg.reqID
+}
+```
+
+Add `Apply()` method in new file `src/internal/ui/zoxide/update.go`:
+
+```go
+package zoxide
+
+import "log/slog"
+
+// Apply updates the zoxide modal with query results
+func (msg UpdateMsg) Apply(m *Model) Cmd {
+	// Ignore stale results - only apply if query matches current input
+	currentQuery := m.textInput.Value()
+	if msg.query != currentQuery {
+		slog.Debug("Ignoring stale zoxide query result",
+			"msgQuery", msg.query,
+			"currentQuery", currentQuery,
+			"id", msg.reqID)
+		return nil
+	}
+
+	slog.Debug("Applying zoxide query results",
+		"query", msg.query,
+		"resultCount", len(msg.results),
+		"id", msg.reqID)
+
+	m.results = msg.results
+	m.cursor = 0
+	m.renderIndex = 0
+
+	return nil
+}
+```
+
+Add request counter to Model in `type.go`:
+
+```go
+type Model struct {
+	// ... existing fields ...
+
+	// Request tracking for async queries
+	reqCnt int
+}
+```
+
+### 2. Create Async Query Command
+
+**File:** `src/internal/ui/zoxide/model.go`
+
+Add method to generate async query command:
+
+```go
+func (m *Model) GetQueryCmd(query string) Cmd {
+	if m.zClient == nil || !common.Config.ZoxideSupport {
+		return nil
+	}
+
+	reqID := m.reqCnt
+	m.reqCnt++
+
+	slog.Debug("Submitting zoxide query request", "query", query, "id", reqID)
+
+	return func() UpdateMsg {
+		queryFields := strings.Fields(query)
+		results, err := m.zClient.QueryAll(queryFields...)
+		if err != nil {
+			slog.Debug("Zoxide query failed", "query", query, "error", err, "id", reqID)
+			return NewUpdateMsg(query, []zoxidelib.Result{}, reqID)
+		}
+		return NewUpdateMsg(query, results, reqID)
+	}
+}
+```
+
+### 3. Create Wrapper Message in Internal Package
+
+**File:** `src/internal/model_msg.go`
+
+Add after `NotifyModalUpdateMsg`:
+
+```go
+type ZoxideUpdateMsg struct {
+	BaseMessage
+
+	zMsg zoxide.UpdateMsg
+}
+
+func NewZoxideUpdateMsg(zMsg zoxide.UpdateMsg) ZoxideUpdateMsg {
+	return ZoxideUpdateMsg{
+		zMsg: zMsg,
+		BaseMessage: BaseMessage{
+			reqID: zMsg.GetReqID(),
+		},
+	}
+}
+
+func (msg ZoxideUpdateMsg) ApplyToModel(m *model) tea.Cmd {
+	cmd := msg.zMsg.Apply(&m.zoxideModal)
+	return zoxideCmdToTeaCmd(cmd)
+}
+```
+
+### 4. Create Command Wrapper Helper
+
+**File:** `src/internal/function.go`
+
+Add after `processCmdToTeaCmd()`:
+
+```go
+func zoxideCmdToTeaCmd(cmd zoxide.Cmd) tea.Cmd {
+	if cmd == nil {
+		return nil
+	}
+	return func() tea.Msg {
+		updateMsg := cmd()
+		return NewZoxideUpdateMsg(updateMsg)
+	}
+}
+```
+
+Add import:
+```go
+import (
+	// ... existing imports ...
+	zoxideui "github.com/yorukot/superfile/src/internal/ui/zoxide"
+)
+```
+
+Use alias `zoxideui` to avoid conflict with zoxidelib.
+
+### 5. Update Input Handling to Return Async Command
+
+**File:** `src/internal/ui/zoxide/model.go`
+
+Modify `handleNormalKeyInput()` method (around line 99-107):
+
+```go
+func (m *Model) handleNormalKeyInput(msg tea.KeyMsg) tea.Cmd {
+	var cmd tea.Cmd
+	m.textInput, cmd = m.textInput.Update(msg)
+
+	// Return async query command instead of blocking
+	return m.GetQueryCmd(m.textInput.Value())
+}
+```
+
+Remove the `updateSuggestions()` method entirely - no longer needed.
+
+Update `HandleUpdate()` to handle `UpdateMsg`:
+
+```go
+func (m *Model) HandleUpdate(msg tea.Msg) (common.ModelAction, tea.Cmd) {
+	slog.Debug("zoxide.Model HandleUpdate()", "msg", msg,
+		"textInput", m.textInput.Value(),
+		"cursorBlink", m.textInput.Cursor.Blink)
+	var action common.ModelAction
+	action = common.NoAction{}
+	var cmd tea.Cmd
+	if !m.IsOpen() {
+		slog.Error("HandleUpdate called on closed zoxide")
+		return action, cmd
+	}
+
+	switch msg := msg.(type) {
+	case UpdateMsg:
+		// Handle async query results
+		cmd = msg.Apply(m)
+		return action, cmd
+	case tea.KeyMsg:
+		// ... existing key handling ...
+	}
+	// ... rest of method
+}
+```
+
+### 6. Update Open() to Return Async Command
+
+**File:** `src/internal/ui/zoxide/utils.go`
+
+Change `Open()` signature and implementation:
+
+```go
+func (m *Model) Open() Cmd {
+	m.open = true
+	m.justOpened = true
+	m.textInput.SetValue("")
+	_ = m.textInput.Focus()
+
+	// Return async command for initial query instead of blocking
+	return m.GetQueryCmd("")
+}
+```
+
+### 7. Update Main Model to Wrap Zoxide Commands
+
+**File:** `src/internal/model.go`
+
+Update `handleKeyInput()` where zoxide modal is opened (around line 433):
+
+```go
+case m.zoxideModal.IsOpen():
+	var action common.ModelAction
+	action, cmd = m.zoxideModal.HandleUpdate(msg)
+	m.applyZoxideModalAction(action)
+	// Wrap zoxide cmd to convert to tea.Cmd
+	return zoxideCmdToTeaCmd(cmd)
+```
+
+**File:** `src/internal/key_function.go`
+
+Update where zoxide modal is opened (search for `OpenZoxide`):
+
+```go
+case slices.Contains(common.Hotkeys.OpenZoxide, keyPressed):
+	zCmd := m.zoxideModal.Open()
+	return zoxideCmdToTeaCmd(zCmd)
+```
+
+## Testing Strategy
+
+1. **Unit Tests** (`src/internal/ui/zoxide/model_test.go`)
+   - Test `GetQueryCmd()` returns correct UpdateMsg
+   - Test `Apply()` updates model state correctly
+   - Test stale query results are ignored
+   - Test request ID tracking
+
+2. **Integration Test** (manual with tmux)
+   ```bash
+   # Build and run
+   make build
+   tmux new-session -d -s spf_test
+   tmux send-keys -t spf_test "./bin/spf" Enter
+   sleep 1
+
+   # Open zoxide modal
+   tmux send-keys -t spf_test "z"
+   sleep 0.5
+
+   # Type quickly to test async behavior
+   tmux send-keys -t spf_test "home"
+
+   # Capture output to verify results appear
+   tmux capture-pane -t spf_test -p
+
+   # Cleanup
+   tmux send-keys -t spf_test "Escape"
+   tmux kill-session -t spf_test
+   ```
+
+3. **Performance Test**
+   - Verify no UI lag when typing quickly
+   - Test with large zoxide database (many entries)
+   - Verify stale results don't override newer ones
+
+## Edge Cases to Handle
+
+1. **Stale results**: Query for "home" completes after query for "homedir" - ignore old results
+2. **Modal closed**: Don't apply results if modal was closed while query was in flight
+3. **Nil client**: GetQueryCmd() should return nil if zClient is nil
+4. **Empty results**: Handle empty result sets gracefully
+
+## Files to Modify
+
+1. `src/internal/ui/zoxide/type.go` - Add UpdateMsg, Cmd types, reqCnt field
+2. `src/internal/ui/zoxide/update.go` - NEW FILE - Add Apply() method
+3. `src/internal/ui/zoxide/model.go` - Add GetQueryCmd(), modify handleNormalKeyInput(), remove updateSuggestions(), handle UpdateMsg in HandleUpdate()
+4. `src/internal/ui/zoxide/utils.go` - Change Open() to return Cmd
+5. `src/internal/model_msg.go` - Add ZoxideUpdateMsg wrapper
+6. `src/internal/function.go` - Add zoxideCmdToTeaCmd() helper
+7. `src/internal/model.go` - Wrap zoxide commands in handleKeyInput()
+8. `src/internal/key_function.go` - Wrap zoxide Open() command
+
+## Success Criteria
+
+- [ ] No blocking calls to QueryAll() in UI thread
+- [ ] Query results update asynchronously
+- [ ] Stale results are ignored
+- [ ] No UI lag when typing quickly
+- [ ] Unit tests pass: `go test ./src/internal/ui/zoxide/...`
+- [ ] All tests pass: `go test ./...`
+- [ ] Linter passes: `golangci-lint run`
+- [ ] Binary builds successfully: `CGO_ENABLED=0 go build -o ./bin/spf`