Add files using upload-large-folder tool

projects/ui/crush/internal/home/home.go

@@ -0,0 +1,42 @@
+package home
+
+import (
+	"log/slog"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+)
+
+// Dir returns the users home directory, or if it fails, tries to create a new
+// temporary directory and use that instead.
+var Dir = sync.OnceValue(func() string {
+	home, err := os.UserHomeDir()
+	if err == nil {
+		slog.Debug("user home directory", "home", home)
+		return home
+	}
+	tmp, err := os.MkdirTemp("crush", "")
+	if err != nil {
+		slog.Error("could not find the user home directory")
+		return ""
+	}
+	slog.Warn("could not find the user home directory, using a temporary one", "home", tmp)
+	return tmp
+})
+
+// Short replaces the actual home path from [Dir] with `~`.
+func Short(p string) string {
+	if !strings.HasPrefix(p, Dir()) || Dir() == "" {
+		return p
+	}
+	return filepath.Join("~", strings.TrimPrefix(p, Dir()))
+}
+
+// Long replaces the `~` with actual home path from [Dir].
+func Long(p string) string {
+	if !strings.HasPrefix(p, "~") || Dir() == "" {
+		return p
+	}
+	return strings.Replace(p, "~", Dir(), 1)
+}

projects/ui/crush/internal/home/home_test.go

@@ -0,0 +1,26 @@
+package home
+
+import (
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestDir(t *testing.T) {
+	require.NotEmpty(t, Dir())
+}
+
+func TestShort(t *testing.T) {
+	d := filepath.Join(Dir(), "documents", "file.txt")
+	require.Equal(t, filepath.FromSlash("~/documents/file.txt"), Short(d))
+	ad := filepath.FromSlash("/absolute/path/file.txt")
+	require.Equal(t, ad, Short(ad))
+}
+
+func TestLong(t *testing.T) {
+	d := filepath.FromSlash("~/documents/file.txt")
+	require.Equal(t, filepath.Join(Dir(), "documents", "file.txt"), Long(d))
+	ad := filepath.FromSlash("/absolute/path/file.txt")
+	require.Equal(t, ad, Long(ad))
+}

projects/ui/crush/internal/log/http.go

@@ -0,0 +1,128 @@
+package log
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"io"
+	"log/slog"
+	"net/http"
+	"strings"
+	"time"
+)
+
+// NewHTTPClient creates an HTTP client with debug logging enabled when debug mode is on.
+func NewHTTPClient() *http.Client {
+	if !slog.Default().Enabled(context.TODO(), slog.LevelDebug) {
+		return http.DefaultClient
+	}
+	return &http.Client{
+		Transport: &HTTPRoundTripLogger{
+			Transport: http.DefaultTransport,
+		},
+	}
+}
+
+// HTTPRoundTripLogger is an http.RoundTripper that logs requests and responses.
+type HTTPRoundTripLogger struct {
+	Transport http.RoundTripper
+}
+
+// RoundTrip implements http.RoundTripper interface with logging.
+func (h *HTTPRoundTripLogger) RoundTrip(req *http.Request) (*http.Response, error) {
+	var err error
+	var save io.ReadCloser
+	save, req.Body, err = drainBody(req.Body)
+	if err != nil {
+		slog.Error(
+			"HTTP request failed",
+			"method", req.Method,
+			"url", req.URL,
+			"error", err,
+		)
+		return nil, err
+	}
+
+	slog.Debug(
+		"HTTP Request",
+		"method", req.Method,
+		"url", req.URL,
+		"body", bodyToString(save),
+	)
+
+	start := time.Now()
+	resp, err := h.Transport.RoundTrip(req)
+	duration := time.Since(start)
+	if err != nil {
+		slog.Error(
+			"HTTP request failed",
+			"method", req.Method,
+			"url", req.URL,
+			"duration_ms", duration.Milliseconds(),
+			"error", err,
+		)
+		return resp, err
+	}
+
+	save, resp.Body, err = drainBody(resp.Body)
+	slog.Debug(
+		"HTTP Response",
+		"status_code", resp.StatusCode,
+		"status", resp.Status,
+		"headers", formatHeaders(resp.Header),
+		"body", bodyToString(save),
+		"content_length", resp.ContentLength,
+		"duration_ms", duration.Milliseconds(),
+		"error", err,
+	)
+	return resp, err
+}
+
+func bodyToString(body io.ReadCloser) string {
+	if body == nil {
+		return ""
+	}
+	src, err := io.ReadAll(body)
+	if err != nil {
+		slog.Error("Failed to read body", "error", err)
+		return ""
+	}
+	var b bytes.Buffer
+	if json.Compact(&b, bytes.TrimSpace(src)) != nil {
+		// not json probably
+		return string(src)
+	}
+	return b.String()
+}
+
+// formatHeaders formats HTTP headers for logging, filtering out sensitive information.
+func formatHeaders(headers http.Header) map[string][]string {
+	filtered := make(map[string][]string)
+	for key, values := range headers {
+		lowerKey := strings.ToLower(key)
+		// Filter out sensitive headers
+		if strings.Contains(lowerKey, "authorization") ||
+			strings.Contains(lowerKey, "api-key") ||
+			strings.Contains(lowerKey, "token") ||
+			strings.Contains(lowerKey, "secret") {
+			filtered[key] = []string{"[REDACTED]"}
+		} else {
+			filtered[key] = values
+		}
+	}
+	return filtered
+}
+
+func drainBody(b io.ReadCloser) (r1, r2 io.ReadCloser, err error) {
+	if b == nil || b == http.NoBody {
+		return http.NoBody, http.NoBody, nil
+	}
+	var buf bytes.Buffer
+	if _, err = buf.ReadFrom(b); err != nil {
+		return nil, b, err
+	}
+	if err = b.Close(); err != nil {
+		return nil, b, err
+	}
+	return io.NopCloser(&buf), io.NopCloser(bytes.NewReader(buf.Bytes())), nil
+}

projects/ui/crush/internal/log/http_test.go

@@ -0,0 +1,73 @@
+package log
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+)
+
+func TestHTTPRoundTripLogger(t *testing.T) {
+	// Create a test server that returns a 500 error
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		w.Header().Set("X-Custom-Header", "test-value")
+		w.WriteHeader(http.StatusInternalServerError)
+		w.Write([]byte(`{"error": "Internal server error", "code": 500}`))
+	}))
+	defer server.Close()
+
+	// Create HTTP client with logging
+	client := NewHTTPClient()
+
+	// Make a request
+	req, err := http.NewRequestWithContext(
+		t.Context(),
+		http.MethodPost,
+		server.URL,
+		strings.NewReader(`{"test": "data"}`),
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", "Bearer secret-token")
+
+	resp, err := client.Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer resp.Body.Close()
+
+	// Verify response
+	if resp.StatusCode != http.StatusInternalServerError {
+		t.Errorf("Expected status code 500, got %d", resp.StatusCode)
+	}
+}
+
+func TestFormatHeaders(t *testing.T) {
+	headers := http.Header{
+		"Content-Type":  []string{"application/json"},
+		"Authorization": []string{"Bearer secret-token"},
+		"X-API-Key":     []string{"api-key-123"},
+		"User-Agent":    []string{"test-agent"},
+	}
+
+	formatted := formatHeaders(headers)
+
+	// Check that sensitive headers are redacted
+	if formatted["Authorization"][0] != "[REDACTED]" {
+		t.Error("Authorization header should be redacted")
+	}
+	if formatted["X-API-Key"][0] != "[REDACTED]" {
+		t.Error("X-API-Key header should be redacted")
+	}
+
+	// Check that non-sensitive headers are preserved
+	if formatted["Content-Type"][0] != "application/json" {
+		t.Error("Content-Type header should be preserved")
+	}
+	if formatted["User-Agent"][0] != "test-agent" {
+		t.Error("User-Agent header should be preserved")
+	}
+}

projects/ui/crush/internal/log/log.go

@@ -0,0 +1,70 @@
+package log
+
+import (
+	"fmt"
+	"log/slog"
+	"os"
+	"runtime/debug"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"gopkg.in/natefinch/lumberjack.v2"
+)
+
+var (
+	initOnce    sync.Once
+	initialized atomic.Bool
+)
+
+func Setup(logFile string, debug bool) {
+	initOnce.Do(func() {
+		logRotator := &lumberjack.Logger{
+			Filename:   logFile,
+			MaxSize:    10,    // Max size in MB
+			MaxBackups: 0,     // Number of backups
+			MaxAge:     30,    // Days
+			Compress:   false, // Enable compression
+		}
+
+		level := slog.LevelInfo
+		if debug {
+			level = slog.LevelDebug
+		}
+
+		logger := slog.NewJSONHandler(logRotator, &slog.HandlerOptions{
+			Level:     level,
+			AddSource: true,
+		})
+
+		slog.SetDefault(slog.New(logger))
+		initialized.Store(true)
+	})
+}
+
+func Initialized() bool {
+	return initialized.Load()
+}
+
+func RecoverPanic(name string, cleanup func()) {
+	if r := recover(); r != nil {
+		// Create a timestamped panic log file
+		timestamp := time.Now().Format("20060102-150405")
+		filename := fmt.Sprintf("crush-panic-%s-%s.log", name, timestamp)
+
+		file, err := os.Create(filename)
+		if err == nil {
+			defer file.Close()
+
+			// Write panic information and stack trace
+			fmt.Fprintf(file, "Panic in %s: %v\n\n", name, r)
+			fmt.Fprintf(file, "Time: %s\n\n", time.Now().Format(time.RFC3339))
+			fmt.Fprintf(file, "Stack Trace:\n%s\n", debug.Stack())
+
+			// Execute cleanup function if provided
+			if cleanup != nil {
+				cleanup()
+			}
+		}
+	}
+}

projects/ui/crush/internal/lsp/caps.go

@@ -0,0 +1,112 @@
+package lsp
+
+import "github.com/charmbracelet/crush/internal/lsp/protocol"
+
+func (c *Client) setCapabilities(caps protocol.ServerCapabilities) {
+	c.capsMu.Lock()
+	defer c.capsMu.Unlock()
+	c.caps = caps
+	c.capsSet.Store(true)
+}
+
+func (c *Client) getCapabilities() (protocol.ServerCapabilities, bool) {
+	c.capsMu.RLock()
+	defer c.capsMu.RUnlock()
+	return c.caps, c.capsSet.Load()
+}
+
+func (c *Client) IsMethodSupported(method string) bool {
+	// Always allow core lifecycle and generic methods
+	switch method {
+	case "initialize", "shutdown", "exit", "$/cancelRequest":
+		return true
+	}
+
+	caps, ok := c.getCapabilities()
+	if !ok {
+		// caps not set yet, be permissive
+		return true
+	}
+
+	switch method {
+	case "textDocument/hover":
+		return caps.HoverProvider != nil
+	case "textDocument/definition":
+		return caps.DefinitionProvider != nil
+	case "textDocument/references":
+		return caps.ReferencesProvider != nil
+	case "textDocument/implementation":
+		return caps.ImplementationProvider != nil
+	case "textDocument/typeDefinition":
+		return caps.TypeDefinitionProvider != nil
+	case "textDocument/documentColor", "textDocument/colorPresentation":
+		return caps.ColorProvider != nil
+	case "textDocument/foldingRange":
+		return caps.FoldingRangeProvider != nil
+	case "textDocument/declaration":
+		return caps.DeclarationProvider != nil
+	case "textDocument/selectionRange":
+		return caps.SelectionRangeProvider != nil
+	case "textDocument/prepareCallHierarchy", "callHierarchy/incomingCalls", "callHierarchy/outgoingCalls":
+		return caps.CallHierarchyProvider != nil
+	case "textDocument/semanticTokens/full", "textDocument/semanticTokens/full/delta", "textDocument/semanticTokens/range":
+		return caps.SemanticTokensProvider != nil
+	case "textDocument/linkedEditingRange":
+		return caps.LinkedEditingRangeProvider != nil
+	case "workspace/willCreateFiles":
+		return caps.Workspace != nil && caps.Workspace.FileOperations != nil && caps.Workspace.FileOperations.WillCreate != nil
+	case "workspace/willRenameFiles":
+		return caps.Workspace != nil && caps.Workspace.FileOperations != nil && caps.Workspace.FileOperations.WillRename != nil
+	case "workspace/willDeleteFiles":
+		return caps.Workspace != nil && caps.Workspace.FileOperations != nil && caps.Workspace.FileOperations.WillDelete != nil
+	case "textDocument/moniker":
+		return caps.MonikerProvider != nil
+	case "textDocument/prepareTypeHierarchy", "typeHierarchy/supertypes", "typeHierarchy/subtypes":
+		return caps.TypeHierarchyProvider != nil
+	case "textDocument/inlineValue":
+		return caps.InlineValueProvider != nil
+	case "textDocument/inlayHint", "inlayHint/resolve":
+		return caps.InlayHintProvider != nil
+	case "textDocument/diagnostic", "workspace/diagnostic":
+		return caps.DiagnosticProvider != nil
+	case "textDocument/inlineCompletion":
+		return caps.InlineCompletionProvider != nil
+	case "workspace/textDocumentContent":
+		return caps.Workspace != nil && caps.Workspace.TextDocumentContent != nil
+	case "textDocument/willSaveWaitUntil":
+		if caps.TextDocumentSync == nil {
+			return false
+		}
+		return true
+	case "textDocument/completion", "completionItem/resolve":
+		return caps.CompletionProvider != nil
+	case "textDocument/signatureHelp":
+		return caps.SignatureHelpProvider != nil
+	case "textDocument/documentHighlight":
+		return caps.DocumentHighlightProvider != nil
+	case "textDocument/documentSymbol":
+		return caps.DocumentSymbolProvider != nil
+	case "textDocument/codeAction", "codeAction/resolve":
+		return caps.CodeActionProvider != nil
+	case "workspace/symbol", "workspaceSymbol/resolve":
+		return caps.WorkspaceSymbolProvider != nil
+	case "textDocument/codeLens", "codeLens/resolve":
+		return caps.CodeLensProvider != nil
+	case "textDocument/documentLink", "documentLink/resolve":
+		return caps.DocumentLinkProvider != nil
+	case "textDocument/formatting":
+		return caps.DocumentFormattingProvider != nil
+	case "textDocument/rangeFormatting":
+		return caps.DocumentRangeFormattingProvider != nil
+	case "textDocument/rangesFormatting":
+		return caps.DocumentRangeFormattingProvider != nil
+	case "textDocument/onTypeFormatting":
+		return caps.DocumentOnTypeFormattingProvider != nil
+	case "textDocument/rename", "textDocument/prepareRename":
+		return caps.RenameProvider != nil
+	case "workspace/executeCommand":
+		return caps.ExecuteCommandProvider != nil
+	default:
+		return true
+	}
+}

projects/ui/crush/internal/lsp/client.go

