lsp improvements

internal/app/app.go

@@ -49,7 +49,8 @@ func New(ctx context.Context, conn *sql.DB) (*App, error) {
 		LSPClients:  make(map[string]*lsp.Client),
 	}
 
-	app.initLSPClients(ctx)
+	// Initialize LSP clients in the background
+	go app.initLSPClients(ctx)
 
 	var err error
 	app.CoderAgent, err = agent.NewAgent(

internal/app/lsp.go

@@ -15,24 +15,28 @@ func (app *App) initLSPClients(ctx context.Context) {
 
 	// Initialize LSP clients
 	for name, clientConfig := range cfg.LSP {
-		app.createAndStartLSPClient(ctx, name, clientConfig.Command, clientConfig.Args...)
+		// Start each client initialization in its own goroutine
+		go app.createAndStartLSPClient(ctx, name, clientConfig.Command, clientConfig.Args...)
 	}
+	logging.Info("LSP clients initialization started in background")
 }
 
 // createAndStartLSPClient creates a new LSP client, initializes it, and starts its workspace watcher
 func (app *App) createAndStartLSPClient(ctx context.Context, name string, command string, args ...string) {
 	// Create a specific context for initialization with a timeout
-
+	logging.Info("Creating LSP client", "name", name, "command", command, "args", args)
+	
 	// Create the LSP client
 	lspClient, err := lsp.NewClient(ctx, command, args...)
 	if err != nil {
 		logging.Error("Failed to create LSP client for", name, err)
 		return
-
 	}
 
-	initCtx, cancel := context.WithTimeout(ctx, 15*time.Second)
+	// Create a longer timeout for initialization (some servers take time to start)
+	initCtx, cancel := context.WithTimeout(ctx, 30*time.Second)
 	defer cancel()
+	
 	// Initialize with the initialization context
 	_, err = lspClient.InitializeLSPClient(initCtx, config.WorkingDirectory())
 	if err != nil {
@@ -42,8 +46,25 @@ func (app *App) createAndStartLSPClient(ctx context.Context, name string, comman
 		return
 	}
 
+	// Wait for the server to be ready
+	if err := lspClient.WaitForServerReady(initCtx); err != nil {
+		logging.Error("Server failed to become ready", "name", name, "error", err)
+		// We'll continue anyway, as some functionality might still work
+		lspClient.SetServerState(lsp.StateError)
+	} else {
+		logging.Info("LSP server is ready", "name", name)
+		lspClient.SetServerState(lsp.StateReady)
+	}
+
+	logging.Info("LSP client initialized", "name", name)
+	
 	// Create a child context that can be canceled when the app is shutting down
 	watchCtx, cancelFunc := context.WithCancel(ctx)
+	
+	// Create a context with the server name for better identification
+	watchCtx = context.WithValue(watchCtx, "serverName", name)
+	
+	// Create the workspace watcher
 	workspaceWatcher := watcher.NewWorkspaceWatcher(lspClient)
 
 	// Store the cancel function to be called during cleanup

internal/config/config.go

@@ -209,17 +209,17 @@ func setProviderDefaults() {
 	// Google Gemini configuration
 	if apiKey := os.Getenv("GEMINI_API_KEY"); apiKey != "" {
 		viper.SetDefault("providers.gemini.apiKey", apiKey)
-		viper.SetDefault("agents.coder.model", models.GRMINI20Flash)
-		viper.SetDefault("agents.task.model", models.GRMINI20Flash)
-		viper.SetDefault("agents.title.model", models.GRMINI20Flash)
+		viper.SetDefault("agents.coder.model", models.Gemini25)
+		viper.SetDefault("agents.task.model", models.Gemini25Flash)
+		viper.SetDefault("agents.title.model", models.Gemini25Flash)
 	}
 
 	// OpenAI configuration
 	if apiKey := os.Getenv("OPENAI_API_KEY"); apiKey != "" {
 		viper.SetDefault("providers.openai.apiKey", apiKey)
-		viper.SetDefault("agents.coder.model", models.GPT4o)
-		viper.SetDefault("agents.task.model", models.GPT4o)
-		viper.SetDefault("agents.title.model", models.GPT4o)
+		viper.SetDefault("agents.coder.model", models.GPT41)
+		viper.SetDefault("agents.task.model", models.GPT41Mini)
+		viper.SetDefault("agents.title.model", models.GPT41Mini)
 
 	}
 

internal/llm/models/gemini.go

@@ -0,0 +1,63 @@
+package models
+
+const (
+	ProviderGemini ModelProvider = "gemini"
+
+	// Models
+	Gemini25Flash     ModelID = "gemini-2.5-flash"
+	Gemini25          ModelID = "gemini-2.5"
+	Gemini20Flash     ModelID = "gemini-2.0-flash"
+	Gemini20FlashLite ModelID = "gemini-2.0-flash-lite"
+)
+
+var GeminiModels = map[ModelID]Model{
+	Gemini25Flash: {
+		ID:                 Gemini25Flash,
+		Name:               "Gemini 2.5 Flash",
+		Provider:           ProviderGemini,
+		APIModel:           "gemini-2.5-flash-preview-04-17",
+		CostPer1MIn:        0.15,
+		CostPer1MInCached:  0,
+		CostPer1MOutCached: 0,
+		CostPer1MOut:       0.60,
+		ContextWindow:      1000000,
+		DefaultMaxTokens:   50000,
+	},
+	Gemini25: {
+		ID:                 Gemini25,
+		Name:               "Gemini 2.5 Pro",
+		Provider:           ProviderGemini,
+		APIModel:           "gemini-2.5-pro-preview-03-25",
+		CostPer1MIn:        1.25,
+		CostPer1MInCached:  0,
+		CostPer1MOutCached: 0,
+		CostPer1MOut:       10,
+		ContextWindow:      1000000,
+		DefaultMaxTokens:   50000,
+	},
+
+	Gemini20Flash: {
+		ID:                 Gemini20Flash,
+		Name:               "Gemini 2.0 Flash",
+		Provider:           ProviderGemini,
+		APIModel:           "gemini-2.0-flash",
+		CostPer1MIn:        0.10,
+		CostPer1MInCached:  0,
+		CostPer1MOutCached: 0,
+		CostPer1MOut:       0.40,
+		ContextWindow:      1000000,
+		DefaultMaxTokens:   6000,
+	},
+	Gemini20FlashLite: {
+		ID:                 Gemini20FlashLite,
+		Name:               "Gemini 2.0 Flash Lite",
+		Provider:           ProviderGemini,
+		APIModel:           "gemini-2.0-flash-lite",
+		CostPer1MIn:        0.05,
+		CostPer1MInCached:  0,
+		CostPer1MOutCached: 0,
+		CostPer1MOut:       0.30,
+		ContextWindow:      1000000,
+		DefaultMaxTokens:   6000,
+	},
+}

internal/llm/models/models.go

@@ -23,9 +23,6 @@ type Model struct {
 
 // Model IDs
 const ( // GEMINI
-	GEMINI25      ModelID = "gemini-2.5"
-	GRMINI20Flash ModelID = "gemini-2.0-flash"
-
 	// GROQ
 	QWENQwq ModelID = "qwen-qwq"
 
@@ -35,7 +32,6 @@ const ( // GEMINI
 
 const (
 	ProviderBedrock ModelProvider = "bedrock"
-	ProviderGemini  ModelProvider = "gemini"
 	ProviderGROQ    ModelProvider = "groq"
 
 	// ForTests
@@ -95,4 +91,5 @@ var SupportedModels = map[ModelID]Model{
 func init() {
 	maps.Copy(SupportedModels, AnthropicModels)
 	maps.Copy(SupportedModels, OpenAIModels)
+	maps.Copy(SupportedModels, GeminiModels)
 }

internal/llm/prompt/coder.go

@@ -68,6 +68,7 @@ You MUST adhere to the following criteria when executing the task:
     - Do NOT show the full contents of large files you have already written, unless the user explicitly asks for them.
 - When doing things with paths, always use use the full path, if the working directory is /abc/xyz  and you want to edit the file abc.go in the working dir refer to it as /abc/xyz/abc.go.
 - If you send a path not including the working dir, the working dir will be prepended to it.
+- Remember the user does not see the full output of tools
 `
 
 const baseAnthropicCoderPrompt = `You are OpenCode, an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.
@@ -162,6 +163,7 @@ NEVER commit changes unless the user explicitly asks you to. It is VERY IMPORTAN
 # Tool usage policy
 - When doing file search, prefer to use the Agent tool in order to reduce context usage.
 - If you intend to call multiple tools and there are no dependencies between the calls, make all of the independent calls in the same function_calls block.
+- IMPORTANT: The user does not see the full output of the tool responses, so if you need the output of the tool for the response make sure to summarize it for the user.
 
 You MUST answer concisely with fewer than 4 lines of text (not including tool use or code generation), unless user asks for detail.`
 

internal/llm/provider/gemini.go

@@ -567,4 +567,3 @@ func contains(s string, substrs ...string) bool {
 	}
 	return false
 }
-

internal/llm/tools/grep.go

@@ -10,6 +10,7 @@ import (
 	"path/filepath"
 	"regexp"
 	"sort"
+	"strconv"
 	"strings"
 	"time"
 
@@ -24,8 +25,10 @@ type GrepParams struct {
 }
 
 type grepMatch struct {
-	path    string
-	modTime time.Time
+	path     string
+	modTime  time.Time
+	lineNum  int
+	lineText string
 }
 
 type GrepResponseMetadata struct {
@@ -147,13 +150,26 @@ func (g *grepTool) Run(ctx context.Context, call ToolCall) (ToolResponse, error)
 	if len(matches) == 0 {
 		output = "No files found"
 	} else {
-		output = fmt.Sprintf("Found %d file%s\n%s",
-			len(matches),
-			pluralize(len(matches)),
-			strings.Join(matches, "\n"))
+		output = fmt.Sprintf("Found %d matches\n", len(matches))
+
+		currentFile := ""
+		for _, match := range matches {
+			if currentFile != match.path {
+				if currentFile != "" {
+					output += "\n"
+				}
+				currentFile = match.path
+				output += fmt.Sprintf("%s:\n", match.path)
+			}
+			if match.lineNum > 0 {
+				output += fmt.Sprintf("  Line %d: %s\n", match.lineNum, match.lineText)
+			} else {
+				output += fmt.Sprintf("  %s\n", match.path)
+			}
+		}
 
 		if truncated {
-			output += "\n\n(Results are truncated. Consider using a more specific path or pattern.)"
+			output += "\n(Results are truncated. Consider using a more specific path or pattern.)"
 		}
 	}
 
@@ -166,14 +182,7 @@ func (g *grepTool) Run(ctx context.Context, call ToolCall) (ToolResponse, error)
 	), nil
 }
 
-func pluralize(count int) string {
-	if count == 1 {
-		return ""
-	}
-	return "s"
-}
-
-func searchFiles(pattern, rootPath, include string, limit int) ([]string, bool, error) {
+func searchFiles(pattern, rootPath, include string, limit int) ([]grepMatch, bool, error) {
 	matches, err := searchWithRipgrep(pattern, rootPath, include)
 	if err != nil {
 		matches, err = searchFilesWithRegex(pattern, rootPath, include)
@@ -191,12 +200,7 @@ func searchFiles(pattern, rootPath, include string, limit int) ([]string, bool,
 		matches = matches[:limit]
 	}
 
-	results := make([]string, len(matches))
-	for i, m := range matches {
-		results[i] = m.path
-	}
-
-	return results, truncated, nil
+	return matches, truncated, nil
 }
 
 func searchWithRipgrep(pattern, path, include string) ([]grepMatch, error) {
@@ -205,7 +209,8 @@ func searchWithRipgrep(pattern, path, include string) ([]grepMatch, error) {
 		return nil, fmt.Errorf("ripgrep not found: %w", err)
 	}
 
-	args := []string{"-l", pattern}
+	// Use -n to show line numbers and include the matched line
+	args := []string{"-n", pattern}
 	if include != "" {
 		args = append(args, "--glob", include)
 	}
@@ -228,14 +233,29 @@ func searchWithRipgrep(pattern, path, include string) ([]grepMatch, error) {
 			continue
 		}
 
-		fileInfo, err := os.Stat(line)
+		// Parse ripgrep output format: file:line:content
+		parts := strings.SplitN(line, ":", 3)
+		if len(parts) < 3 {
+			continue
+		}
+
+		filePath := parts[0]
+		lineNum, err := strconv.Atoi(parts[1])
+		if err != nil {
+			continue
+		}
+		lineText := parts[2]
+
+		fileInfo, err := os.Stat(filePath)
 		if err != nil {
 			continue // Skip files we can't access
 		}
 
 		matches = append(matches, grepMatch{
-			path:    line,
-			modTime: fileInfo.ModTime(),
+			path:     filePath,
+			modTime:  fileInfo.ModTime(),
+			lineNum:  lineNum,
+			lineText: lineText,
 		})
 	}
 
@@ -276,15 +296,17 @@ func searchFilesWithRegex(pattern, rootPath, include string) ([]grepMatch, error
 			return nil
 		}
 
-		match, err := fileContainsPattern(path, regex)
+		match, lineNum, lineText, err := fileContainsPattern(path, regex)
 		if err != nil {
 			return nil // Skip files we can't read
 		}
 
 		if match {
 			matches = append(matches, grepMatch{
-				path:    path,
-				modTime: info.ModTime(),
+				path:     path,
+				modTime:  info.ModTime(),
+				lineNum:  lineNum,
+				lineText: lineText,
 			})
 
 			if len(matches) >= 200 {
@@ -301,21 +323,24 @@ func searchFilesWithRegex(pattern, rootPath, include string) ([]grepMatch, error
 	return matches, nil
 }
 
-func fileContainsPattern(filePath string, pattern *regexp.Regexp) (bool, error) {
+func fileContainsPattern(filePath string, pattern *regexp.Regexp) (bool, int, string, error) {
 	file, err := os.Open(filePath)
 	if err != nil {
-		return false, err
+		return false, 0, "", err
 	}
 	defer file.Close()
 
 	scanner := bufio.NewScanner(file)
+	lineNum := 0
 	for scanner.Scan() {
-		if pattern.MatchString(scanner.Text()) {
-			return true, nil
+		lineNum++
+		line := scanner.Text()
+		if pattern.MatchString(line) {
+			return true, lineNum, line, nil
 		}
 	}
 
-	return false, scanner.Err()
+	return false, 0, "", scanner.Err()
 }
 
 func globToRegex(glob string) string {

internal/lsp/client.go

@@ -8,6 +8,7 @@ import (
 	"io"
 	"os"
 	"os/exec"
+	"path/filepath"
 	"strings"
 	"sync"
 	"sync/atomic"
@@ -46,6 +47,9 @@ type Client struct {
 	// Files are currently opened by the LSP
 	openFiles   map[string]*OpenFileInfo
 	openFilesMu sync.RWMutex
+
+	// Server state
+	serverState atomic.Value
 }
 
 func NewClient(ctx context.Context, command string, args ...string) (*Client, error) {
@@ -80,6 +84,9 @@ func NewClient(ctx context.Context, command string, args ...string) (*Client, er
 		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)
@@ -220,16 +227,6 @@ func (c *Client) InitializeLSPClient(ctx context.Context, workspaceDir string) (
 		return nil, fmt.Errorf("initialization failed: %w", err)
 	}
 
-	// LSP sepecific Initialization
-	path := strings.ToLower(c.Cmd.Path)
-	switch {
-	case strings.Contains(path, "typescript-language-server"):
-		// err := initializeTypescriptLanguageServer(ctx, c, workspaceDir)
-		// if err != nil {
-		// 	return nil, err
-		// }
-	}
-
 	return &result, nil
 }
 
@@ -273,10 +270,314 @@ const (
 	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)
+}
+
+// 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 {
-	// TODO: wait for specific messages or poll workspace/symbol
-	time.Sleep(time.Second * 1)
-	return nil
+	cnf := 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 cnf.DebugLSP {
+		logging.Debug("Waiting for LSP server to be ready...")
+	}
+
+	// Determine server type for specialized initialization
+	serverType := c.detectServerType()
+
+	// For TypeScript-like servers, we need to open some key files first
+	if serverType == ServerTypeTypeScript {
+		if cnf.DebugLSP {
+			logging.Debug("TypeScript-like server detected, opening key configuration files")
+		}
+		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
+			err := c.pingServerByType(ctx, serverType)
+			if err == nil {
+				// Server responded successfully
+				c.SetServerState(StateReady)
+				if cnf.DebugLSP {
+					logging.Debug("LSP server is ready")
+				}
+				return nil
+			} else {
+				logging.Debug("LSP server not ready yet", "error", err, "serverType", serverType)
+			}
+
+			if cnf.DebugLSP {
+				logging.Debug("LSP server not ready yet", "error", err, "serverType", serverType)
+			}
+		}
+	}
+}
+
+// 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.WorkingDirectory()
+	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 {
+				logging.Debug("Failed to open key config file", "file", file, "error", err)
+			} else {
+				logging.Debug("Opened key config file for initialization", "file", file)
+			}
+		}
+	}
+}
+
+// pingServerByType sends a ping request appropriate for the server type
+func (c *Client) pingServerByType(ctx context.Context, serverType ServerType) error {
+	switch serverType {
+	case ServerTypeTypeScript:
+		// For TypeScript, try a document symbol request on an open file
+		return c.pingTypeScriptServer(ctx)
+	case ServerTypeGo:
+		// For Go, workspace/symbol works well
+		return c.pingWithWorkspaceSymbol(ctx)
+	case ServerTypeRust:
+		// For Rust, workspace/symbol works well
+		return c.pingWithWorkspaceSymbol(ctx)
+	default:
+		// Default ping method
+		return c.pingWithWorkspaceSymbol(ctx)
+	}
+}
+
+// pingTypeScriptServer tries to ping a TypeScript server with appropriate methods
+func (c *Client) pingTypeScriptServer(ctx context.Context) error {
+	// First try workspace/symbol which works for many servers
+	if err := c.pingWithWorkspaceSymbol(ctx); err == nil {
+		return nil
+	}
+
+	// If that fails, try to find an open file and request document symbols
+	c.openFilesMu.RLock()
+	defer c.openFilesMu.RUnlock()
+
+	// If we have any open files, try to get document symbols for one
+	for uri := range c.openFiles {
+		filePath := strings.TrimPrefix(uri, "file://")
+		if strings.HasSuffix(filePath, ".ts") || strings.HasSuffix(filePath, ".js") ||
+			strings.HasSuffix(filePath, ".tsx") || strings.HasSuffix(filePath, ".jsx") {
+			var symbols []protocol.DocumentSymbol
+			err := c.Call(ctx, "textDocument/documentSymbol", protocol.DocumentSymbolParams{
+				TextDocument: protocol.TextDocumentIdentifier{
+					URI: protocol.DocumentUri(uri),
+				},
+			}, &symbols)
+			if err == nil {
+				return nil
+			}
+		}
+	}
+
+	// If we have no open TypeScript files, try to find and open one
+	workDir := config.WorkingDirectory()
+	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() {
+			return nil
+		}
+
+		ext := filepath.Ext(path)
+		if ext == ".ts" || ext == ".js" || ext == ".tsx" || ext == ".jsx" {
+			// Found a TypeScript file, try to open it
+			if err := c.OpenFile(ctx, path); err == nil {
+				// Successfully opened, stop walking
+				return filepath.SkipAll
+			}
+		}
+
+		return nil
+	})
+	if err != nil {
+		logging.Debug("Error walking directory for TypeScript files", "error", err)
+	}
+
+	// Final fallback - just try a generic capability
+	return c.pingWithServerCapabilities(ctx)
+}
+
+// openTypeScriptFiles finds and opens TypeScript files to help initialize the server
+func (c *Client) openTypeScriptFiles(ctx context.Context, workDir string) {
+	cnf := 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 cnf.DebugLSP {
+					logging.Debug("Opened TypeScript file for initialization", "file", path)
+				}
+			}
+		}
+
+		return nil
+	})
+
+	if err != nil && cnf.DebugLSP {
+		logging.Debug("Error walking directory for TypeScript files", "error", err)
+	}
+
+	if cnf.DebugLSP {
+		logging.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]
+}
+
+// pingWithWorkspaceSymbol tries a workspace/symbol request
+func (c *Client) pingWithWorkspaceSymbol(ctx context.Context) error {
+	var result []protocol.SymbolInformation
+	return c.Call(ctx, "workspace/symbol", protocol.WorkspaceSymbolParams{
+		Query: "",
+	}, &result)
+}
+
+// pingWithServerCapabilities tries to get server capabilities
+func (c *Client) pingWithServerCapabilities(ctx context.Context) error {
+	// This is a very lightweight request that should work for most servers
+	return c.Notify(ctx, "$/cancelRequest", struct{ ID int }{ID: -1})
 }
 
 type OpenFileInfo struct {
@@ -435,6 +736,43 @@ func (c *Client) GetFileDiagnostics(uri protocol.DocumentUri) []protocol.Diagnos
 	return c.diagnostics[uri]
 }
 
+// GetDiagnostics returns all diagnostics for all files
 func (c *Client) GetDiagnostics() map[protocol.DocumentUri][]protocol.Diagnostic {
 	return 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) {
+	uri := fmt.Sprintf("file://%s", filepath)
+	documentUri := protocol.DocumentUri(uri)
+
+	// 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
+}

internal/lsp/watcher/watcher.go

@@ -9,6 +9,7 @@ import (
 	"sync"
 	"time"
 
+	"github.com/bmatcuk/doublestar/v4"
 	"github.com/fsnotify/fsnotify"
 	"github.com/kujtimiihoxha/opencode/internal/config"
 	"github.com/kujtimiihoxha/opencode/internal/logging"
@@ -43,6 +44,8 @@ func NewWorkspaceWatcher(client *lsp.Client) *WorkspaceWatcher {
 // AddRegistrations adds file watchers to track
 func (w *WorkspaceWatcher) AddRegistrations(ctx context.Context, id string, watchers []protocol.FileSystemWatcher) {
 	cnf := config.Get()
+
+	logging.Debug("Adding file watcher registrations")
 	w.registrationMu.Lock()
 	defer w.registrationMu.Unlock()
 
@@ -55,7 +58,6 @@ func (w *WorkspaceWatcher) AddRegistrations(ctx context.Context, id string, watc
 			"id", id,
 			"watchers", len(watchers),
 			"total", len(w.registrations),
-			"watchers", watchers,
 		)
 
 		for i, watcher := range watchers {
@@ -88,66 +90,217 @@ func (w *WorkspaceWatcher) AddRegistrations(ctx context.Context, id string, watc
 			}
 
 			logging.Debug("WatchKind", "kind", watchKind)
-
-			// Test match against some example paths
-			testPaths := []string{
-				"/Users/phil/dev/mcp-language-server/internal/watcher/watcher.go",
-				"/Users/phil/dev/mcp-language-server/go.mod",
-			}
-
-			for _, testPath := range testPaths {
-				isMatch := w.matchesPattern(testPath, watcher.GlobPattern)
-				logging.Debug("Test path", "path", testPath, "matches", isMatch)
-			}
 		}
 	}
 
-	// Find and open all existing files that match the newly registered patterns
-	// TODO: not all language servers require this, but typescript does. Make this configurable
-	go func() {
-		startTime := time.Now()
-		filesOpened := 0
-
-		err := filepath.WalkDir(w.workspacePath, func(path string, d os.DirEntry, err error) error {
-			if err != nil {
-				return err
+	// Determine server type for specialized handling
+	serverName := getServerNameFromContext(ctx)
+	logging.Debug("Server type detected", "serverName", serverName)
+	
+	// Check if this server has sent file watchers
+	hasFileWatchers := len(watchers) > 0
+	
+	// For servers that need file preloading, we'll use a smart approach
+	if shouldPreloadFiles(serverName) || !hasFileWatchers {
+		go func() {
+			startTime := time.Now()
+			filesOpened := 0
+			
+			// Determine max files to open based on server type
+			maxFilesToOpen := 50 // Default conservative limit
+			
+			switch serverName {
+			case "typescript", "typescript-language-server", "tsserver", "vtsls":
+				// TypeScript servers benefit from seeing more files
+				maxFilesToOpen = 100
+			case "java", "jdtls":
+				// Java servers need to see many files for project model
+				maxFilesToOpen = 200
+			}
+			
+			// First, open high-priority files
+			highPriorityFilesOpened := w.openHighPriorityFiles(ctx, serverName)
+			filesOpened += highPriorityFilesOpened
+			
+			if cnf.DebugLSP {
+				logging.Debug("Opened high-priority files", 
+					"count", highPriorityFilesOpened,
+					"serverName", serverName)
 			}
+			
+			// If we've already opened enough high-priority files, we might not need more
+			if filesOpened >= maxFilesToOpen {
+				if cnf.DebugLSP {
+					logging.Debug("Reached file limit with high-priority files",
+						"filesOpened", filesOpened,
+						"maxFiles", maxFilesToOpen)
+				}
+				return
+			}
+			
+			// For the remaining slots, walk the directory and open matching files
+			
+			err := filepath.WalkDir(w.workspacePath, func(path string, d os.DirEntry, err error) error {
+				if err != nil {
+					return err
+				}
 
-			// Skip directories that should be excluded
-			if d.IsDir() {
-				if path != w.workspacePath && shouldExcludeDir(path) {
-					if cnf.DebugLSP {
-						logging.Debug("Skipping excluded directory", "path", path)
+				// Skip directories that should be excluded
+				if d.IsDir() {
+					if path != w.workspacePath && shouldExcludeDir(path) {
+						if cnf.DebugLSP {
+							logging.Debug("Skipping excluded directory", "path", path)
+						}
+						return filepath.SkipDir
+					}
+				} else {
+					// Process files, but limit the total number
+					if filesOpened < maxFilesToOpen {
+						// Only process if it's not already open (high-priority files were opened earlier)
+						if !w.client.IsFileOpen(path) {
+							w.openMatchingFile(ctx, path)
+							filesOpened++
+
+							// Add a small delay after every 10 files to prevent overwhelming the server
+							if filesOpened%10 == 0 {
+								time.Sleep(50 * time.Millisecond)
+							}
+						}
+					} else {
+						// We've reached our limit, stop walking
+						return filepath.SkipAll
 					}
-					return filepath.SkipDir
 				}
-			} else {
-				// Process files
-				w.openMatchingFile(ctx, path)
-				filesOpened++
 
-				// Add a small delay after every 100 files to prevent overwhelming the server
-				if filesOpened%100 == 0 {
-					time.Sleep(10 * time.Millisecond)
-				}
+				return nil
+			})
+
+			elapsedTime := time.Since(startTime)
+			if cnf.DebugLSP {
+				logging.Debug("Limited workspace scan complete",
+					"filesOpened", filesOpened,
+					"maxFiles", maxFilesToOpen,
+					"elapsedTime", elapsedTime.Seconds(),
+					"workspacePath", w.workspacePath,
+				)
 			}
 
-			return nil
-		})
+			if err != nil && cnf.DebugLSP {
+				logging.Debug("Error scanning workspace for files to open", "error", err)
+			}
+		}()
+	} else if cnf.DebugLSP {
+		logging.Debug("Using on-demand file loading for server", "server", serverName)
+	}
+}
 
-		elapsedTime := time.Since(startTime)
-		if cnf.DebugLSP {
-			logging.Debug("Workspace scan complete",
-				"filesOpened", filesOpened,
-				"elapsedTime", elapsedTime.Seconds(),
-				"workspacePath", w.workspacePath,
-			)
+// openHighPriorityFiles opens important files for the server type
+// Returns the number of files opened
+func (w *WorkspaceWatcher) openHighPriorityFiles(ctx context.Context, serverName string) int {
+	cnf := config.Get()
+	filesOpened := 0
+	
+	// Define patterns for high-priority files based on server type
+	var patterns []string
+	
+	switch serverName {
+	case "typescript", "typescript-language-server", "tsserver", "vtsls":
+		patterns = []string{
+			"**/tsconfig.json",
+			"**/package.json",
+			"**/jsconfig.json",
+			"**/index.ts",
+			"**/index.js",
+			"**/main.ts",
+			"**/main.js",
 		}
-
-		if err != nil && cnf.DebugLSP {
-			logging.Debug("Error scanning workspace for files to open", "error", err)
+	case "gopls":
+		patterns = []string{
+			"**/go.mod",
+			"**/go.sum",
+			"**/main.go",
+		}
+	case "rust-analyzer":
+		patterns = []string{
+			"**/Cargo.toml",
+			"**/Cargo.lock",
+			"**/src/lib.rs",
+			"**/src/main.rs",
+		}
+	case "python", "pyright", "pylsp":
+		patterns = []string{
+			"**/pyproject.toml",
+			"**/setup.py",
+			"**/requirements.txt",
+			"**/__init__.py",
+			"**/__main__.py",
+		}
+	case "clangd":
+		patterns = []string{
+			"**/CMakeLists.txt",
+			"**/Makefile",
+			"**/compile_commands.json",
+		}
+	case "java", "jdtls":
+		patterns = []string{
+			"**/pom.xml",
+			"**/build.gradle",
+			"**/src/main/java/**/*.java",
 		}
-	}()
+	default:
+		// For unknown servers, use common configuration files
+		patterns = []string{
+			"**/package.json",
+			"**/Makefile",
+			"**/CMakeLists.txt",
+			"**/.editorconfig",
+		}
+	}
+	
+	// For each pattern, find and open matching files
+	for _, pattern := range patterns {
+		// Use doublestar.Glob to find files matching the pattern (supports ** patterns)
+		matches, err := doublestar.Glob(os.DirFS(w.workspacePath), pattern)
+		if err != nil {
+			if cnf.DebugLSP {
+				logging.Debug("Error finding high-priority files", "pattern", pattern, "error", err)
+			}
+			continue
+		}
+		
+		for _, match := range matches {
+			// Convert relative path to absolute
+			fullPath := filepath.Join(w.workspacePath, match)
+			
+			// Skip directories and excluded files
+			info, err := os.Stat(fullPath)
+			if err != nil || info.IsDir() || shouldExcludeFile(fullPath) {
+				continue
+			}
+			
+			// Open the file
+			if err := w.client.OpenFile(ctx, fullPath); err != nil {
+				if cnf.DebugLSP {
+					logging.Debug("Error opening high-priority file", "path", fullPath, "error", err)
+				}
+			} else {
+				filesOpened++
+				if cnf.DebugLSP {
+					logging.Debug("Opened high-priority file", "path", fullPath)
+				}
+			}
+			
+			// Add a small delay to prevent overwhelming the server
+			time.Sleep(20 * time.Millisecond)
+			
+			// Limit the number of files opened per pattern
+			if filesOpened >= 5 && (serverName != "java" && serverName != "jdtls") {
+				break
+			}
+		}
+	}
+	
+	return filesOpened
 }
 
 // WatchWorkspace sets up file watching for a workspace
@@ -155,6 +308,18 @@ func (w *WorkspaceWatcher) WatchWorkspace(ctx context.Context, workspacePath str
 	cnf := config.Get()
 	w.workspacePath = workspacePath
 
+	// Store the watcher in the context for later use
+	ctx = context.WithValue(ctx, "workspaceWatcher", w)
+	
+	// If the server name isn't already in the context, try to detect it
+	if _, ok := ctx.Value("serverName").(string); !ok {
+		serverName := getServerNameFromContext(ctx)
+		ctx = context.WithValue(ctx, "serverName", serverName)
+	}
+	
+	serverName := getServerNameFromContext(ctx)
+	logging.Debug("Starting workspace watcher", "workspacePath", workspacePath, "serverName", serverName)
+	
 	// Register handler for file watcher registrations from the server
 	lsp.RegisterFileWatchHandler(func(id string, watchers []protocol.FileSystemWatcher) {
 		w.AddRegistrations(ctx, id, watchers)
@@ -510,6 +675,57 @@ func (w *WorkspaceWatcher) notifyFileEvent(ctx context.Context, uri string, chan
 	return w.client.DidChangeWatchedFiles(ctx, params)
 }
 
+// getServerNameFromContext extracts the server name from the context
+// This is a best-effort function that tries to identify which LSP server we're dealing with
+func getServerNameFromContext(ctx context.Context) string {
+	// First check if the server name is directly stored in the context
+	if serverName, ok := ctx.Value("serverName").(string); ok && serverName != "" {
+		return strings.ToLower(serverName)
+	}
+	
+	// Otherwise, try to extract server name from the client command path
+	if w, ok := ctx.Value("workspaceWatcher").(*WorkspaceWatcher); ok && w != nil && w.client != nil && w.client.Cmd != nil {
+		path := strings.ToLower(w.client.Cmd.Path)
+
+		// Extract server name from path
+		if strings.Contains(path, "typescript") || strings.Contains(path, "tsserver") || strings.Contains(path, "vtsls") {
+			return "typescript"
+		} else if strings.Contains(path, "gopls") {
+			return "gopls"
+		} else if strings.Contains(path, "rust-analyzer") {
+			return "rust-analyzer"
+		} else if strings.Contains(path, "pyright") || strings.Contains(path, "pylsp") || strings.Contains(path, "python") {
+			return "python"
+		} else if strings.Contains(path, "clangd") {
+			return "clangd"
+		} else if strings.Contains(path, "jdtls") || strings.Contains(path, "java") {
+			return "java"
+		}
+
+		// Return the base name as fallback
+		return filepath.Base(path)
+	}
+
+	return "unknown"
+}
+
+// shouldPreloadFiles determines if we should preload files for a specific language server
+// Some servers work better with preloaded files, others don't need it
+func shouldPreloadFiles(serverName string) bool {
+	// TypeScript/JavaScript servers typically need some files preloaded
+	// to properly resolve imports and provide intellisense
+	switch serverName {
+	case "typescript", "typescript-language-server", "tsserver", "vtsls":
+		return true
+	case "java", "jdtls":
+		// Java servers often need to see source files to build the project model
+		return true
+	default:
+		// For most servers, we'll use lazy loading by default
+		return false
+	}
+}
+
 // Common patterns for directories and files to exclude
 // TODO: make configurable
 var (
@@ -647,9 +863,119 @@ func (w *WorkspaceWatcher) openMatchingFile(ctx context.Context, path string) {
 
 	// Check if this path should be watched according to server registrations
 	if watched, _ := w.isPathWatched(path); watched {
-		// Don't need to check if it's already open - the client.OpenFile handles that
-		if err := w.client.OpenFile(ctx, path); err != nil && cnf.DebugLSP {
-			logging.Error("Error opening file", "path", path, "error", err)
+		// Get server name for specialized handling
+		serverName := getServerNameFromContext(ctx)
+		
+		// Check if the file is a high-priority file that should be opened immediately
+		// This helps with project initialization for certain language servers
+		if isHighPriorityFile(path, serverName) {
+			if cnf.DebugLSP {
+				logging.Debug("Opening high-priority file", "path", path, "serverName", serverName)
+			}
+			if err := w.client.OpenFile(ctx, path); err != nil && cnf.DebugLSP {
+				logging.Error("Error opening high-priority file", "path", path, "error", err)
+			}
+			return
+		}
+
+		// For non-high-priority files, we'll use different strategies based on server type
+		if shouldPreloadFiles(serverName) {
+			// For servers that benefit from preloading, open files but with limits
+			
+			// Check file size - for preloading we're more conservative
+			if info.Size() > (1 * 1024 * 1024) { // 1MB limit for preloaded files
+				if cnf.DebugLSP {
+					logging.Debug("Skipping large file for preloading", "path", path, "size", info.Size())
+				}
+				return
+			}
+			
+			// Check file extension for common source files
+			ext := strings.ToLower(filepath.Ext(path))
+			
+			// Only preload source files for the specific language
+			shouldOpen := false
+			
+			switch serverName {
+			case "typescript", "typescript-language-server", "tsserver", "vtsls":
+				shouldOpen = ext == ".ts" || ext == ".js" || ext == ".tsx" || ext == ".jsx"
+			case "gopls":
+				shouldOpen = ext == ".go"
+			case "rust-analyzer":
+				shouldOpen = ext == ".rs"
+			case "python", "pyright", "pylsp":
+				shouldOpen = ext == ".py"
+			case "clangd":
+				shouldOpen = ext == ".c" || ext == ".cpp" || ext == ".h" || ext == ".hpp"
+			case "java", "jdtls":
+				shouldOpen = ext == ".java"
+			default:
+				// For unknown servers, be conservative
+				shouldOpen = false
+			}
+			
+			if shouldOpen {
+				// Don't need to check if it's already open - the client.OpenFile handles that
+				if err := w.client.OpenFile(ctx, path); err != nil && cnf.DebugLSP {
+					logging.Error("Error opening file", "path", path, "error", err)
+				}
+			}
 		}
 	}
 }
+
+// isHighPriorityFile determines if a file should be opened immediately
+// regardless of the preloading strategy
+func isHighPriorityFile(path string, serverName string) bool {
+	fileName := filepath.Base(path)
+	ext := filepath.Ext(path)
+
+	switch serverName {
+	case "typescript", "typescript-language-server", "tsserver", "vtsls":
+		// For TypeScript, we want to open configuration files immediately
+		return fileName == "tsconfig.json" ||
+			fileName == "package.json" ||
+			fileName == "jsconfig.json" ||
+			// Also open main entry points
+			fileName == "index.ts" ||
+			fileName == "index.js" ||
+			fileName == "main.ts" ||
+			fileName == "main.js"
+	case "gopls":
+		// For Go, we want to open go.mod files immediately
+		return fileName == "go.mod" || 
+			fileName == "go.sum" ||
+			// Also open main.go files
+			fileName == "main.go"
+	case "rust-analyzer":
+		// For Rust, we want to open Cargo.toml files immediately
+		return fileName == "Cargo.toml" || 
+			fileName == "Cargo.lock" ||
+			// Also open lib.rs and main.rs
+			fileName == "lib.rs" ||
+			fileName == "main.rs"
+	case "python", "pyright", "pylsp":
+		// For Python, open key project files
+		return fileName == "pyproject.toml" ||
+			fileName == "setup.py" ||
+			fileName == "requirements.txt" ||
+			fileName == "__init__.py" ||
+			fileName == "__main__.py"
+	case "clangd":
+		// For C/C++, open key project files
+		return fileName == "CMakeLists.txt" ||
+			fileName == "Makefile" ||
+			fileName == "compile_commands.json"
+	case "java", "jdtls":
+		// For Java, open key project files
+		return fileName == "pom.xml" ||
+			fileName == "build.gradle" ||
+			ext == ".java" // Java servers often need to see source files
+	}
+
+	// For unknown servers, prioritize common configuration files
+	return fileName == "package.json" ||
+		fileName == "Makefile" ||
+		fileName == "CMakeLists.txt" ||
+		fileName == ".editorconfig"
+}

internal/tui/components/chat/chat.go

@@ -2,6 +2,7 @@ package chat
 
 import (
 	"fmt"
+	"sort"
 
 	"github.com/charmbracelet/lipgloss"
 	"github.com/charmbracelet/x/ansi"
@@ -28,8 +29,16 @@ func lspsConfigured(width int) string {
 
 	lsps := styles.BaseStyle.Width(width).Foreground(styles.PrimaryColor).Bold(true).Render(title)
 
+	// Get LSP names and sort them for consistent ordering
+	var lspNames []string
+	for name := range cfg.LSP {
+		lspNames = append(lspNames, name)
+	}
+	sort.Strings(lspNames)
+
 	var lspViews []string
-	for name, lsp := range cfg.LSP {
+	for _, name := range lspNames {
+		lsp := cfg.LSP[name]
 		lspName := styles.BaseStyle.Foreground(styles.Forground).Render(
 			fmt.Sprintf("• %s", name),
 		)
@@ -49,7 +58,6 @@ func lspsConfigured(width int) string {
 					),
 				),
 		)
-
 	}
 	return styles.BaseStyle.
 		Width(width).

internal/tui/components/chat/list.go

@@ -376,14 +376,7 @@ func (m *messagesCmp) working() string {
 		if hasToolsWithoutResponse(m.messages) {
 			task = "Waiting for tool response..."
 		} else if !lastMessage.IsFinished() {
-			lastUpdate := lastMessage.UpdatedAt
-			currentTime := time.Now().Unix()
-			if lastMessage.Content().String() != "" && lastUpdate != 0 && currentTime-lastUpdate > 5 {
-				task = "Building tool call..."
-			} else if lastMessage.Content().String() == "" {
-				task = "Generating..."
-			}
-			task = ""
+			task = "Generating..."
 		}
 		if task != "" {
 			text += styles.BaseStyle.Width(m.width).Foreground(styles.PrimaryColor).Bold(true).Render(

internal/tui/components/chat/message.go

@@ -151,7 +151,11 @@ func renderAssistantMessage(
 			))
 		}
 	}
-	if content != "" {
+	if content != "" || (finished && finishData.Reason == message.FinishReasonEndTurn) {
+		if content == "" {
+			content = "*Finished without output*"
+		}
+
 		content = renderMessage(content, false, msg.ID == focusedUIMessageId, width, info...)
 		messages = append(messages, uiMessage{
 			ID:          msg.ID,

internal/tui/components/core/status.go

@@ -138,6 +138,23 @@ func (m statusCmp) View() string {
 }
 
 func (m *statusCmp) projectDiagnostics() string {
+	// Check if any LSP server is still initializing
+	initializing := false
+	for _, client := range m.lspClients {
+		if client.GetServerState() == lsp.StateStarting {
+			initializing = true
+			break
+		}
+	}
+	
+	// If any server is initializing, show that status
+	if initializing {
+		return lipgloss.NewStyle().
+			Background(styles.BackgroundDarker).
+			Foreground(styles.Peach).
+			Render(fmt.Sprintf("%s Initializing LSP...", styles.SpinnerIcon))
+	}
+	
 	errorDiagnostics := []protocol.Diagnostic{}
 	warnDiagnostics := []protocol.Diagnostic{}
 	hintDiagnostics := []protocol.Diagnostic{}

internal/tui/styles/icons.go

@@ -6,7 +6,8 @@ const (
 	CheckIcon   string = "✓"
 	ErrorIcon   string = "✖"
 	WarningIcon string = "⚠"
-	InfoIcon    string = ""
+	InfoIcon    string = ""
 	HintIcon    string = "i"
 	SpinnerIcon string = "..."
-)
+	LoadingIcon string = "⟳"
+)