@@ -0,0 +1,753 @@
+package lsp
+
+import (
+	"bufio"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log/slog"
+	"maps"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"slices"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/charmbracelet/crush/internal/config"
+	"github.com/charmbracelet/crush/internal/log"
+	"github.com/charmbracelet/crush/internal/lsp/protocol"
+)
+
+type Client struct {
+	Cmd    *exec.Cmd
+	stdin  io.WriteCloser
+	stdout *bufio.Reader
+	stderr io.ReadCloser
+
+	// Client name for identification
+	name string
+
+	// File types this LSP server handles (e.g., .go, .rs, .py)
+	fileTypes []string
+
+	// Diagnostic change callback
+	onDiagnosticsChanged func(name string, count int)
+
+	// Request ID counter
+	nextID atomic.Int32
+
+	// Response handlers
+	handlers   map[int32]chan *Message
+	handlersMu sync.RWMutex
+
+	// Server request handlers
+	serverRequestHandlers map[string]ServerRequestHandler
+	serverHandlersMu      sync.RWMutex
+
+	// Notification handlers
+	notificationHandlers map[string]NotificationHandler
+	notificationMu       sync.RWMutex
+
+	// Diagnostic cache
+	diagnostics   map[protocol.DocumentURI][]protocol.Diagnostic
+	diagnosticsMu sync.RWMutex
+
+	// Files are currently opened by the LSP
+	openFiles   map[string]*OpenFileInfo
+	openFilesMu sync.RWMutex
+
+	// Server state
+	serverState atomic.Value
+
+	// Server capabilities as returned by initialize
+	caps    protocol.ServerCapabilities
+	capsMu  sync.RWMutex
+	capsSet atomic.Bool
+}
+
+// NewClient creates a new LSP client.
+func NewClient(ctx context.Context, name string, config config.LSPConfig) (*Client, error) {
+	cmd := exec.CommandContext(ctx, config.Command, config.Args...)
+
+	// Copy env
+	cmd.Env = slices.Concat(os.Environ(), config.ResolvedEnv())
+
+	stdin, err := cmd.StdinPipe()
+	if err != nil {
+		return nil, fmt.Errorf("failed to create stdin pipe: %w", err)
+	}
+
+	stdout, err := cmd.StdoutPipe()
+	if err != nil {
+		return nil, fmt.Errorf("failed to create stdout pipe: %w", err)
+	}
+
+	stderr, err := cmd.StderrPipe()
+	if err != nil {
+		return nil, fmt.Errorf("failed to create stderr pipe: %w", err)
+	}
+
+	client := &Client{
+		Cmd:                   cmd,
+		name:                  name,
+		fileTypes:             config.FileTypes,
+		stdin:                 stdin,
+		stdout:                bufio.NewReader(stdout),
+		stderr:                stderr,
+		handlers:              make(map[int32]chan *Message),
+		notificationHandlers:  make(map[string]NotificationHandler),
+		serverRequestHandlers: make(map[string]ServerRequestHandler),
+		diagnostics:           make(map[protocol.DocumentURI][]protocol.Diagnostic),
+		openFiles:             make(map[string]*OpenFileInfo),
+	}
+
+	// Initialize server state
+	client.serverState.Store(StateStarting)
+
+	// Start the LSP server process
+	if err := cmd.Start(); err != nil {
+		return nil, fmt.Errorf("failed to start LSP server: %w", err)
+	}
+
+	// Handle stderr in a separate goroutine
+	go func() {
+		scanner := bufio.NewScanner(stderr)
+		for scanner.Scan() {
+			slog.Error("LSP Server", "err", scanner.Text())
+		}
+		if err := scanner.Err(); err != nil {
+			slog.Error("Error reading", "err", err)
+		}
+	}()
+
+	// Start message handling loop
+	go func() {
+		defer log.RecoverPanic("LSP-message-handler", func() {
+			slog.Error("LSP message handler crashed, LSP functionality may be impaired")
+		})
+		client.handleMessages()
+	}()
+
+	return client, nil
+}
+
+func (c *Client) RegisterNotificationHandler(method string, handler NotificationHandler) {
+	c.notificationMu.Lock()
+	defer c.notificationMu.Unlock()
+	c.notificationHandlers[method] = handler
+}
+
+func (c *Client) RegisterServerRequestHandler(method string, handler ServerRequestHandler) {
+	c.serverHandlersMu.Lock()
+	defer c.serverHandlersMu.Unlock()
+	c.serverRequestHandlers[method] = handler
+}
+
+func (c *Client) InitializeLSPClient(ctx context.Context, workspaceDir string) (*protocol.InitializeResult, error) {
+	initParams := protocol.ParamInitialize{
+		WorkspaceFoldersInitializeParams: protocol.WorkspaceFoldersInitializeParams{
+			WorkspaceFolders: []protocol.WorkspaceFolder{
+				{
+					URI:  protocol.URI(protocol.URIFromPath(workspaceDir)),
+					Name: workspaceDir,
+				},
+			},
+		},
+
+		XInitializeParams: protocol.XInitializeParams{
+			ProcessID: int32(os.Getpid()),
+			ClientInfo: &protocol.ClientInfo{
+				Name:    "mcp-language-server",
+				Version: "0.1.0",
+			},
+			RootPath: workspaceDir,
+			RootURI:  protocol.URIFromPath(workspaceDir),
+			Capabilities: protocol.ClientCapabilities{
+				Workspace: protocol.WorkspaceClientCapabilities{
+					Configuration: true,
+					DidChangeConfiguration: protocol.DidChangeConfigurationClientCapabilities{
+						DynamicRegistration: true,
+					},
+					DidChangeWatchedFiles: protocol.DidChangeWatchedFilesClientCapabilities{
+						DynamicRegistration:    true,
+						RelativePatternSupport: true,
+					},
+				},
+				TextDocument: protocol.TextDocumentClientCapabilities{
+					Synchronization: &protocol.TextDocumentSyncClientCapabilities{
+						DynamicRegistration: true,
+						DidSave:             true,
+					},
+					Completion: protocol.CompletionClientCapabilities{
+						CompletionItem: protocol.ClientCompletionItemOptions{},
+					},
+					CodeLens: &protocol.CodeLensClientCapabilities{
+						DynamicRegistration: true,
+					},
+					DocumentSymbol: protocol.DocumentSymbolClientCapabilities{},
+					CodeAction: protocol.CodeActionClientCapabilities{
+						CodeActionLiteralSupport: protocol.ClientCodeActionLiteralOptions{
+							CodeActionKind: protocol.ClientCodeActionKindOptions{
+								ValueSet: []protocol.CodeActionKind{},
+							},
+						},
+					},
+					PublishDiagnostics: protocol.PublishDiagnosticsClientCapabilities{
+						VersionSupport: true,
+					},
+					SemanticTokens: protocol.SemanticTokensClientCapabilities{
+						Requests: protocol.ClientSemanticTokensRequestOptions{
+							Range: &protocol.Or_ClientSemanticTokensRequestOptions_range{},
+							Full:  &protocol.Or_ClientSemanticTokensRequestOptions_full{},
+						},
+						TokenTypes:     []string{},
+						TokenModifiers: []string{},
+						Formats:        []protocol.TokenFormat{},
+					},
+				},
+				Window: protocol.WindowClientCapabilities{},
+			},
+			InitializationOptions: map[string]any{
+				"codelenses": map[string]bool{
+					"generate":           true,
+					"regenerate_cgo":     true,
+					"test":               true,
+					"tidy":               true,
+					"upgrade_dependency": true,
+					"vendor":             true,
+					"vulncheck":          false,
+				},
+			},
+		},
+	}
+
+	result, err := c.Initialize(ctx, initParams)
+	if err != nil {
+		return nil, fmt.Errorf("initialize failed: %w", err)
+	}
+
+	c.setCapabilities(result.Capabilities)
+
+	if err := c.Initialized(ctx, protocol.InitializedParams{}); err != nil {
+		return nil, fmt.Errorf("initialized notification failed: %w", err)
+	}
+
+	// Register handlers
+	c.RegisterServerRequestHandler("workspace/applyEdit", HandleApplyEdit)
+	c.RegisterServerRequestHandler("workspace/configuration", HandleWorkspaceConfiguration)
+	c.RegisterServerRequestHandler("client/registerCapability", HandleRegisterCapability)
+	c.RegisterNotificationHandler("window/showMessage", HandleServerMessage)
+	c.RegisterNotificationHandler("textDocument/publishDiagnostics", func(params json.RawMessage) {
+		HandleDiagnostics(c, params)
+	})
+
+	return &result, nil
+}
+
+func (c *Client) Close() error {
+	// Try to close all open files first
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	// Attempt to close files but continue shutdown regardless
+	c.CloseAllFiles(ctx)
+
+	// Close stdin to signal the server
+	if err := c.stdin.Close(); err != nil {
+		return fmt.Errorf("failed to close stdin: %w", err)
+	}
+
+	// Use a channel to handle the Wait with timeout
+	done := make(chan error, 1)
+	go func() {
+		done <- c.Cmd.Wait()
+	}()
+
+	// Wait for process to exit with timeout
+	select {
+	case err := <-done:
+		return err
+	case <-time.After(2 * time.Second):
+		// If we timeout, try to kill the process
+		if err := c.Cmd.Process.Kill(); err != nil {
+			return fmt.Errorf("failed to kill process: %w", err)
+		}
+		return fmt.Errorf("process killed after timeout")
+	}
+}
+
+type ServerState int
+
+const (
+	StateStarting ServerState = iota
+	StateReady
+	StateError
+)
+
+// GetServerState returns the current state of the LSP server
+func (c *Client) GetServerState() ServerState {
+	if val := c.serverState.Load(); val != nil {
+		return val.(ServerState)
+	}
+	return StateStarting
+}
+
+// SetServerState sets the current state of the LSP server
+func (c *Client) SetServerState(state ServerState) {
+	c.serverState.Store(state)
+}
+
+// GetName returns the name of the LSP client
+func (c *Client) GetName() string {
+	return c.name
+}
+
+// SetDiagnosticsCallback sets the callback function for diagnostic changes
+func (c *Client) SetDiagnosticsCallback(callback func(name string, count int)) {
+	c.onDiagnosticsChanged = callback
+}
+
+// WaitForServerReady waits for the server to be ready by polling the server
+// with a simple request until it responds successfully or times out
+func (c *Client) WaitForServerReady(ctx context.Context) error {
+	cfg := config.Get()
+
+	// Set initial state
+	c.SetServerState(StateStarting)
+
+	// Create a context with timeout
+	ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
+	defer cancel()
+
+	// Try to ping the server with a simple request
+	ticker := time.NewTicker(500 * time.Millisecond)
+	defer ticker.Stop()
+
+	if cfg.Options.DebugLSP {
+		slog.Debug("Waiting for LSP server to be ready...")
+	}
+
+	c.openKeyConfigFiles(ctx)
+
+	for {
+		select {
+		case <-ctx.Done():
+			c.SetServerState(StateError)
+			return fmt.Errorf("timeout waiting for LSP server to be ready")
+		case <-ticker.C:
+			// Try a ping method appropriate for this server type
+			if err := c.ping(ctx); err != nil {
+				if cfg.Options.DebugLSP {
+					slog.Debug("LSP server not ready yet", "error", err, "server", c.name)
+				}
+				continue
+			}
+
+			// Server responded successfully
+			c.SetServerState(StateReady)
+			if cfg.Options.DebugLSP {
+				slog.Debug("LSP server is ready")
+			}
+			return nil
+		}
+	}
+}
+
+// ServerType represents the type of LSP server
+type ServerType int
+
+const (
+	ServerTypeUnknown ServerType = iota
+	ServerTypeGo
+	ServerTypeTypeScript
+	ServerTypeRust
+	ServerTypePython
+	ServerTypeGeneric
+)
+
+// detectServerType tries to determine what type of LSP server we're dealing with
+func (c *Client) detectServerType() ServerType {
+	if c.Cmd == nil {
+		return ServerTypeUnknown
+	}
+
+	cmdPath := strings.ToLower(c.Cmd.Path)
+
+	switch {
+	case strings.Contains(cmdPath, "gopls"):
+		return ServerTypeGo
+	case strings.Contains(cmdPath, "typescript") || strings.Contains(cmdPath, "vtsls") || strings.Contains(cmdPath, "tsserver"):
+		return ServerTypeTypeScript
+	case strings.Contains(cmdPath, "rust-analyzer"):
+		return ServerTypeRust
+	case strings.Contains(cmdPath, "pyright") || strings.Contains(cmdPath, "pylsp") || strings.Contains(cmdPath, "python"):
+		return ServerTypePython
+	default:
+		return ServerTypeGeneric
+	}
+}
+
+// openKeyConfigFiles opens important configuration files that help initialize the server
+func (c *Client) openKeyConfigFiles(ctx context.Context) {
+	workDir := config.Get().WorkingDir()
+	serverType := c.detectServerType()
+
+	var filesToOpen []string
+
+	switch serverType {
+	case ServerTypeTypeScript:
+		// TypeScript servers need these config files to properly initialize
+		filesToOpen = []string{
+			filepath.Join(workDir, "tsconfig.json"),
+			filepath.Join(workDir, "package.json"),
+			filepath.Join(workDir, "jsconfig.json"),
+		}
+
+		// Also find and open a few TypeScript files to help the server initialize
+		c.openTypeScriptFiles(ctx, workDir)
+	case ServerTypeGo:
+		filesToOpen = []string{
+			filepath.Join(workDir, "go.mod"),
+			filepath.Join(workDir, "go.sum"),
+		}
+	case ServerTypeRust:
+		filesToOpen = []string{
+			filepath.Join(workDir, "Cargo.toml"),
+			filepath.Join(workDir, "Cargo.lock"),
+		}
+	}
+
+	// Try to open each file, ignoring errors if they don't exist
+	for _, file := range filesToOpen {
+		if _, err := os.Stat(file); err == nil {
+			// File exists, try to open it
+			if err := c.OpenFile(ctx, file); err != nil {
+				slog.Debug("Failed to open key config file", "file", file, "error", err)
+			} else {
+				slog.Debug("Opened key config file for initialization", "file", file)
+			}
+		}
+	}
+}
+
+// ping sends a ping request...
+func (c *Client) ping(ctx context.Context) error {
+	if _, err := c.Symbol(ctx, protocol.WorkspaceSymbolParams{}); err == nil {
+		return nil
+	}
+	// This is a very lightweight request that should work for most servers
+	return c.Notify(ctx, "$/cancelRequest", protocol.CancelParams{ID: "1"})
+}
+
+// openTypeScriptFiles finds and opens TypeScript files to help initialize the server
+func (c *Client) openTypeScriptFiles(ctx context.Context, workDir string) {
+	cfg := config.Get()
+	filesOpened := 0
+	maxFilesToOpen := 5 // Limit to a reasonable number of files
+
+	// Find and open TypeScript files
+	err := filepath.WalkDir(workDir, func(path string, d os.DirEntry, err error) error {
+		if err != nil {
+			return err
+		}
+
+		// Skip directories and non-TypeScript files
+		if d.IsDir() {
+			// Skip common directories to avoid wasting time
+			if shouldSkipDir(path) {
+				return filepath.SkipDir
+			}
+			return nil
+		}
+
+		// Check if we've opened enough files
+		if filesOpened >= maxFilesToOpen {
+			return filepath.SkipAll
+		}
+
+		// Check file extension
+		ext := filepath.Ext(path)
+		if ext == ".ts" || ext == ".tsx" || ext == ".js" || ext == ".jsx" {
+			// Try to open the file
+			if err := c.OpenFile(ctx, path); err == nil {
+				filesOpened++
+				if cfg.Options.DebugLSP {
+					slog.Debug("Opened TypeScript file for initialization", "file", path)
+				}
+			}
+		}
+
+		return nil
+	})
+
+	if err != nil && cfg.Options.DebugLSP {
+		slog.Debug("Error walking directory for TypeScript files", "error", err)
+	}
+
+	if cfg.Options.DebugLSP {
+		slog.Debug("Opened TypeScript files for initialization", "count", filesOpened)
+	}
+}
+
+// shouldSkipDir returns true if the directory should be skipped during file search
+func shouldSkipDir(path string) bool {
+	dirName := filepath.Base(path)
+
+	// Skip hidden directories
+	if strings.HasPrefix(dirName, ".") {
+		return true
+	}
+
+	// Skip common directories that won't contain relevant source files
+	skipDirs := map[string]bool{
+		"node_modules": true,
+		"dist":         true,
+		"build":        true,
+		"coverage":     true,
+		"vendor":       true,
+		"target":       true,
+	}
+
+	return skipDirs[dirName]
+}
+
+type OpenFileInfo struct {
+	Version int32
+	URI     protocol.DocumentURI
+}
+
+// HandlesFile checks if this LSP client handles the given file based on its
+// extension.
+func (c *Client) HandlesFile(path string) bool {
+	// If no file types are specified, handle all files (backward compatibility)
+	if len(c.fileTypes) == 0 {
+		return true
+	}
+
+	name := strings.ToLower(filepath.Base(path))
+	for _, filetpe := range c.fileTypes {
+		suffix := strings.ToLower(filetpe)
+		if !strings.HasPrefix(suffix, ".") {
+			suffix = "." + suffix
+		}
+		if strings.HasSuffix(name, suffix) {
+			slog.Debug("handles file", "name", c.name, "file", name, "filetype", filetpe)
+			return true
+		}
+	}
+	slog.Debug("doesn't handle file", "name", c.name, "file", name)
+	return false
+}
+
+func (c *Client) OpenFile(ctx context.Context, filepath string) error {
+	if !c.HandlesFile(filepath) {
+		return nil
+	}
+
+	uri := string(protocol.URIFromPath(filepath))
+
+	c.openFilesMu.Lock()
+	if _, exists := c.openFiles[uri]; exists {
+		c.openFilesMu.Unlock()
+		return nil // Already open
+	}
+	c.openFilesMu.Unlock()
+
+	// Skip files that do not exist or cannot be read
+	content, err := os.ReadFile(filepath)
+	if err != nil {
+		return fmt.Errorf("error reading file: %w", err)
+	}
+
+	params := protocol.DidOpenTextDocumentParams{
+		TextDocument: protocol.TextDocumentItem{
+			URI:        protocol.DocumentURI(uri),
+			LanguageID: DetectLanguageID(uri),
+			Version:    1,
+			Text:       string(content),
+		},
+	}
+
+	if err := c.DidOpen(ctx, params); err != nil {
+		return err
+	}
+
+	c.openFilesMu.Lock()
+	c.openFiles[uri] = &OpenFileInfo{
+		Version: 1,
+		URI:     protocol.DocumentURI(uri),
+	}
+	c.openFilesMu.Unlock()
+
+	return nil
+}
+
+func (c *Client) NotifyChange(ctx context.Context, filepath string) error {
+	uri := string(protocol.URIFromPath(filepath))
+
+	content, err := os.ReadFile(filepath)
+	if err != nil {
+		return fmt.Errorf("error reading file: %w", err)
+	}
+
+	c.openFilesMu.Lock()
+	fileInfo, isOpen := c.openFiles[uri]
+	if !isOpen {
+		c.openFilesMu.Unlock()
+		return fmt.Errorf("cannot notify change for unopened file: %s", filepath)
+	}
+
+	// Increment version
+	fileInfo.Version++
+	version := fileInfo.Version
+	c.openFilesMu.Unlock()
+
+	params := protocol.DidChangeTextDocumentParams{
+		TextDocument: protocol.VersionedTextDocumentIdentifier{
+			TextDocumentIdentifier: protocol.TextDocumentIdentifier{
+				URI: protocol.DocumentURI(uri),
+			},
+			Version: version,
+		},
+		ContentChanges: []protocol.TextDocumentContentChangeEvent{
+			{
+				Value: protocol.TextDocumentContentChangeWholeDocument{
+					Text: string(content),
+				},
+			},
+		},
+	}
+
+	return c.DidChange(ctx, params)
+}
+
+func (c *Client) CloseFile(ctx context.Context, filepath string) error {
+	cfg := config.Get()
+	uri := string(protocol.URIFromPath(filepath))
+
+	c.openFilesMu.Lock()
+	if _, exists := c.openFiles[uri]; !exists {
+		c.openFilesMu.Unlock()
+		return nil // Already closed
+	}
+	c.openFilesMu.Unlock()
+
+	params := protocol.DidCloseTextDocumentParams{
+		TextDocument: protocol.TextDocumentIdentifier{
+			URI: protocol.DocumentURI(uri),
+		},
+	}
+
+	if cfg.Options.DebugLSP {
+		slog.Debug("Closing file", "file", filepath)
+	}
+	if err := c.DidClose(ctx, params); err != nil {
+		return err
+	}
+
+	c.openFilesMu.Lock()
+	delete(c.openFiles, uri)
+	c.openFilesMu.Unlock()
+
+	return nil
+}
+
+func (c *Client) IsFileOpen(filepath string) bool {
+	uri := string(protocol.URIFromPath(filepath))
+	c.openFilesMu.RLock()
+	defer c.openFilesMu.RUnlock()
+	_, exists := c.openFiles[uri]
+	return exists
+}
+
+// CloseAllFiles closes all currently open files
+func (c *Client) CloseAllFiles(ctx context.Context) {
+	cfg := config.Get()
+	c.openFilesMu.Lock()
+	filesToClose := make([]string, 0, len(c.openFiles))
+
+	// First collect all URIs that need to be closed
+	for uri := range c.openFiles {
+		// Convert URI back to file path using proper URI handling
+		filePath, err := protocol.DocumentURI(uri).Path()
+		if err != nil {
+			slog.Error("Failed to convert URI to path for file closing", "uri", uri, "error", err)
+			continue
+		}
+		filesToClose = append(filesToClose, filePath)
+	}
+	c.openFilesMu.Unlock()
+
+	// Then close them all
+	for _, filePath := range filesToClose {
+		err := c.CloseFile(ctx, filePath)
+		if err != nil && cfg.Options.DebugLSP {
+			slog.Warn("Error closing file", "file", filePath, "error", err)
+		}
+	}
+
+	if cfg.Options.DebugLSP {
+		slog.Debug("Closed all files", "files", filesToClose)
+	}
+}
+
+func (c *Client) GetFileDiagnostics(uri protocol.DocumentURI) []protocol.Diagnostic {
+	c.diagnosticsMu.RLock()
+	defer c.diagnosticsMu.RUnlock()
+
+	return c.diagnostics[uri]
+}
+
+// GetDiagnostics returns all diagnostics for all files
+func (c *Client) GetDiagnostics() map[protocol.DocumentURI][]protocol.Diagnostic {
+	c.diagnosticsMu.RLock()
+	defer c.diagnosticsMu.RUnlock()
+
+	return maps.Clone(c.diagnostics)
+}
+
+// OpenFileOnDemand opens a file only if it's not already open
+// This is used for lazy-loading files when they're actually needed
+func (c *Client) OpenFileOnDemand(ctx context.Context, filepath string) error {
+	// Check if the file is already open
+	if c.IsFileOpen(filepath) {
+		return nil
+	}
+
+	// Open the file
+	return c.OpenFile(ctx, filepath)
+}
+
+// GetDiagnosticsForFile ensures a file is open and returns its diagnostics
+// This is useful for on-demand diagnostics when using lazy loading
+func (c *Client) GetDiagnosticsForFile(ctx context.Context, filepath string) ([]protocol.Diagnostic, error) {
+	documentURI := protocol.URIFromPath(filepath)
+
+	// Make sure the file is open
+	if !c.IsFileOpen(filepath) {
+		if err := c.OpenFile(ctx, filepath); err != nil {
+			return nil, fmt.Errorf("failed to open file for diagnostics: %w", err)
+		}
+
+		// Give the LSP server a moment to process the file
+		time.Sleep(100 * time.Millisecond)
+	}
+
+	// Get diagnostics
+	c.diagnosticsMu.RLock()
+	diagnostics := c.diagnostics[documentURI]
+	c.diagnosticsMu.RUnlock()
+
+	return diagnostics, nil
+}
+
+// ClearDiagnosticsForURI removes diagnostics for a specific URI from the cache
+func (c *Client) ClearDiagnosticsForURI(uri protocol.DocumentURI) {
+	c.diagnosticsMu.Lock()
+	defer c.diagnosticsMu.Unlock()
+	delete(c.diagnostics, uri)
+}

projects/ui/crush/internal/lsp/client_test.go

@@ -0,0 +1,93 @@
+package lsp
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestHandlesFile(t *testing.T) {
+	tests := []struct {
+		name      string
+		fileTypes []string
+		filepath  string
+		expected  bool
+	}{
+		{
+			name:      "no file types specified - handles all files",
+			fileTypes: nil,
+			filepath:  "test.go",
+			expected:  true,
+		},
+		{
+			name:      "empty file types - handles all files",
+			fileTypes: []string{},
+			filepath:  "test.go",
+			expected:  true,
+		},
+		{
+			name:      "matches .go extension",
+			fileTypes: []string{".go"},
+			filepath:  "main.go",
+			expected:  true,
+		},
+		{
+			name:      "matches go extension without dot",
+			fileTypes: []string{"go"},
+			filepath:  "main.go",
+			expected:  true,
+		},
+		{
+			name:      "matches one of multiple extensions",
+			fileTypes: []string{".js", ".ts", ".tsx"},
+			filepath:  "component.tsx",
+			expected:  true,
+		},
+		{
+			name:      "does not match extension",
+			fileTypes: []string{".go", ".rs"},
+			filepath:  "script.sh",
+			expected:  false,
+		},
+		{
+			name:      "matches with full path",
+			fileTypes: []string{".sh"},
+			filepath:  "/usr/local/bin/script.sh",
+			expected:  true,
+		},
+		{
+			name:      "case insensitive matching",
+			fileTypes: []string{".GO"},
+			filepath:  "main.go",
+			expected:  true,
+		},
+		{
+			name:      "bash file types",
+			fileTypes: []string{".sh", ".bash", ".zsh", ".ksh"},
+			filepath:  "script.sh",
+			expected:  true,
+		},
+		{
+			name:      "bash should not handle go files",
+			fileTypes: []string{".sh", ".bash", ".zsh", ".ksh"},
+			filepath:  "main.go",
+			expected:  false,
+		},
+		{
+			name:      "bash should not handle json files",
+			fileTypes: []string{".sh", ".bash", ".zsh", ".ksh"},
+			filepath:  "config.json",
+			expected:  false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			client := &Client{
+				fileTypes: tt.fileTypes,
+			}
+			result := client.HandlesFile(tt.filepath)
+			require.Equal(t, tt.expected, result)
+		})
+	}
+}

projects/ui/crush/internal/lsp/handlers.go

@@ -0,0 +1,119 @@
+package lsp
+
+import (
+	"encoding/json"
+	"log/slog"
+
+	"github.com/charmbracelet/crush/internal/config"
+
+	"github.com/charmbracelet/crush/internal/lsp/protocol"
+	"github.com/charmbracelet/crush/internal/lsp/util"
+)
+
+// Requests
+
+func HandleWorkspaceConfiguration(params json.RawMessage) (any, error) {
+	return []map[string]any{{}}, nil
+}
+
+func HandleRegisterCapability(params json.RawMessage) (any, error) {
+	var registerParams protocol.RegistrationParams
+	if err := json.Unmarshal(params, &registerParams); err != nil {
+		slog.Error("Error unmarshaling registration params", "error", err)
+		return nil, err
+	}
+
+	for _, reg := range registerParams.Registrations {
+		switch reg.Method {
+		case "workspace/didChangeWatchedFiles":
+			// Parse the registration options
+			optionsJSON, err := json.Marshal(reg.RegisterOptions)
+			if err != nil {
+				slog.Error("Error marshaling registration options", "error", err)
+				continue
+			}
+
+			var options protocol.DidChangeWatchedFilesRegistrationOptions
+			if err := json.Unmarshal(optionsJSON, &options); err != nil {
+				slog.Error("Error unmarshaling registration options", "error", err)
+				continue
+			}
+
+			// Store the file watchers registrations
+			notifyFileWatchRegistration(reg.ID, options.Watchers)
+		}
+	}
+
+	return nil, nil
+}
+
+func HandleApplyEdit(params json.RawMessage) (any, error) {
+	var edit protocol.ApplyWorkspaceEditParams
+	if err := json.Unmarshal(params, &edit); err != nil {
+		return nil, err
+	}
+
+	err := util.ApplyWorkspaceEdit(edit.Edit)
+	if err != nil {
+		slog.Error("Error applying workspace edit", "error", err)
+		return protocol.ApplyWorkspaceEditResult{Applied: false, FailureReason: err.Error()}, nil
+	}
+
+	return protocol.ApplyWorkspaceEditResult{Applied: true}, nil
+}
+
+// FileWatchRegistrationHandler is a function that will be called when file watch registrations are received
+type FileWatchRegistrationHandler func(id string, watchers []protocol.FileSystemWatcher)
+
+// fileWatchHandler holds the current handler for file watch registrations
+var fileWatchHandler FileWatchRegistrationHandler
+
+// RegisterFileWatchHandler sets the handler for file watch registrations
+func RegisterFileWatchHandler(handler FileWatchRegistrationHandler) {
+	fileWatchHandler = handler
+}
+
+// notifyFileWatchRegistration notifies the handler about new file watch registrations
+func notifyFileWatchRegistration(id string, watchers []protocol.FileSystemWatcher) {
+	if fileWatchHandler != nil {
+		fileWatchHandler(id, watchers)
+	}
+}
+
+// Notifications
+
+func HandleServerMessage(params json.RawMessage) {
+	cfg := config.Get()
+	var msg struct {
+		Type    int    `json:"type"`
+		Message string `json:"message"`
+	}
+	if err := json.Unmarshal(params, &msg); err == nil {
+		if cfg.Options.DebugLSP {
+			slog.Debug("Server message", "type", msg.Type, "message", msg.Message)
+		}
+	}
+}
+
+func HandleDiagnostics(client *Client, params json.RawMessage) {
+	var diagParams protocol.PublishDiagnosticsParams
+	if err := json.Unmarshal(params, &diagParams); err != nil {
+		slog.Error("Error unmarshaling diagnostics params", "error", err)
+		return
+	}
+
+	client.diagnosticsMu.Lock()
+	client.diagnostics[diagParams.URI] = diagParams.Diagnostics
+
+	// Calculate total diagnostic count
+	totalCount := 0
+	for _, diagnostics := range client.diagnostics {
+		totalCount += len(diagnostics)
+	}
+	client.diagnosticsMu.Unlock()
+
+	// Trigger callback if set
+	if client.onDiagnosticsChanged != nil {
+		client.onDiagnosticsChanged(client.name, totalCount)
+	}
+}

projects/ui/crush/internal/lsp/language.go

@@ -0,0 +1,132 @@
+package lsp
+
+import (
+	"path/filepath"
+	"strings"
+
+	"github.com/charmbracelet/crush/internal/lsp/protocol"
+)
+
+func DetectLanguageID(uri string) protocol.LanguageKind {
+	ext := strings.ToLower(filepath.Ext(uri))
+	switch ext {
+	case ".abap":
+		return protocol.LangABAP
+	case ".bat":
+		return protocol.LangWindowsBat
+	case ".bib", ".bibtex":
+		return protocol.LangBibTeX
+	case ".clj":
+		return protocol.LangClojure
+	case ".coffee":
+		return protocol.LangCoffeescript
+	case ".c":
+		return protocol.LangC
+	case ".cpp", ".cxx", ".cc", ".c++":
+		return protocol.LangCPP
+	case ".cs":
+		return protocol.LangCSharp
+	case ".css":
+		return protocol.LangCSS
+	case ".d":
+		return protocol.LangD
+	case ".pas", ".pascal":
+		return protocol.LangDelphi
+	case ".diff", ".patch":
+		return protocol.LangDiff
+	case ".dart":
+		return protocol.LangDart
+	case ".dockerfile":
+		return protocol.LangDockerfile
+	case ".ex", ".exs":
+		return protocol.LangElixir
+	case ".erl", ".hrl":
+		return protocol.LangErlang
+	case ".fs", ".fsi", ".fsx", ".fsscript":
+		return protocol.LangFSharp
+	case ".gitcommit":
+		return protocol.LangGitCommit
+	case ".gitrebase":
+		return protocol.LangGitRebase
+	case ".go":
+		return protocol.LangGo
+	case ".groovy":
+		return protocol.LangGroovy
+	case ".hbs", ".handlebars":
+		return protocol.LangHandlebars
+	case ".hs":
+		return protocol.LangHaskell
+	case ".html", ".htm":
+		return protocol.LangHTML
+	case ".ini":
+		return protocol.LangIni
+	case ".java":
+		return protocol.LangJava
+	case ".js":
+		return protocol.LangJavaScript
+	case ".jsx":
+		return protocol.LangJavaScriptReact
+	case ".json":
+		return protocol.LangJSON
+	case ".tex", ".latex":
+		return protocol.LangLaTeX
+	case ".less":
+		return protocol.LangLess
+	case ".lua":
+		return protocol.LangLua
+	case ".makefile", "makefile":
+		return protocol.LangMakefile
+	case ".md", ".markdown":
+		return protocol.LangMarkdown
+	case ".m":
+		return protocol.LangObjectiveC
+	case ".mm":
+		return protocol.LangObjectiveCPP
+	case ".pl":
+		return protocol.LangPerl
+	case ".pm":
+		return protocol.LangPerl6
+	case ".php":
+		return protocol.LangPHP
+	case ".ps1", ".psm1":
+		return protocol.LangPowershell
+	case ".pug", ".jade":
+		return protocol.LangPug
+	case ".py":
+		return protocol.LangPython
+	case ".r":
+		return protocol.LangR
+	case ".cshtml", ".razor":
+		return protocol.LangRazor
+	case ".rb":
+		return protocol.LangRuby
+	case ".rs":
+		return protocol.LangRust
+	case ".scss":
+		return protocol.LangSCSS
+	case ".sass":
+		return protocol.LangSASS
+	case ".scala":
+		return protocol.LangScala
+	case ".shader":
+		return protocol.LangShaderLab
+	case ".sh", ".bash", ".zsh", ".ksh":
+		return protocol.LangShellScript
+	case ".sql":
+		return protocol.LangSQL
+	case ".swift":
+		return protocol.LangSwift
+	case ".ts":
+		return protocol.LangTypeScript
+	case ".tsx":
+		return protocol.LangTypeScriptReact
+	case ".xml":
+		return protocol.LangXML
+	case ".xsl":
+		return protocol.LangXSL
+	case ".yaml", ".yml":
+		return protocol.LangYAML
+	default:
+		return protocol.LanguageKind("") // Unknown language
+	}
+}

projects/ui/crush/internal/lsp/methods.go

@@ -0,0 +1,554 @@
+// Generated code. Do not edit
+package lsp
+
+import (
+	"context"
+
+	"github.com/charmbracelet/crush/internal/lsp/protocol"
+)
+
+// Implementation sends a textDocument/implementation request to the LSP server.
+// A request to resolve the implementation locations of a symbol at a given text document position. The request's parameter is of type TextDocumentPositionParams the response is of type Definition or a Thenable that resolves to such.
+func (c *Client) Implementation(ctx context.Context, params protocol.ImplementationParams) (protocol.Or_Result_textDocument_implementation, error) {
+	var result protocol.Or_Result_textDocument_implementation
+	err := c.Call(ctx, "textDocument/implementation", params, &result)
+	return result, err
+}
+
+// TypeDefinition sends a textDocument/typeDefinition request to the LSP server.
+// A request to resolve the type definition locations of a symbol at a given text document position. The request's parameter is of type TextDocumentPositionParams the response is of type Definition or a Thenable that resolves to such.
+func (c *Client) TypeDefinition(ctx context.Context, params protocol.TypeDefinitionParams) (protocol.Or_Result_textDocument_typeDefinition, error) {
+	var result protocol.Or_Result_textDocument_typeDefinition
+	err := c.Call(ctx, "textDocument/typeDefinition", params, &result)
+	return result, err
+}
+
+// DocumentColor sends a textDocument/documentColor request to the LSP server.
+// A request to list all color symbols found in a given text document. The request's parameter is of type DocumentColorParams the response is of type ColorInformation ColorInformation[] or a Thenable that resolves to such.
+func (c *Client) DocumentColor(ctx context.Context, params protocol.DocumentColorParams) ([]protocol.ColorInformation, error) {
+	var result []protocol.ColorInformation
+	err := c.Call(ctx, "textDocument/documentColor", params, &result)
+	return result, err
+}
+
+// ColorPresentation sends a textDocument/colorPresentation request to the LSP server.
+// A request to list all presentation for a color. The request's parameter is of type ColorPresentationParams the response is of type ColorInformation ColorInformation[] or a Thenable that resolves to such.
+func (c *Client) ColorPresentation(ctx context.Context, params protocol.ColorPresentationParams) ([]protocol.ColorPresentation, error) {
+	var result []protocol.ColorPresentation
+	err := c.Call(ctx, "textDocument/colorPresentation", params, &result)
+	return result, err
+}
+
+// FoldingRange sends a textDocument/foldingRange request to the LSP server.
+// A request to provide folding ranges in a document. The request's parameter is of type FoldingRangeParams, the response is of type FoldingRangeList or a Thenable that resolves to such.
+func (c *Client) FoldingRange(ctx context.Context, params protocol.FoldingRangeParams) ([]protocol.FoldingRange, error) {
+	var result []protocol.FoldingRange
+	err := c.Call(ctx, "textDocument/foldingRange", params, &result)
+	return result, err
+}
+
+// Declaration sends a textDocument/declaration request to the LSP server.
+// A request to resolve the type definition locations of a symbol at a given text document position. The request's parameter is of type TextDocumentPositionParams the response is of type Declaration or a typed array of DeclarationLink or a Thenable that resolves to such.
+func (c *Client) Declaration(ctx context.Context, params protocol.DeclarationParams) (protocol.Or_Result_textDocument_declaration, error) {
+	var result protocol.Or_Result_textDocument_declaration
+	err := c.Call(ctx, "textDocument/declaration", params, &result)
+	return result, err
+}
+
+// SelectionRange sends a textDocument/selectionRange request to the LSP server.
+// A request to provide selection ranges in a document. The request's parameter is of type SelectionRangeParams, the response is of type SelectionRange SelectionRange[] or a Thenable that resolves to such.
+func (c *Client) SelectionRange(ctx context.Context, params protocol.SelectionRangeParams) ([]protocol.SelectionRange, error) {
+	var result []protocol.SelectionRange
+	err := c.Call(ctx, "textDocument/selectionRange", params, &result)
+	return result, err
+}
+
+// PrepareCallHierarchy sends a textDocument/prepareCallHierarchy request to the LSP server.
+// A request to result a CallHierarchyItem in a document at a given position. Can be used as an input to an incoming or outgoing call hierarchy. Since 3.16.0
+func (c *Client) PrepareCallHierarchy(ctx context.Context, params protocol.CallHierarchyPrepareParams) ([]protocol.CallHierarchyItem, error) {
+	var result []protocol.CallHierarchyItem
+	err := c.Call(ctx, "textDocument/prepareCallHierarchy", params, &result)
+	return result, err
+}
+
+// IncomingCalls sends a callHierarchy/incomingCalls request to the LSP server.
+// A request to resolve the incoming calls for a given CallHierarchyItem. Since 3.16.0
+func (c *Client) IncomingCalls(ctx context.Context, params protocol.CallHierarchyIncomingCallsParams) ([]protocol.CallHierarchyIncomingCall, error) {
+	var result []protocol.CallHierarchyIncomingCall
+	err := c.Call(ctx, "callHierarchy/incomingCalls", params, &result)
+	return result, err
+}
+
+// OutgoingCalls sends a callHierarchy/outgoingCalls request to the LSP server.
+// A request to resolve the outgoing calls for a given CallHierarchyItem. Since 3.16.0
+func (c *Client) OutgoingCalls(ctx context.Context, params protocol.CallHierarchyOutgoingCallsParams) ([]protocol.CallHierarchyOutgoingCall, error) {
+	var result []protocol.CallHierarchyOutgoingCall
+	err := c.Call(ctx, "callHierarchy/outgoingCalls", params, &result)
+	return result, err
+}
+
+// SemanticTokensFull sends a textDocument/semanticTokens/full request to the LSP server.
+// Since 3.16.0
+func (c *Client) SemanticTokensFull(ctx context.Context, params protocol.SemanticTokensParams) (protocol.SemanticTokens, error) {
+	var result protocol.SemanticTokens
+	err := c.Call(ctx, "textDocument/semanticTokens/full", params, &result)
+	return result, err
+}
+
+// SemanticTokensFullDelta sends a textDocument/semanticTokens/full/delta request to the LSP server.
+// Since 3.16.0
+func (c *Client) SemanticTokensFullDelta(ctx context.Context, params protocol.SemanticTokensDeltaParams) (protocol.Or_Result_textDocument_semanticTokens_full_delta, error) {
+	var result protocol.Or_Result_textDocument_semanticTokens_full_delta
+	err := c.Call(ctx, "textDocument/semanticTokens/full/delta", params, &result)
+	return result, err
+}
+
+// SemanticTokensRange sends a textDocument/semanticTokens/range request to the LSP server.
+// Since 3.16.0
+func (c *Client) SemanticTokensRange(ctx context.Context, params protocol.SemanticTokensRangeParams) (protocol.SemanticTokens, error) {
+	var result protocol.SemanticTokens
+	err := c.Call(ctx, "textDocument/semanticTokens/range", params, &result)
+	return result, err
+}
+
+// LinkedEditingRange sends a textDocument/linkedEditingRange request to the LSP server.
+// A request to provide ranges that can be edited together. Since 3.16.0
+func (c *Client) LinkedEditingRange(ctx context.Context, params protocol.LinkedEditingRangeParams) (protocol.LinkedEditingRanges, error) {
+	var result protocol.LinkedEditingRanges
+	err := c.Call(ctx, "textDocument/linkedEditingRange", params, &result)
+	return result, err
+}
+
+// WillCreateFiles sends a workspace/willCreateFiles request to the LSP server.
+// The will create files request is sent from the client to the server before files are actually created as long as the creation is triggered from within the client. The request can return a WorkspaceEdit which will be applied to workspace before the files are created. Hence the WorkspaceEdit can not manipulate the content of the file to be created. Since 3.16.0
+func (c *Client) WillCreateFiles(ctx context.Context, params protocol.CreateFilesParams) (protocol.WorkspaceEdit, error) {
+	var result protocol.WorkspaceEdit
+	err := c.Call(ctx, "workspace/willCreateFiles", params, &result)
+	return result, err
+}
+
+// WillRenameFiles sends a workspace/willRenameFiles request to the LSP server.
+// The will rename files request is sent from the client to the server before files are actually renamed as long as the rename is triggered from within the client. Since 3.16.0
+func (c *Client) WillRenameFiles(ctx context.Context, params protocol.RenameFilesParams) (protocol.WorkspaceEdit, error) {
+	var result protocol.WorkspaceEdit
+	err := c.Call(ctx, "workspace/willRenameFiles", params, &result)
+	return result, err
+}
+
+// WillDeleteFiles sends a workspace/willDeleteFiles request to the LSP server.
+// The did delete files notification is sent from the client to the server when files were deleted from within the client. Since 3.16.0
+func (c *Client) WillDeleteFiles(ctx context.Context, params protocol.DeleteFilesParams) (protocol.WorkspaceEdit, error) {
+	var result protocol.WorkspaceEdit
+	err := c.Call(ctx, "workspace/willDeleteFiles", params, &result)
+	return result, err
+}
+
+// Moniker sends a textDocument/moniker request to the LSP server.
+// A request to get the moniker of a symbol at a given text document position. The request parameter is of type TextDocumentPositionParams. The response is of type Moniker Moniker[] or null.
+func (c *Client) Moniker(ctx context.Context, params protocol.MonikerParams) ([]protocol.Moniker, error) {
+	var result []protocol.Moniker
+	err := c.Call(ctx, "textDocument/moniker", params, &result)
+	return result, err
+}
+
+// PrepareTypeHierarchy sends a textDocument/prepareTypeHierarchy request to the LSP server.
+// A request to result a TypeHierarchyItem in a document at a given position. Can be used as an input to a subtypes or supertypes type hierarchy. Since 3.17.0
+func (c *Client) PrepareTypeHierarchy(ctx context.Context, params protocol.TypeHierarchyPrepareParams) ([]protocol.TypeHierarchyItem, error) {
+	var result []protocol.TypeHierarchyItem
+	err := c.Call(ctx, "textDocument/prepareTypeHierarchy", params, &result)
+	return result, err
+}
+
+// Supertypes sends a typeHierarchy/supertypes request to the LSP server.
+// A request to resolve the supertypes for a given TypeHierarchyItem. Since 3.17.0
+func (c *Client) Supertypes(ctx context.Context, params protocol.TypeHierarchySupertypesParams) ([]protocol.TypeHierarchyItem, error) {
+	var result []protocol.TypeHierarchyItem
+	err := c.Call(ctx, "typeHierarchy/supertypes", params, &result)
+	return result, err
+}
+
+// Subtypes sends a typeHierarchy/subtypes request to the LSP server.
+// A request to resolve the subtypes for a given TypeHierarchyItem. Since 3.17.0
+func (c *Client) Subtypes(ctx context.Context, params protocol.TypeHierarchySubtypesParams) ([]protocol.TypeHierarchyItem, error) {
+	var result []protocol.TypeHierarchyItem
+	err := c.Call(ctx, "typeHierarchy/subtypes", params, &result)
+	return result, err
+}
+
+// InlineValue sends a textDocument/inlineValue request to the LSP server.
+// A request to provide inline values in a document. The request's parameter is of type InlineValueParams, the response is of type InlineValue InlineValue[] or a Thenable that resolves to such. Since 3.17.0
+func (c *Client) InlineValue(ctx context.Context, params protocol.InlineValueParams) ([]protocol.InlineValue, error) {
+	var result []protocol.InlineValue
+	err := c.Call(ctx, "textDocument/inlineValue", params, &result)
+	return result, err
+}
+
+// InlayHint sends a textDocument/inlayHint request to the LSP server.
+// A request to provide inlay hints in a document. The request's parameter is of type InlayHintsParams, the response is of type InlayHint InlayHint[] or a Thenable that resolves to such. Since 3.17.0
+func (c *Client) InlayHint(ctx context.Context, params protocol.InlayHintParams) ([]protocol.InlayHint, error) {
+	var result []protocol.InlayHint
+	err := c.Call(ctx, "textDocument/inlayHint", params, &result)
+	return result, err
+}
+
+// Resolve sends a inlayHint/resolve request to the LSP server.
+// A request to resolve additional properties for an inlay hint. The request's parameter is of type InlayHint, the response is of type InlayHint or a Thenable that resolves to such. Since 3.17.0
+func (c *Client) Resolve(ctx context.Context, params protocol.InlayHint) (protocol.InlayHint, error) {
+	var result protocol.InlayHint
+	err := c.Call(ctx, "inlayHint/resolve", params, &result)
+	return result, err
+}
+
+// Diagnostic sends a textDocument/diagnostic request to the LSP server.
+// The document diagnostic request definition. Since 3.17.0
+func (c *Client) Diagnostic(ctx context.Context, params protocol.DocumentDiagnosticParams) (protocol.DocumentDiagnosticReport, error) {
+	var result protocol.DocumentDiagnosticReport
+	err := c.Call(ctx, "textDocument/diagnostic", params, &result)
+	return result, err
+}
+
+// DiagnosticWorkspace sends a workspace/diagnostic request to the LSP server.
+// The workspace diagnostic request definition. Since 3.17.0
+func (c *Client) DiagnosticWorkspace(ctx context.Context, params protocol.WorkspaceDiagnosticParams) (protocol.WorkspaceDiagnosticReport, error) {
+	var result protocol.WorkspaceDiagnosticReport
+	err := c.Call(ctx, "workspace/diagnostic", params, &result)
+	return result, err
+}
+
+// InlineCompletion sends a textDocument/inlineCompletion request to the LSP server.
+// A request to provide inline completions in a document. The request's parameter is of type InlineCompletionParams, the response is of type InlineCompletion InlineCompletion[] or a Thenable that resolves to such. Since 3.18.0 PROPOSED
+func (c *Client) InlineCompletion(ctx context.Context, params protocol.InlineCompletionParams) (protocol.Or_Result_textDocument_inlineCompletion, error) {
+	var result protocol.Or_Result_textDocument_inlineCompletion
+	err := c.Call(ctx, "textDocument/inlineCompletion", params, &result)
+	return result, err
+}
+
+// TextDocumentContent sends a workspace/textDocumentContent request to the LSP server.
+// The workspace/textDocumentContent request is sent from the client to the server to request the content of a text document. Since 3.18.0 PROPOSED
+func (c *Client) TextDocumentContent(ctx context.Context, params protocol.TextDocumentContentParams) (string, error) {
+	var result string
+	err := c.Call(ctx, "workspace/textDocumentContent", params, &result)
+	return result, err
+}
+
+// Initialize sends a initialize request to the LSP server.
+// The initialize request is sent from the client to the server. It is sent once as the request after starting up the server. The requests parameter is of type InitializeParams the response if of type InitializeResult of a Thenable that resolves to such.
+func (c *Client) Initialize(ctx context.Context, params protocol.ParamInitialize) (protocol.InitializeResult, error) {
+	var result protocol.InitializeResult
+	err := c.Call(ctx, "initialize", params, &result)
+	return result, err
+}
+
+// Shutdown sends a shutdown request to the LSP server.
+// A shutdown request is sent from the client to the server. It is sent once when the client decides to shutdown the server. The only notification that is sent after a shutdown request is the exit event.
+func (c *Client) Shutdown(ctx context.Context) error {
+	return c.Call(ctx, "shutdown", nil, nil)
+}
+
+// WillSaveWaitUntil sends a textDocument/willSaveWaitUntil request to the LSP server.
+// A document will save request is sent from the client to the server before the document is actually saved. The request can return an array of TextEdits which will be applied to the text document before it is saved. Please note that clients might drop results if computing the text edits took too long or if a server constantly fails on this request. This is done to keep the save fast and reliable.
+func (c *Client) WillSaveWaitUntil(ctx context.Context, params protocol.WillSaveTextDocumentParams) ([]protocol.TextEdit, error) {
+	var result []protocol.TextEdit
+	err := c.Call(ctx, "textDocument/willSaveWaitUntil", params, &result)
+	return result, err
+}
+
+// Completion sends a textDocument/completion request to the LSP server.
+// Request to request completion at a given text document position. The request's parameter is of type TextDocumentPosition the response is of type CompletionItem CompletionItem[] or CompletionList or a Thenable that resolves to such. The request can delay the computation of the CompletionItem.detail detail and CompletionItem.documentation documentation properties to the completionItem/resolve request. However, properties that are needed for the initial sorting and filtering, like sortText, filterText, insertText, and textEdit, must not be changed during resolve.
+func (c *Client) Completion(ctx context.Context, params protocol.CompletionParams) (protocol.Or_Result_textDocument_completion, error) {
+	var result protocol.Or_Result_textDocument_completion
+	err := c.Call(ctx, "textDocument/completion", params, &result)
+	return result, err
+}
+
+// ResolveCompletionItem sends a completionItem/resolve request to the LSP server.
+// Request to resolve additional information for a given completion item.The request's parameter is of type CompletionItem the response is of type CompletionItem or a Thenable that resolves to such.
+func (c *Client) ResolveCompletionItem(ctx context.Context, params protocol.CompletionItem) (protocol.CompletionItem, error) {
+	var result protocol.CompletionItem
+	err := c.Call(ctx, "completionItem/resolve", params, &result)
+	return result, err
+}
+
+// Hover sends a textDocument/hover request to the LSP server.
+// Request to request hover information at a given text document position. The request's parameter is of type TextDocumentPosition the response is of type Hover or a Thenable that resolves to such.
+func (c *Client) Hover(ctx context.Context, params protocol.HoverParams) (protocol.Hover, error) {
+	var result protocol.Hover
+	err := c.Call(ctx, "textDocument/hover", params, &result)
+	return result, err
+}
+
+// SignatureHelp sends a textDocument/signatureHelp request to the LSP server.
+func (c *Client) SignatureHelp(ctx context.Context, params protocol.SignatureHelpParams) (protocol.SignatureHelp, error) {
+	var result protocol.SignatureHelp
+	err := c.Call(ctx, "textDocument/signatureHelp", params, &result)
+	return result, err
+}
+
+// Definition sends a textDocument/definition request to the LSP server.
+// A request to resolve the definition location of a symbol at a given text document position. The request's parameter is of type TextDocumentPosition the response is of either type Definition or a typed array of DefinitionLink or a Thenable that resolves to such.
+func (c *Client) Definition(ctx context.Context, params protocol.DefinitionParams) (protocol.Or_Result_textDocument_definition, error) {
+	var result protocol.Or_Result_textDocument_definition
+	err := c.Call(ctx, "textDocument/definition", params, &result)
+	return result, err
+}
+
+// References sends a textDocument/references request to the LSP server.
+// A request to resolve project-wide references for the symbol denoted by the given text document position. The request's parameter is of type ReferenceParams the response is of type Location Location[] or a Thenable that resolves to such.
+func (c *Client) References(ctx context.Context, params protocol.ReferenceParams) ([]protocol.Location, error) {
+	var result []protocol.Location
+	err := c.Call(ctx, "textDocument/references", params, &result)
+	return result, err
+}
+
+// DocumentHighlight sends a textDocument/documentHighlight request to the LSP server.
+// Request to resolve a DocumentHighlight for a given text document position. The request's parameter is of type TextDocumentPosition the request response is an array of type DocumentHighlight or a Thenable that resolves to such.
+func (c *Client) DocumentHighlight(ctx context.Context, params protocol.DocumentHighlightParams) ([]protocol.DocumentHighlight, error) {
+	var result []protocol.DocumentHighlight
+	err := c.Call(ctx, "textDocument/documentHighlight", params, &result)
+	return result, err
+}
+
+// DocumentSymbol sends a textDocument/documentSymbol request to the LSP server.
+// A request to list all symbols found in a given text document. The request's parameter is of type TextDocumentIdentifier the response is of type SymbolInformation SymbolInformation[] or a Thenable that resolves to such.
+func (c *Client) DocumentSymbol(ctx context.Context, params protocol.DocumentSymbolParams) (protocol.Or_Result_textDocument_documentSymbol, error) {
+	var result protocol.Or_Result_textDocument_documentSymbol
+	err := c.Call(ctx, "textDocument/documentSymbol", params, &result)
+	return result, err
+}
+
+// CodeAction sends a textDocument/codeAction request to the LSP server.
+// A request to provide commands for the given text document and range.
+func (c *Client) CodeAction(ctx context.Context, params protocol.CodeActionParams) ([]protocol.Or_Result_textDocument_codeAction_Item0_Elem, error) {
+	var result []protocol.Or_Result_textDocument_codeAction_Item0_Elem
+	err := c.Call(ctx, "textDocument/codeAction", params, &result)
+	return result, err
+}
+
+// ResolveCodeAction sends a codeAction/resolve request to the LSP server.
+// Request to resolve additional information for a given code action.The request's parameter is of type CodeAction the response is of type CodeAction or a Thenable that resolves to such.
+func (c *Client) ResolveCodeAction(ctx context.Context, params protocol.CodeAction) (protocol.CodeAction, error) {
+	var result protocol.CodeAction
+	err := c.Call(ctx, "codeAction/resolve", params, &result)
+	return result, err
+}
+
+// Symbol sends a workspace/symbol request to the LSP server.
+// A request to list project-wide symbols matching the query string given by the WorkspaceSymbolParams. The response is of type SymbolInformation SymbolInformation[] or a Thenable that resolves to such. Since 3.17.0 - support for WorkspaceSymbol in the returned data. Clients need to advertise support for WorkspaceSymbols via the client capability workspace.symbol.resolveSupport.
+func (c *Client) Symbol(ctx context.Context, params protocol.WorkspaceSymbolParams) (protocol.Or_Result_workspace_symbol, error) {
+	var result protocol.Or_Result_workspace_symbol
+	err := c.Call(ctx, "workspace/symbol", params, &result)
+	return result, err
+}
+
+// ResolveWorkspaceSymbol sends a workspaceSymbol/resolve request to the LSP server.
+// A request to resolve the range inside the workspace symbol's location. Since 3.17.0
+func (c *Client) ResolveWorkspaceSymbol(ctx context.Context, params protocol.WorkspaceSymbol) (protocol.WorkspaceSymbol, error) {
+	var result protocol.WorkspaceSymbol
+	err := c.Call(ctx, "workspaceSymbol/resolve", params, &result)
+	return result, err
+}
+
+// CodeLens sends a textDocument/codeLens request to the LSP server.
+// A request to provide code lens for the given text document.
+func (c *Client) CodeLens(ctx context.Context, params protocol.CodeLensParams) ([]protocol.CodeLens, error) {
+	var result []protocol.CodeLens
+	err := c.Call(ctx, "textDocument/codeLens", params, &result)
+	return result, err
+}
+
+// ResolveCodeLens sends a codeLens/resolve request to the LSP server.
+// A request to resolve a command for a given code lens.
+func (c *Client) ResolveCodeLens(ctx context.Context, params protocol.CodeLens) (protocol.CodeLens, error) {
+	var result protocol.CodeLens
+	err := c.Call(ctx, "codeLens/resolve", params, &result)
+	return result, err
+}
+
+// DocumentLink sends a textDocument/documentLink request to the LSP server.
+// A request to provide document links
+func (c *Client) DocumentLink(ctx context.Context, params protocol.DocumentLinkParams) ([]protocol.DocumentLink, error) {
+	var result []protocol.DocumentLink
+	err := c.Call(ctx, "textDocument/documentLink", params, &result)
+	return result, err
+}
+
+// ResolveDocumentLink sends a documentLink/resolve request to the LSP server.
+// Request to resolve additional information for a given document link. The request's parameter is of type DocumentLink the response is of type DocumentLink or a Thenable that resolves to such.
+func (c *Client) ResolveDocumentLink(ctx context.Context, params protocol.DocumentLink) (protocol.DocumentLink, error) {
+	var result protocol.DocumentLink
+	err := c.Call(ctx, "documentLink/resolve", params, &result)
+	return result, err
+}
+
+// Formatting sends a textDocument/formatting request to the LSP server.
+// A request to format a whole document.
+func (c *Client) Formatting(ctx context.Context, params protocol.DocumentFormattingParams) ([]protocol.TextEdit, error) {
+	var result []protocol.TextEdit
+	err := c.Call(ctx, "textDocument/formatting", params, &result)
+	return result, err
+}
+
+// RangeFormatting sends a textDocument/rangeFormatting request to the LSP server.
+// A request to format a range in a document.
+func (c *Client) RangeFormatting(ctx context.Context, params protocol.DocumentRangeFormattingParams) ([]protocol.TextEdit, error) {
+	var result []protocol.TextEdit
+	err := c.Call(ctx, "textDocument/rangeFormatting", params, &result)
+	return result, err
+}
+
+// RangesFormatting sends a textDocument/rangesFormatting request to the LSP server.
+// A request to format ranges in a document. Since 3.18.0 PROPOSED
+func (c *Client) RangesFormatting(ctx context.Context, params protocol.DocumentRangesFormattingParams) ([]protocol.TextEdit, error) {
+	var result []protocol.TextEdit
+	err := c.Call(ctx, "textDocument/rangesFormatting", params, &result)
+	return result, err
+}
+
+// OnTypeFormatting sends a textDocument/onTypeFormatting request to the LSP server.
+// A request to format a document on type.
+func (c *Client) OnTypeFormatting(ctx context.Context, params protocol.DocumentOnTypeFormattingParams) ([]protocol.TextEdit, error) {
+	var result []protocol.TextEdit
+	err := c.Call(ctx, "textDocument/onTypeFormatting", params, &result)
+	return result, err
+}
+
+// Rename sends a textDocument/rename request to the LSP server.
+// A request to rename a symbol.
+func (c *Client) Rename(ctx context.Context, params protocol.RenameParams) (protocol.WorkspaceEdit, error) {
+	var result protocol.WorkspaceEdit
+	err := c.Call(ctx, "textDocument/rename", params, &result)
+	return result, err
+}
+
+// PrepareRename sends a textDocument/prepareRename request to the LSP server.
+// A request to test and perform the setup necessary for a rename. Since 3.16 - support for default behavior
+func (c *Client) PrepareRename(ctx context.Context, params protocol.PrepareRenameParams) (protocol.PrepareRenameResult, error) {
+	var result protocol.PrepareRenameResult
+	err := c.Call(ctx, "textDocument/prepareRename", params, &result)
+	return result, err
+}
+
+// ExecuteCommand sends a workspace/executeCommand request to the LSP server.
+// A request send from the client to the server to execute a command. The request might return a workspace edit which the client will apply to the workspace.
+func (c *Client) ExecuteCommand(ctx context.Context, params protocol.ExecuteCommandParams) (any, error) {
+	var result any
+	err := c.Call(ctx, "workspace/executeCommand", params, &result)
+	return result, err
+}
+
+// DidChangeWorkspaceFolders sends a workspace/didChangeWorkspaceFolders notification to the LSP server.
+// The workspace/didChangeWorkspaceFolders notification is sent from the client to the server when the workspace folder configuration changes.
+func (c *Client) DidChangeWorkspaceFolders(ctx context.Context, params protocol.DidChangeWorkspaceFoldersParams) error {
+	return c.Notify(ctx, "workspace/didChangeWorkspaceFolders", params)
+}
+
+// WorkDoneProgressCancel sends a window/workDoneProgress/cancel notification to the LSP server.
+// The window/workDoneProgress/cancel notification is sent from  the client to the server to cancel a progress initiated on the server side.
+func (c *Client) WorkDoneProgressCancel(ctx context.Context, params protocol.WorkDoneProgressCancelParams) error {
+	return c.Notify(ctx, "window/workDoneProgress/cancel", params)
+}
+
+// DidCreateFiles sends a workspace/didCreateFiles notification to the LSP server.
+// The did create files notification is sent from the client to the server when files were created from within the client. Since 3.16.0
+func (c *Client) DidCreateFiles(ctx context.Context, params protocol.CreateFilesParams) error {
+	return c.Notify(ctx, "workspace/didCreateFiles", params)
+}
+
+// DidRenameFiles sends a workspace/didRenameFiles notification to the LSP server.
+// The did rename files notification is sent from the client to the server when files were renamed from within the client. Since 3.16.0
+func (c *Client) DidRenameFiles(ctx context.Context, params protocol.RenameFilesParams) error {
+	return c.Notify(ctx, "workspace/didRenameFiles", params)
+}
+
+// DidDeleteFiles sends a workspace/didDeleteFiles notification to the LSP server.
+// The will delete files request is sent from the client to the server before files are actually deleted as long as the deletion is triggered from within the client. Since 3.16.0
+func (c *Client) DidDeleteFiles(ctx context.Context, params protocol.DeleteFilesParams) error {
+	return c.Notify(ctx, "workspace/didDeleteFiles", params)
+}
+
+// DidOpenNotebookDocument sends a notebookDocument/didOpen notification to the LSP server.
+// A notification sent when a notebook opens. Since 3.17.0
+func (c *Client) DidOpenNotebookDocument(ctx context.Context, params protocol.DidOpenNotebookDocumentParams) error {
+	return c.Notify(ctx, "notebookDocument/didOpen", params)
+}
+
+// DidChangeNotebookDocument sends a notebookDocument/didChange notification to the LSP server.
+func (c *Client) DidChangeNotebookDocument(ctx context.Context, params protocol.DidChangeNotebookDocumentParams) error {
+	return c.Notify(ctx, "notebookDocument/didChange", params)
+}
+
+// DidSaveNotebookDocument sends a notebookDocument/didSave notification to the LSP server.
+// A notification sent when a notebook document is saved. Since 3.17.0
+func (c *Client) DidSaveNotebookDocument(ctx context.Context, params protocol.DidSaveNotebookDocumentParams) error {
+	return c.Notify(ctx, "notebookDocument/didSave", params)
+}
+
+// DidCloseNotebookDocument sends a notebookDocument/didClose notification to the LSP server.
+// A notification sent when a notebook closes. Since 3.17.0
+func (c *Client) DidCloseNotebookDocument(ctx context.Context, params protocol.DidCloseNotebookDocumentParams) error {
+	return c.Notify(ctx, "notebookDocument/didClose", params)
+}
+
+// Initialized sends a initialized notification to the LSP server.
+// The initialized notification is sent from the client to the server after the client is fully initialized and the server is allowed to send requests from the server to the client.
+func (c *Client) Initialized(ctx context.Context, params protocol.InitializedParams) error {
+	return c.Notify(ctx, "initialized", params)
+}
+
+// Exit sends a exit notification to the LSP server.
+// The exit event is sent from the client to the server to ask the server to exit its process.
+func (c *Client) Exit(ctx context.Context) error {
+	return c.Notify(ctx, "exit", nil)
+}
+
+// DidChangeConfiguration sends a workspace/didChangeConfiguration notification to the LSP server.
+// The configuration change notification is sent from the client to the server when the client's configuration has changed. The notification contains the changed configuration as defined by the language client.
+func (c *Client) DidChangeConfiguration(ctx context.Context, params protocol.DidChangeConfigurationParams) error {
+	return c.Notify(ctx, "workspace/didChangeConfiguration", params)
+}
+
+// DidOpen sends a textDocument/didOpen notification to the LSP server.
+// The document open notification is sent from the client to the server to signal newly opened text documents. The document's truth is now managed by the client and the server must not try to read the document's truth using the document's uri. Open in this sense means it is managed by the client. It doesn't necessarily mean that its content is presented in an editor. An open notification must not be sent more than once without a corresponding close notification send before. This means open and close notification must be balanced and the max open count is one.
+func (c *Client) DidOpen(ctx context.Context, params protocol.DidOpenTextDocumentParams) error {
+	return c.Notify(ctx, "textDocument/didOpen", params)
+}
+
+// DidChange sends a textDocument/didChange notification to the LSP server.
+// The document change notification is sent from the client to the server to signal changes to a text document.
+func (c *Client) DidChange(ctx context.Context, params protocol.DidChangeTextDocumentParams) error {
+	return c.Notify(ctx, "textDocument/didChange", params)
+}
+
+// DidClose sends a textDocument/didClose notification to the LSP server.
+// The document close notification is sent from the client to the server when the document got closed in the client. The document's truth now exists where the document's uri points to (e.g. if the document's uri is a file uri the truth now exists on disk). As with the open notification the close notification is about managing the document's content. Receiving a close notification doesn't mean that the document was open in an editor before. A close notification requires a previous open notification to be sent.
+func (c *Client) DidClose(ctx context.Context, params protocol.DidCloseTextDocumentParams) error {
+	return c.Notify(ctx, "textDocument/didClose", params)
+}
+
+// DidSave sends a textDocument/didSave notification to the LSP server.
+// The document save notification is sent from the client to the server when the document got saved in the client.
+func (c *Client) DidSave(ctx context.Context, params protocol.DidSaveTextDocumentParams) error {
+	return c.Notify(ctx, "textDocument/didSave", params)
+}
+
+// WillSave sends a textDocument/willSave notification to the LSP server.
+// A document will save notification is sent from the client to the server before the document is actually saved.
+func (c *Client) WillSave(ctx context.Context, params protocol.WillSaveTextDocumentParams) error {
+	return c.Notify(ctx, "textDocument/willSave", params)
+}
+
+// DidChangeWatchedFiles sends a workspace/didChangeWatchedFiles notification to the LSP server.
+// The watched files notification is sent from the client to the server when the client detects changes to file watched by the language client.
+func (c *Client) DidChangeWatchedFiles(ctx context.Context, params protocol.DidChangeWatchedFilesParams) error {
+	return c.Notify(ctx, "workspace/didChangeWatchedFiles", params)
+}
+
+// SetTrace sends a $/setTrace notification to the LSP server.
+func (c *Client) SetTrace(ctx context.Context, params protocol.SetTraceParams) error {
+	return c.Notify(ctx, "$/setTrace", params)
+}
+
+// Progress sends a $/progress notification to the LSP server.
+func (c *Client) Progress(ctx context.Context, params protocol.ProgressParams) error {
+	return c.Notify(ctx, "$/progress", params)
+}

projects/ui/crush/internal/lsp/protocol.go

@@ -0,0 +1,48 @@
+package lsp
+
+import (
+	"encoding/json"
+)
+
+// Message represents a JSON-RPC 2.0 message
+type Message struct {
+	JSONRPC string          `json:"jsonrpc"`
+	ID      int32           `json:"id,omitempty"`
+	Method  string          `json:"method,omitempty"`
+	Params  json.RawMessage `json:"params,omitempty"`
+	Result  json.RawMessage `json:"result,omitempty"`
+	Error   *ResponseError  `json:"error,omitempty"`
+}
+
+// ResponseError represents a JSON-RPC 2.0 error
+type ResponseError struct {
+	Code    int    `json:"code"`
+	Message string `json:"message"`
+}
+
+func NewRequest(id int32, method string, params any) (*Message, error) {
+	paramsJSON, err := json.Marshal(params)
+	if err != nil {
+		return nil, err
+	}
+
+	return &Message{
+		JSONRPC: "2.0",
+		ID:      id,
+		Method:  method,
+		Params:  paramsJSON,
+	}, nil
+}
+
+func NewNotification(method string, params any) (*Message, error) {
+	paramsJSON, err := json.Marshal(params)
+	if err != nil {
+		return nil, err
+	}
+
+	return &Message{
+		JSONRPC: "2.0",
+		Method:  method,
+		Params:  paramsJSON,
+	}, nil
+}

projects/ui/crush/internal/lsp/transport.go

@@ -0,0 +1,284 @@
+package lsp
+
+import (
+	"bufio"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log/slog"
+	"strings"
+
+	"github.com/charmbracelet/crush/internal/config"
+)
+
+// WriteMessage writes an LSP message to the given writer
+func WriteMessage(w io.Writer, msg *Message) error {
+	data, err := json.Marshal(msg)
+	if err != nil {
+		return fmt.Errorf("failed to marshal message: %w", err)
+	}
+	cfg := config.Get()
+
+	if cfg.Options.DebugLSP {
+		slog.Debug("Sending message to server", "method", msg.Method, "id", msg.ID)
+	}
+
+	_, err = fmt.Fprintf(w, "Content-Length: %d\r\n\r\n", len(data))
+	if err != nil {
+		return fmt.Errorf("failed to write header: %w", err)
+	}
+
+	_, err = w.Write(data)
+	if err != nil {
+		return fmt.Errorf("failed to write message: %w", err)
+	}
+
+	return nil
+}
+
+// ReadMessage reads a single LSP message from the given reader
+func ReadMessage(r *bufio.Reader) (*Message, error) {
+	cfg := config.Get()
+	// Read headers
+	var contentLength int
+	for {
+		line, err := r.ReadString('\n')
+		if err != nil {
+			return nil, fmt.Errorf("failed to read header: %w", err)
+		}
+		line = strings.TrimSpace(line)
+
+		if cfg.Options.DebugLSP {
+			slog.Debug("Received header", "line", line)
+		}
+
+		if line == "" {
+			break // End of headers
+		}
+
+		if strings.HasPrefix(line, "Content-Length: ") {
+			_, err := fmt.Sscanf(line, "Content-Length: %d", &contentLength)
+			if err != nil {
+				return nil, fmt.Errorf("invalid Content-Length: %w", err)
+			}
+		}
+	}
+
+	if cfg.Options.DebugLSP {
+		slog.Debug("Content-Length", "length", contentLength)
+	}
+
+	// Read content
+	content := make([]byte, contentLength)
+	_, err := io.ReadFull(r, content)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read content: %w", err)
+	}
+
+	if cfg.Options.DebugLSP {
+		slog.Debug("Received content", "content", string(content))
+	}
+
+	// Parse message
+	var msg Message
+	if err := json.Unmarshal(content, &msg); err != nil {
+		return nil, fmt.Errorf("failed to unmarshal message: %w", err)
+	}
+
+	return &msg, nil
+}
+
+// handleMessages reads and dispatches messages in a loop
+func (c *Client) handleMessages() {
+	cfg := config.Get()
+	for {
+		msg, err := ReadMessage(c.stdout)
+		if err != nil {
+			if cfg.Options.DebugLSP {
+				slog.Error("Error reading message", "error", err)
+			}
+			return
+		}
+
+		// Handle server->client request (has both Method and ID)
+		if msg.Method != "" && msg.ID != 0 {
+			if cfg.Options.DebugLSP {
+				slog.Debug("Received request from server", "method", msg.Method, "id", msg.ID)
+			}
+
+			response := &Message{
+				JSONRPC: "2.0",
+				ID:      msg.ID,
+			}
+
+			// Look up handler for this method
+			c.serverHandlersMu.RLock()
+			handler, ok := c.serverRequestHandlers[msg.Method]
+			c.serverHandlersMu.RUnlock()
+
+			if ok {
+				result, err := handler(msg.Params)
+				if err != nil {
+					response.Error = &ResponseError{
+						Code:    -32603,
+						Message: err.Error(),
+					}
+				} else {
+					rawJSON, err := json.Marshal(result)
+					if err != nil {
+						response.Error = &ResponseError{
+							Code:    -32603,
+							Message: fmt.Sprintf("failed to marshal response: %v", err),
+						}
+					} else {
+						response.Result = rawJSON
+					}
+				}
+			} else {
+				response.Error = &ResponseError{
+					Code:    -32601,
+					Message: fmt.Sprintf("method not found: %s", msg.Method),
+				}
+			}
+
+			// Send response back to server
+			if err := WriteMessage(c.stdin, response); err != nil {
+				slog.Error("Error sending response to server", "error", err)
+			}
+
+			continue
+		}
+
+		// Handle notification (has Method but no ID)
+		if msg.Method != "" && msg.ID == 0 {
+			c.notificationMu.RLock()
+			handler, ok := c.notificationHandlers[msg.Method]
+			c.notificationMu.RUnlock()
+
+			if ok {
+				if cfg.Options.DebugLSP {
+					slog.Debug("Handling notification", "method", msg.Method)
+				}
+				go handler(msg.Params)
+			} else if cfg.Options.DebugLSP {
+				slog.Debug("No handler for notification", "method", msg.Method)
+			}
+			continue
+		}
+
+		// Handle response to our request (has ID but no Method)
+		if msg.ID != 0 && msg.Method == "" {
+			c.handlersMu.RLock()
+			ch, ok := c.handlers[msg.ID]
+			c.handlersMu.RUnlock()
+
+			if ok {
+				if cfg.Options.DebugLSP {
+					slog.Debug("Received response for request", "id", msg.ID)
+				}
+				ch <- msg
+				close(ch)
+			} else if cfg.Options.DebugLSP {
+				slog.Debug("No handler for response", "id", msg.ID)
+			}
+		}
+	}
+}
+
+// Call makes a request and waits for the response
+func (c *Client) Call(ctx context.Context, method string, params any, result any) error {
+	if !c.IsMethodSupported(method) {
+		return fmt.Errorf("method not supported by server: %s", method)
+	}
+	id := c.nextID.Add(1)
+
+	cfg := config.Get()
+	if cfg.Options.DebugLSP {
+		slog.Debug("Making call", "method", method, "id", id)
+	}
+
+	msg, err := NewRequest(id, method, params)
+	if err != nil {
+		return fmt.Errorf("failed to create request: %w", err)
+	}
+
+	// Create response channel
+	ch := make(chan *Message, 1)
+	c.handlersMu.Lock()
+	c.handlers[id] = ch
+	c.handlersMu.Unlock()
+
+	defer func() {
+		c.handlersMu.Lock()
+		delete(c.handlers, id)
+		c.handlersMu.Unlock()
+	}()
+
+	// Send request
+	if err := WriteMessage(c.stdin, msg); err != nil {
+		return fmt.Errorf("failed to send request: %w", err)
+	}
+
+	if cfg.Options.DebugLSP {
+		slog.Debug("Request sent", "method", method, "id", id)
+	}
+
+	// Wait for response
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	case resp := <-ch:
+		if cfg.Options.DebugLSP {
+			slog.Debug("Received response", "id", id)
+		}
+
+		if resp.Error != nil {
+			return fmt.Errorf("request failed: %s (code: %d)", resp.Error.Message, resp.Error.Code)
+		}
+
+		if result != nil {
+			// If result is a json.RawMessage, just copy the raw bytes
+			if rawMsg, ok := result.(*json.RawMessage); ok {
+				*rawMsg = resp.Result
+				return nil
+			}
+			// Otherwise unmarshal into the provided type
+			if err := json.Unmarshal(resp.Result, result); err != nil {
+				return fmt.Errorf("failed to unmarshal result: %w", err)
+			}
+		}
+
+		return nil
+	}
+}
+
+// Notify sends a notification (a request without an ID that doesn't expect a response)
+func (c *Client) Notify(ctx context.Context, method string, params any) error {
+	cfg := config.Get()
+	if !c.IsMethodSupported(method) {
+		if cfg.Options.DebugLSP {
+			slog.Debug("Skipping notification: method not supported by server", "method", method)
+		}
+		return nil
+	}
+	if cfg.Options.DebugLSP {
+		slog.Debug("Sending notification", "method", method)
+	}
+
+	msg, err := NewNotification(method, params)
+	if err != nil {
+		return fmt.Errorf("failed to create notification: %w", err)
+	}
+
+	if err := WriteMessage(c.stdin, msg); err != nil {
+		return fmt.Errorf("failed to send notification: %w", err)
+	}
+
+	return nil
+}
+
+type (
+	NotificationHandler  func(params json.RawMessage)
+	ServerRequestHandler func(params json.RawMessage) (any, error)
+)

projects/ui/crush/internal/message/attachment.go

@@ -0,0 +1,8 @@
+package message
+
+type Attachment struct {
+	FilePath string
+	FileName string
+	MimeType string
+	Content  []byte
+}

projects/ui/crush/internal/message/content.go

@@ -0,0 +1,386 @@
+package message
+
+import (
+	"encoding/base64"
+	"slices"
+	"time"
+
+	"github.com/charmbracelet/catwalk/pkg/catwalk"
+)
+
+type MessageRole string
+
+const (
+	Assistant MessageRole = "assistant"
+	User      MessageRole = "user"
+	System    MessageRole = "system"
+	Tool      MessageRole = "tool"
+)
+
+type FinishReason string
+
+const (
+	FinishReasonEndTurn          FinishReason = "end_turn"
+	FinishReasonMaxTokens        FinishReason = "max_tokens"
+	FinishReasonToolUse          FinishReason = "tool_use"
+	FinishReasonCanceled         FinishReason = "canceled"
+	FinishReasonError            FinishReason = "error"
+	FinishReasonPermissionDenied FinishReason = "permission_denied"
+
+	// Should never happen
+	FinishReasonUnknown FinishReason = "unknown"
+)
+
+type ContentPart interface {
+	isPart()
+}
+
+type ReasoningContent struct {
+	Thinking   string `json:"thinking"`
+	Signature  string `json:"signature"`
+	StartedAt  int64  `json:"started_at,omitempty"`
+	FinishedAt int64  `json:"finished_at,omitempty"`
+}
+
+func (tc ReasoningContent) String() string {
+	return tc.Thinking
+}
+func (ReasoningContent) isPart() {}
+
+type TextContent struct {
+	Text string `json:"text"`
+}
+
+func (tc TextContent) String() string {
+	return tc.Text
+}
+
+func (TextContent) isPart() {}
+
+type ImageURLContent struct {
+	URL    string `json:"url"`
+	Detail string `json:"detail,omitempty"`
+}
+
+func (iuc ImageURLContent) String() string {
+	return iuc.URL
+}
+
+func (ImageURLContent) isPart() {}
+
+type BinaryContent struct {
+	Path     string
+	MIMEType string
+	Data     []byte
+}
+
+func (bc BinaryContent) String(p catwalk.InferenceProvider) string {
+	base64Encoded := base64.StdEncoding.EncodeToString(bc.Data)
+	if p == catwalk.InferenceProviderOpenAI {
+		return "data:" + bc.MIMEType + ";base64," + base64Encoded
+	}
+	return base64Encoded
+}
+
+func (BinaryContent) isPart() {}
+
+type ToolCall struct {
+	ID       string `json:"id"`
+	Name     string `json:"name"`
+	Input    string `json:"input"`
+	Type     string `json:"type"`
+	Finished bool   `json:"finished"`
+}
+
+func (ToolCall) isPart() {}
+
+type ToolResult struct {
+	ToolCallID string `json:"tool_call_id"`
+	Name       string `json:"name"`
+	Content    string `json:"content"`
+	Metadata   string `json:"metadata"`
+	IsError    bool   `json:"is_error"`
+}
+
+func (ToolResult) isPart() {}
+
+type Finish struct {
+	Reason  FinishReason `json:"reason"`
+	Time    int64        `json:"time"`
+	Message string       `json:"message,omitempty"`
+	Details string       `json:"details,omitempty"`
+}
+
+func (Finish) isPart() {}
+
+type Message struct {
+	ID        string
+	Role      MessageRole
+	SessionID string
+	Parts     []ContentPart
+	Model     string
+	Provider  string
+	CreatedAt int64
+	UpdatedAt int64
+}
+
+func (m *Message) Content() TextContent {
+	for _, part := range m.Parts {
+		if c, ok := part.(TextContent); ok {
+			return c
+		}
+	}
+	return TextContent{}
+}
+
+func (m *Message) ReasoningContent() ReasoningContent {
+	for _, part := range m.Parts {
+		if c, ok := part.(ReasoningContent); ok {
+			return c
+		}
+	}
+	return ReasoningContent{}
+}
+
+func (m *Message) ImageURLContent() []ImageURLContent {
+	imageURLContents := make([]ImageURLContent, 0)
+	for _, part := range m.Parts {
+		if c, ok := part.(ImageURLContent); ok {
+			imageURLContents = append(imageURLContents, c)
+		}
+	}
+	return imageURLContents
+}
+
+func (m *Message) BinaryContent() []BinaryContent {
+	binaryContents := make([]BinaryContent, 0)
+	for _, part := range m.Parts {
+		if c, ok := part.(BinaryContent); ok {
+			binaryContents = append(binaryContents, c)
+		}
+	}
+	return binaryContents
+}
+
+func (m *Message) ToolCalls() []ToolCall {
+	toolCalls := make([]ToolCall, 0)
+	for _, part := range m.Parts {
+		if c, ok := part.(ToolCall); ok {
+			toolCalls = append(toolCalls, c)
+		}
+	}
+	return toolCalls
+}
+
+func (m *Message) ToolResults() []ToolResult {
+	toolResults := make([]ToolResult, 0)
+	for _, part := range m.Parts {
+		if c, ok := part.(ToolResult); ok {
+			toolResults = append(toolResults, c)
+		}
+	}
+	return toolResults
+}
+
+func (m *Message) IsFinished() bool {
+	for _, part := range m.Parts {
+		if _, ok := part.(Finish); ok {
+			return true
+		}
+	}
+	return false
+}
+
+func (m *Message) FinishPart() *Finish {
+	for _, part := range m.Parts {
+		if c, ok := part.(Finish); ok {
+			return &c
+		}
+	}
+	return nil
+}
+
+func (m *Message) FinishReason() FinishReason {
+	for _, part := range m.Parts {
+		if c, ok := part.(Finish); ok {
+			return c.Reason
+		}
+	}
+	return ""
+}
+
+func (m *Message) IsThinking() bool {
+	if m.ReasoningContent().Thinking != "" && m.Content().Text == "" && !m.IsFinished() {
+		return true
+	}
+	return false
+}
+
+func (m *Message) AppendContent(delta string) {
+	found := false
+	for i, part := range m.Parts {
+		if c, ok := part.(TextContent); ok {
+			m.Parts[i] = TextContent{Text: c.Text + delta}
+			found = true
+		}
+	}
+	if !found {
+		m.Parts = append(m.Parts, TextContent{Text: delta})
+	}
+}
+
+func (m *Message) AppendReasoningContent(delta string) {
+	found := false
+	for i, part := range m.Parts {
+		if c, ok := part.(ReasoningContent); ok {
+			m.Parts[i] = ReasoningContent{
+				Thinking:   c.Thinking + delta,
+				Signature:  c.Signature,
+				StartedAt:  c.StartedAt,
+				FinishedAt: c.FinishedAt,
+			}
+			found = true
+		}
+	}
+	if !found {
+		m.Parts = append(m.Parts, ReasoningContent{
+			Thinking:  delta,
+			StartedAt: time.Now().Unix(),
+		})
+	}
+}
+
+func (m *Message) AppendReasoningSignature(signature string) {
+	for i, part := range m.Parts {
+		if c, ok := part.(ReasoningContent); ok {
+			m.Parts[i] = ReasoningContent{
+				Thinking:   c.Thinking,
+				Signature:  c.Signature + signature,
+				StartedAt:  c.StartedAt,
+				FinishedAt: c.FinishedAt,
+			}
+			return
+		}
+	}
+	m.Parts = append(m.Parts, ReasoningContent{Signature: signature})
+}
+
+func (m *Message) FinishThinking() {
+	for i, part := range m.Parts {
+		if c, ok := part.(ReasoningContent); ok {
+			if c.FinishedAt == 0 {
+				m.Parts[i] = ReasoningContent{
+					Thinking:   c.Thinking,
+					Signature:  c.Signature,
+					StartedAt:  c.StartedAt,
+					FinishedAt: time.Now().Unix(),
+				}
+			}
+			return
+		}
+	}
+}
+
+func (m *Message) ThinkingDuration() time.Duration {
+	reasoning := m.ReasoningContent()
+	if reasoning.StartedAt == 0 {
+		return 0
+	}
+
+	endTime := reasoning.FinishedAt
+	if endTime == 0 {
+		endTime = time.Now().Unix()
+	}
+
+	return time.Duration(endTime-reasoning.StartedAt) * time.Second
+}
+
+func (m *Message) FinishToolCall(toolCallID string) {
+	for i, part := range m.Parts {
+		if c, ok := part.(ToolCall); ok {
+			if c.ID == toolCallID {
+				m.Parts[i] = ToolCall{
+					ID:       c.ID,
+					Name:     c.Name,
+					Input:    c.Input,
+					Type:     c.Type,
+					Finished: true,
+				}
+				return
+			}
+		}
+	}
+}
+
+func (m *Message) AppendToolCallInput(toolCallID string, inputDelta string) {
+	for i, part := range m.Parts {
+		if c, ok := part.(ToolCall); ok {
+			if c.ID == toolCallID {
+				m.Parts[i] = ToolCall{
+					ID:       c.ID,
+					Name:     c.Name,
+					Input:    c.Input + inputDelta,
+					Type:     c.Type,
+					Finished: c.Finished,
+				}
+				return
+			}
+		}
+	}
+}
+
+func (m *Message) AddToolCall(tc ToolCall) {
+	for i, part := range m.Parts {
+		if c, ok := part.(ToolCall); ok {
+			if c.ID == tc.ID {
+				m.Parts[i] = tc
+				return
+			}
+		}
+	}
+	m.Parts = append(m.Parts, tc)
+}
+
+func (m *Message) SetToolCalls(tc []ToolCall) {
+	// remove any existing tool call part it could have multiple
+	parts := make([]ContentPart, 0)
+	for _, part := range m.Parts {
+		if _, ok := part.(ToolCall); ok {
+			continue
+		}
+		parts = append(parts, part)
+	}
+	m.Parts = parts
+	for _, toolCall := range tc {
+		m.Parts = append(m.Parts, toolCall)
+	}
+}
+
+func (m *Message) AddToolResult(tr ToolResult) {
+	m.Parts = append(m.Parts, tr)
+}
+
+func (m *Message) SetToolResults(tr []ToolResult) {
+	for _, toolResult := range tr {
+		m.Parts = append(m.Parts, toolResult)
+	}
+}
+
+func (m *Message) AddFinish(reason FinishReason, message, details string) {
+	// remove any existing finish part
+	for i, part := range m.Parts {
+		if _, ok := part.(Finish); ok {
+			m.Parts = slices.Delete(m.Parts, i, i+1)
+			break
+		}
+	}
+	m.Parts = append(m.Parts, Finish{Reason: reason, Time: time.Now().Unix(), Message: message, Details: details})
+}
+
+func (m *Message) AddImageURL(url, detail string) {
+	m.Parts = append(m.Parts, ImageURLContent{URL: url, Detail: detail})
+}
+
+func (m *Message) AddBinary(mimeType string, data []byte) {
+	m.Parts = append(m.Parts, BinaryContent{MIMEType: mimeType, Data: data})
+}

projects/ui/crush/internal/message/message.go

@@ -0,0 +1,282 @@
+package message
+
+import (
+	"context"
+	"database/sql"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"github.com/charmbracelet/crush/internal/db"
+	"github.com/charmbracelet/crush/internal/pubsub"
+	"github.com/google/uuid"
+)
+
+type CreateMessageParams struct {
+	Role     MessageRole
+	Parts    []ContentPart
+	Model    string
+	Provider string
+}
+
+type Service interface {
+	pubsub.Suscriber[Message]
+	Create(ctx context.Context, sessionID string, params CreateMessageParams) (Message, error)
+	Update(ctx context.Context, message Message) error
+	Get(ctx context.Context, id string) (Message, error)
+	List(ctx context.Context, sessionID string) ([]Message, error)
+	Delete(ctx context.Context, id string) error
+	DeleteSessionMessages(ctx context.Context, sessionID string) error
+}
+
+type service struct {
+	*pubsub.Broker[Message]
+	q db.Querier
+}
+
+func NewService(q db.Querier) Service {
+	return &service{
+		Broker: pubsub.NewBroker[Message](),
+		q:      q,
+	}
+}
+
+func (s *service) Delete(ctx context.Context, id string) error {
+	message, err := s.Get(ctx, id)
+	if err != nil {
+		return err
+	}
+	err = s.q.DeleteMessage(ctx, message.ID)
+	if err != nil {
+		return err
+	}
+	s.Publish(pubsub.DeletedEvent, message)
+	return nil
+}
+
+func (s *service) Create(ctx context.Context, sessionID string, params CreateMessageParams) (Message, error) {
+	if params.Role != Assistant {
+		params.Parts = append(params.Parts, Finish{
+			Reason: "stop",
+		})
+	}
+	partsJSON, err := marshallParts(params.Parts)
+	if err != nil {
+		return Message{}, err
+	}
+	dbMessage, err := s.q.CreateMessage(ctx, db.CreateMessageParams{
+		ID:        uuid.New().String(),
+		SessionID: sessionID,
+		Role:      string(params.Role),
+		Parts:     string(partsJSON),
+		Model:     sql.NullString{String: string(params.Model), Valid: true},
+		Provider:  sql.NullString{String: params.Provider, Valid: params.Provider != ""},
+	})
+	if err != nil {
+		return Message{}, err
+	}
+	message, err := s.fromDBItem(dbMessage)
+	if err != nil {
+		return Message{}, err
+	}
+	s.Publish(pubsub.CreatedEvent, message)
+	return message, nil
+}
+
+func (s *service) DeleteSessionMessages(ctx context.Context, sessionID string) error {
+	messages, err := s.List(ctx, sessionID)
+	if err != nil {
+		return err
+	}
+	for _, message := range messages {
+		if message.SessionID == sessionID {
+			err = s.Delete(ctx, message.ID)
+			if err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func (s *service) Update(ctx context.Context, message Message) error {
+	parts, err := marshallParts(message.Parts)
+	if err != nil {
+		return err
+	}
+	finishedAt := sql.NullInt64{}
+	if f := message.FinishPart(); f != nil {
+		finishedAt.Int64 = f.Time
+		finishedAt.Valid = true
+	}
+	err = s.q.UpdateMessage(ctx, db.UpdateMessageParams{
+		ID:         message.ID,
+		Parts:      string(parts),
+		FinishedAt: finishedAt,
+	})
+	if err != nil {
+		return err
+	}
+	message.UpdatedAt = time.Now().Unix()
+	s.Publish(pubsub.UpdatedEvent, message)
+	return nil
+}
+
+func (s *service) Get(ctx context.Context, id string) (Message, error) {
+	dbMessage, err := s.q.GetMessage(ctx, id)
+	if err != nil {
+		return Message{}, err
+	}
+	return s.fromDBItem(dbMessage)
+}
+
+func (s *service) List(ctx context.Context, sessionID string) ([]Message, error) {
+	dbMessages, err := s.q.ListMessagesBySession(ctx, sessionID)
+	if err != nil {
+		return nil, err
+	}
+	messages := make([]Message, len(dbMessages))
+	for i, dbMessage := range dbMessages {
+		messages[i], err = s.fromDBItem(dbMessage)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return messages, nil
+}
+
+func (s *service) fromDBItem(item db.Message) (Message, error) {
+	parts, err := unmarshallParts([]byte(item.Parts))
+	if err != nil {
+		return Message{}, err
+	}
+	return Message{
+		ID:        item.ID,
+		SessionID: item.SessionID,
+		Role:      MessageRole(item.Role),
+		Parts:     parts,
+		Model:     item.Model.String,
+		Provider:  item.Provider.String,
+		CreatedAt: item.CreatedAt,
+		UpdatedAt: item.UpdatedAt,
+	}, nil
+}
+
+type partType string
+
+const (
+	reasoningType  partType = "reasoning"
+	textType       partType = "text"
+	imageURLType   partType = "image_url"
+	binaryType     partType = "binary"
+	toolCallType   partType = "tool_call"
+	toolResultType partType = "tool_result"
+	finishType     partType = "finish"
+)
+
+type partWrapper struct {
+	Type partType    `json:"type"`
+	Data ContentPart `json:"data"`
+}
+
+func marshallParts(parts []ContentPart) ([]byte, error) {
+	wrappedParts := make([]partWrapper, len(parts))
+
+	for i, part := range parts {
+		var typ partType
+
+		switch part.(type) {
+		case ReasoningContent:
+			typ = reasoningType
+		case TextContent:
+			typ = textType
+		case ImageURLContent:
+			typ = imageURLType
+		case BinaryContent:
+			typ = binaryType
+		case ToolCall:
+			typ = toolCallType
+		case ToolResult:
+			typ = toolResultType
+		case Finish:
+			typ = finishType
+		default:
+			return nil, fmt.Errorf("unknown part type: %T", part)
+		}
+
+		wrappedParts[i] = partWrapper{
+			Type: typ,
+			Data: part,
+		}
+	}
+	return json.Marshal(wrappedParts)
+}
+
+func unmarshallParts(data []byte) ([]ContentPart, error) {
+	temp := []json.RawMessage{}
+
+	if err := json.Unmarshal(data, &temp); err != nil {
+		return nil, err
+	}
+
+	parts := make([]ContentPart, 0)
+
+	for _, rawPart := range temp {
+		var wrapper struct {
+			Type partType        `json:"type"`
+			Data json.RawMessage `json:"data"`
+		}
+
+		if err := json.Unmarshal(rawPart, &wrapper); err != nil {
+			return nil, err
+		}
+
+		switch wrapper.Type {
+		case reasoningType:
+			part := ReasoningContent{}
+			if err := json.Unmarshal(wrapper.Data, &part); err != nil {
+				return nil, err
+			}
+			parts = append(parts, part)
+		case textType:
+			part := TextContent{}
+			if err := json.Unmarshal(wrapper.Data, &part); err != nil {
+				return nil, err
+			}
+			parts = append(parts, part)
+		case imageURLType:
+			part := ImageURLContent{}
+			if err := json.Unmarshal(wrapper.Data, &part); err != nil {
+				return nil, err
+			}
+		case binaryType:
+			part := BinaryContent{}
+			if err := json.Unmarshal(wrapper.Data, &part); err != nil {
+				return nil, err
+			}
+			parts = append(parts, part)
+		case toolCallType:
+			part := ToolCall{}
+			if err := json.Unmarshal(wrapper.Data, &part); err != nil {
+				return nil, err
+			}
+			parts = append(parts, part)
+		case toolResultType:
+			part := ToolResult{}
+			if err := json.Unmarshal(wrapper.Data, &part); err != nil {
+				return nil, err
+			}
+			parts = append(parts, part)
+		case finishType:
+			part := Finish{}
+			if err := json.Unmarshal(wrapper.Data, &part); err != nil {
+				return nil, err
+			}
+			parts = append(parts, part)
+		default:
+			return nil, fmt.Errorf("unknown part type: %s", wrapper.Type)
+		}
+	}
+
+	return parts, nil
+}

projects/ui/crush/internal/permission/permission.go

@@ -0,0 +1,234 @@
+package permission
+
+import (
+	"context"
+	"errors"
+	"os"
+	"path/filepath"
+	"slices"
+	"sync"
+
+	"github.com/charmbracelet/crush/internal/csync"
+	"github.com/charmbracelet/crush/internal/pubsub"
+	"github.com/google/uuid"
+)
+
+var ErrorPermissionDenied = errors.New("permission denied")
+
+type CreatePermissionRequest struct {
+	SessionID   string `json:"session_id"`
+	ToolCallID  string `json:"tool_call_id"`
+	ToolName    string `json:"tool_name"`
+	Description string `json:"description"`
+	Action      string `json:"action"`
+	Params      any    `json:"params"`
+	Path        string `json:"path"`
+}
+
+type PermissionNotification struct {
+	ToolCallID string `json:"tool_call_id"`
+	Granted    bool   `json:"granted"`
+	Denied     bool   `json:"denied"`
+}
+
+type PermissionRequest struct {
+	ID          string `json:"id"`
+	SessionID   string `json:"session_id"`
+	ToolCallID  string `json:"tool_call_id"`
+	ToolName    string `json:"tool_name"`
+	Description string `json:"description"`
+	Action      string `json:"action"`
+	Params      any    `json:"params"`
+	Path        string `json:"path"`
+}
+
+type Service interface {
+	pubsub.Suscriber[PermissionRequest]
+	GrantPersistent(permission PermissionRequest)
+	Grant(permission PermissionRequest)
+	Deny(permission PermissionRequest)
+	Request(opts CreatePermissionRequest) bool
+	AutoApproveSession(sessionID string)
+	SetSkipRequests(skip bool)
+	SkipRequests() bool
+	SubscribeNotifications(ctx context.Context) <-chan pubsub.Event[PermissionNotification]
+}
+
+type permissionService struct {
+	*pubsub.Broker[PermissionRequest]
+
+	notificationBroker    *pubsub.Broker[PermissionNotification]
+	workingDir            string
+	sessionPermissions    []PermissionRequest
+	sessionPermissionsMu  sync.RWMutex
+	pendingRequests       *csync.Map[string, chan bool]
+	autoApproveSessions   map[string]bool
+	autoApproveSessionsMu sync.RWMutex
+	skip                  bool
+	allowedTools          []string
+
+	// used to make sure we only process one request at a time
+	requestMu     sync.Mutex
+	activeRequest *PermissionRequest
+}
+
+func (s *permissionService) GrantPersistent(permission PermissionRequest) {
+	s.notificationBroker.Publish(pubsub.CreatedEvent, PermissionNotification{
+		ToolCallID: permission.ToolCallID,
+		Granted:    true,
+	})
+	respCh, ok := s.pendingRequests.Get(permission.ID)
+	if ok {
+		respCh <- true
+	}
+
+	s.sessionPermissionsMu.Lock()
+	s.sessionPermissions = append(s.sessionPermissions, permission)
+	s.sessionPermissionsMu.Unlock()
+
+	if s.activeRequest != nil && s.activeRequest.ID == permission.ID {
+		s.activeRequest = nil
+	}
+}
+
+func (s *permissionService) Grant(permission PermissionRequest) {
+	s.notificationBroker.Publish(pubsub.CreatedEvent, PermissionNotification{
+		ToolCallID: permission.ToolCallID,
+		Granted:    true,
+	})
+	respCh, ok := s.pendingRequests.Get(permission.ID)
+	if ok {
+		respCh <- true
+	}
+
+	if s.activeRequest != nil && s.activeRequest.ID == permission.ID {
+		s.activeRequest = nil
+	}
+}
+
+func (s *permissionService) Deny(permission PermissionRequest) {
+	s.notificationBroker.Publish(pubsub.CreatedEvent, PermissionNotification{
+		ToolCallID: permission.ToolCallID,
+		Granted:    false,
+		Denied:     true,
+	})
+	respCh, ok := s.pendingRequests.Get(permission.ID)
+	if ok {
+		respCh <- false
+	}
+
+	if s.activeRequest != nil && s.activeRequest.ID == permission.ID {
+		s.activeRequest = nil
+	}
+}
+
+func (s *permissionService) Request(opts CreatePermissionRequest) bool {
+	if s.skip {
+		return true
+	}
+
+	// tell the UI that a permission was requested
+	s.notificationBroker.Publish(pubsub.CreatedEvent, PermissionNotification{
+		ToolCallID: opts.ToolCallID,
+	})
+	s.requestMu.Lock()
+	defer s.requestMu.Unlock()
+
+	// Check if the tool/action combination is in the allowlist
+	commandKey := opts.ToolName + ":" + opts.Action
+	if slices.Contains(s.allowedTools, commandKey) || slices.Contains(s.allowedTools, opts.ToolName) {
+		return true
+	}
+
+	s.autoApproveSessionsMu.RLock()
+	autoApprove := s.autoApproveSessions[opts.SessionID]
+	s.autoApproveSessionsMu.RUnlock()
+
+	if autoApprove {
+		return true
+	}
+
+	fileInfo, err := os.Stat(opts.Path)
+	dir := opts.Path
+	if err == nil {
+		if fileInfo.IsDir() {
+			dir = opts.Path
+		} else {
+			dir = filepath.Dir(opts.Path)
+		}
+	}
+
+	if dir == "." {
+		dir = s.workingDir
+	}
+	permission := PermissionRequest{
+		ID:          uuid.New().String(),
+		Path:        dir,
+		SessionID:   opts.SessionID,
+		ToolCallID:  opts.ToolCallID,
+		ToolName:    opts.ToolName,
+		Description: opts.Description,
+		Action:      opts.Action,
+		Params:      opts.Params,
+	}
+
+	s.sessionPermissionsMu.RLock()
+	for _, p := range s.sessionPermissions {
+		if p.ToolName == permission.ToolName && p.Action == permission.Action && p.SessionID == permission.SessionID && p.Path == permission.Path {
+			s.sessionPermissionsMu.RUnlock()
+			return true
+		}
+	}
+	s.sessionPermissionsMu.RUnlock()
+
+	s.sessionPermissionsMu.RLock()
+	for _, p := range s.sessionPermissions {
+		if p.ToolName == permission.ToolName && p.Action == permission.Action && p.SessionID == permission.SessionID && p.Path == permission.Path {
+			s.sessionPermissionsMu.RUnlock()
+			return true
+		}
+	}
+	s.sessionPermissionsMu.RUnlock()
+
+	s.activeRequest = &permission
+
+	respCh := make(chan bool, 1)
+	s.pendingRequests.Set(permission.ID, respCh)
+	defer s.pendingRequests.Del(permission.ID)
+
+	// Publish the request
+	s.Publish(pubsub.CreatedEvent, permission)
+
+	return <-respCh
+}
+
+func (s *permissionService) AutoApproveSession(sessionID string) {
+	s.autoApproveSessionsMu.Lock()
+	s.autoApproveSessions[sessionID] = true
+	s.autoApproveSessionsMu.Unlock()
+}
+
+func (s *permissionService) SubscribeNotifications(ctx context.Context) <-chan pubsub.Event[PermissionNotification] {
+	return s.notificationBroker.Subscribe(ctx)
+}
+
+func (s *permissionService) SetSkipRequests(skip bool) {
+	s.skip = skip
+}
+
+func (s *permissionService) SkipRequests() bool {
+	return s.skip
+}
+
+func NewPermissionService(workingDir string, skip bool, allowedTools []string) Service {
+	return &permissionService{
+		Broker:              pubsub.NewBroker[PermissionRequest](),
+		notificationBroker:  pubsub.NewBroker[PermissionNotification](),
+		workingDir:          workingDir,
+		sessionPermissions:  make([]PermissionRequest, 0),
+		autoApproveSessions: make(map[string]bool),
+		skip:                skip,
+		allowedTools:        allowedTools,
+		pendingRequests:     csync.NewMap[string, chan bool](),
+	}
+}

projects/ui/crush/internal/permission/permission_test.go

@@ -0,0 +1,247 @@
+package permission
+
+import (
+	"sync"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestPermissionService_AllowedCommands(t *testing.T) {
+	tests := []struct {
+		name         string
+		allowedTools []string
+		toolName     string
+		action       string
+		expected     bool
+	}{
+		{
+			name:         "tool in allowlist",
+			allowedTools: []string{"bash", "view"},
+			toolName:     "bash",
+			action:       "execute",
+			expected:     true,
+		},
+		{
+			name:         "tool:action in allowlist",
+			allowedTools: []string{"bash:execute", "edit:create"},
+			toolName:     "bash",
+			action:       "execute",
+			expected:     true,
+		},
+		{
+			name:         "tool not in allowlist",
+			allowedTools: []string{"view", "ls"},
+			toolName:     "bash",
+			action:       "execute",
+			expected:     false,
+		},
+		{
+			name:         "tool:action not in allowlist",
+			allowedTools: []string{"bash:read", "edit:create"},
+			toolName:     "bash",
+			action:       "execute",
+			expected:     false,
+		},
+		{
+			name:         "empty allowlist",
+			allowedTools: []string{},
+			toolName:     "bash",
+			action:       "execute",
+			expected:     false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			service := NewPermissionService("/tmp", false, tt.allowedTools)
+
+			// Create a channel to capture the permission request
+			// Since we're testing the allowlist logic, we need to simulate the request
+			ps := service.(*permissionService)
+
+			// Test the allowlist logic directly
+			commandKey := tt.toolName + ":" + tt.action
+			allowed := false
+			for _, cmd := range ps.allowedTools {
+				if cmd == commandKey || cmd == tt.toolName {
+					allowed = true
+					break
+				}
+			}
+
+			if allowed != tt.expected {
+				t.Errorf("expected %v, got %v for tool %s action %s with allowlist %v",
+					tt.expected, allowed, tt.toolName, tt.action, tt.allowedTools)
+			}
+		})
+	}
+}
+
+func TestPermissionService_SkipMode(t *testing.T) {
+	service := NewPermissionService("/tmp", true, []string{})
+
+	result := service.Request(CreatePermissionRequest{
+		SessionID:   "test-session",
+		ToolName:    "bash",
+		Action:      "execute",
+		Description: "test command",
+		Path:        "/tmp",
+	})
+
+	if !result {
+		t.Error("expected permission to be granted in skip mode")
+	}
+}
+
+func TestPermissionService_SequentialProperties(t *testing.T) {
+	t.Run("Sequential permission requests with persistent grants", func(t *testing.T) {
+		service := NewPermissionService("/tmp", false, []string{})
+
+		req1 := CreatePermissionRequest{
+			SessionID:   "session1",
+			ToolName:    "file_tool",
+			Description: "Read file",
+			Action:      "read",
+			Params:      map[string]string{"file": "test.txt"},
+			Path:        "/tmp/test.txt",
+		}
+
+		var result1 bool
+		var wg sync.WaitGroup
+		wg.Add(1)
+
+		events := service.Subscribe(t.Context())
+
+		go func() {
+			defer wg.Done()
+			result1 = service.Request(req1)
+		}()
+
+		var permissionReq PermissionRequest
+		event := <-events
+
+		permissionReq = event.Payload
+		service.GrantPersistent(permissionReq)
+
+		wg.Wait()
+		assert.True(t, result1, "First request should be granted")
+
+		// Second identical request should be automatically approved due to persistent permission
+		req2 := CreatePermissionRequest{
+			SessionID:   "session1",
+			ToolName:    "file_tool",
+			Description: "Read file again",
+			Action:      "read",
+			Params:      map[string]string{"file": "test.txt"},
+			Path:        "/tmp/test.txt",
+		}
+		result2 := service.Request(req2)
+		assert.True(t, result2, "Second request should be auto-approved")
+	})
+	t.Run("Sequential requests with temporary grants", func(t *testing.T) {
+		service := NewPermissionService("/tmp", false, []string{})
+
+		req := CreatePermissionRequest{
+			SessionID:   "session2",
+			ToolName:    "file_tool",
+			Description: "Write file",
+			Action:      "write",
+			Params:      map[string]string{"file": "test.txt"},
+			Path:        "/tmp/test.txt",
+		}
+
+		events := service.Subscribe(t.Context())
+		var result1 bool
+		var wg sync.WaitGroup
+
+		wg.Go(func() {
+			result1 = service.Request(req)
+		})
+
+		var permissionReq PermissionRequest
+		event := <-events
+		permissionReq = event.Payload
+
+		service.Grant(permissionReq)
+		wg.Wait()
+		assert.True(t, result1, "First request should be granted")
+
+		var result2 bool
+
+		wg.Go(func() {
+			result2 = service.Request(req)
+		})
+
+		event = <-events
+		permissionReq = event.Payload
+		service.Deny(permissionReq)
+		wg.Wait()
+		assert.False(t, result2, "Second request should be denied")
+	})
+	t.Run("Concurrent requests with different outcomes", func(t *testing.T) {
+		service := NewPermissionService("/tmp", false, []string{})
+
+		events := service.Subscribe(t.Context())
+
+		var wg sync.WaitGroup
+		results := make([]bool, 0)
+
+		requests := []CreatePermissionRequest{
+			{
+				SessionID:   "concurrent1",
+				ToolName:    "tool1",
+				Action:      "action1",
+				Path:        "/tmp/file1.txt",
+				Description: "First concurrent request",
+			},
+			{
+				SessionID:   "concurrent2",
+				ToolName:    "tool2",
+				Action:      "action2",
+				Path:        "/tmp/file2.txt",
+				Description: "Second concurrent request",
+			},
+			{
+				SessionID:   "concurrent3",
+				ToolName:    "tool3",
+				Action:      "action3",
+				Path:        "/tmp/file3.txt",
+				Description: "Third concurrent request",
+			},
+		}
+
+		for i, req := range requests {
+			wg.Add(1)
+			go func(index int, request CreatePermissionRequest) {
+				defer wg.Done()
+				results = append(results, service.Request(request))
+			}(i, req)
+		}
+
+		for range 3 {
+			event := <-events
+			switch event.Payload.ToolName {
+			case "tool1":
+				service.Grant(event.Payload)
+			case "tool2":
+				service.GrantPersistent(event.Payload)
+			case "tool3":
+				service.Deny(event.Payload)
+			}
+		}
+		wg.Wait()
+		grantedCount := 0
+		for _, result := range results {
+			if result {
+				grantedCount++
+			}
+		}
+
+		assert.Equal(t, 2, grantedCount, "Should have 2 granted and 1 denied")
+		secondReq := requests[1]
+		secondReq.Description = "Repeat of second request"
+		result := service.Request(secondReq)
+		assert.True(t, result, "Repeated request should be auto-approved due to persistent permission")
+	})
+}

projects/ui/crush/internal/pubsub/broker.go

@@ -0,0 +1,118 @@
+package pubsub
+
+import (
+	"context"
+	"sync"
+)
+
+const bufferSize = 64
+
+type Broker[T any] struct {
+	subs      map[chan Event[T]]struct{}
+	mu        sync.RWMutex
+	done      chan struct{}
+	subCount  int
+	maxEvents int
+}
+
+func NewBroker[T any]() *Broker[T] {
+	return NewBrokerWithOptions[T](bufferSize, 1000)
+}
+
+func NewBrokerWithOptions[T any](channelBufferSize, maxEvents int) *Broker[T] {
+	b := &Broker[T]{
+		subs:      make(map[chan Event[T]]struct{}),
+		done:      make(chan struct{}),
+		subCount:  0,
+		maxEvents: maxEvents,
+	}
+	return b
+}
+
+func (b *Broker[T]) Shutdown() {
+	select {
+	case <-b.done: // Already closed
+		return
+	default:
+		close(b.done)
+	}
+
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	for ch := range b.subs {
+		delete(b.subs, ch)
+		close(ch)
+	}
+
+	b.subCount = 0
+}
+
+func (b *Broker[T]) Subscribe(ctx context.Context) <-chan Event[T] {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	select {
+	case <-b.done:
+		ch := make(chan Event[T])
+		close(ch)
+		return ch
+	default:
+	}
+
+	sub := make(chan Event[T], bufferSize)
+	b.subs[sub] = struct{}{}
+	b.subCount++
+
+	go func() {
+		<-ctx.Done()
+
+		b.mu.Lock()
+		defer b.mu.Unlock()
+
+		select {
+		case <-b.done:
+			return
+		default:
+		}
+
+		delete(b.subs, sub)
+		close(sub)
+		b.subCount--
+	}()
+
+	return sub
+}
+
+func (b *Broker[T]) GetSubscriberCount() int {
+	b.mu.RLock()
+	defer b.mu.RUnlock()
+	return b.subCount
+}
+
+func (b *Broker[T]) Publish(t EventType, payload T) {
+	b.mu.RLock()
+	select {
+	case <-b.done:
+		b.mu.RUnlock()
+		return
+	default:
+	}
+
+	subscribers := make([]chan Event[T], 0, len(b.subs))
+	for sub := range b.subs {
+		subscribers = append(subscribers, sub)
+	}
+	b.mu.RUnlock()
+
+	event := Event[T]{Type: t, Payload: payload}
+
+	for _, sub := range subscribers {
+		select {
+		case sub <- event:
+		default:
+			// Channel is full, subscriber is slow - skip this event
+			// This prevents blocking the publisher
+		}
+	}
+}

projects/ui/crush/internal/pubsub/events.go

@@ -0,0 +1,28 @@
+package pubsub
+
+import "context"
+
+const (
+	CreatedEvent EventType = "created"
+	UpdatedEvent EventType = "updated"
+	DeletedEvent EventType = "deleted"
+)
+
+type Suscriber[T any] interface {
+	Subscribe(context.Context) <-chan Event[T]
+}
+
+type (
+	// EventType identifies the type of event
+	EventType string
+
+	// Event represents an event in the lifecycle of a resource
+	Event[T any] struct {
+		Type    EventType
+		Payload T
+	}
+
+	Publisher[T any] interface {
+		Publish(EventType, T)
+	}
+)