Add custom initialization for ts lang server. All files must be open

Author: isaacphi

README.md

@@ -3,11 +3,13 @@
 A Model Context Protocol (MCP) server that runs a language server and provides tools for communicating with it.
 
 ## Motivation
+
 Claude desktop with the [filesystem](https://github.com/modelcontextprotocol/servers/tree/main/src/filesystem) server feels like magic when working on small projects. This starts to fall apart after you add a few files and imports. With this project, I want to create that experience when working with large projects.
 
 Language servers excel at tasks that LLMs often struggle with, such as precisely understanding types, understanding relationships, and providing accurate symbol references. This project aims to makes bring those tools to LLMs. LSP also seems like a clear inspiration for MCP so why not jam them together?
 
 ## Status
+
 ⚠️ Pre-beta Quality ⚠️
 
 I have tested this server with the following language servers
@@ -20,6 +22,7 @@ I have tested this server with the following language servers
 But it should be compatible with many more.
 
 ## Tools
+
 - `read_definition`: Retrieves the complete source code definition of any symbol (function, type, constant, etc.) from your codebase.
 - `find_references`: Locates all usages and references of a symbol throughout the codebase.
 - `get_diagnostics`: Provides diagnostic information for a specific file, including warnings and errors.
@@ -32,14 +35,17 @@ Behind the scenes, this MCP server can act on `workspace/applyEdit` requests fro
 Each tool supports various options for customizing output, such as including line numbers or additional context. See the tool documentation for detailed usage. Line numbers are necessary for `apply_text_edit` to be able to make accurate edits.
 
 ## About
+
 This codebase makes use of edited code from [gopls](https://go.googlesource.com/tools/+/refs/heads/master/gopls/internal/protocol) to handle LSP communication. See ATTRIBUTION for details.
 
 [mcp-golang](https://github.com/metoro-io/mcp-golang) is used for MCP communication.
 
 ## Prerequisites
-Install Go: Follow instructions at https://golang.org/doc/install
+
+Install Go: Follow instructions at <https://golang.org/doc/install>
 
 Fetch or update this server:
+
 ```bash
 go install github.com/isaacphi/mcp-language-server@latest
 ```
@@ -53,6 +59,7 @@ Install a language server for your codebase:
 - Or use any language server
 
 ## Setup
+
 Add something like the following configuration to your Claude Desktop settings (or similar MCP-enabled client):
 
 ```json
@@ -87,6 +94,7 @@ Replace:
 - `DEBUG=1` is optional. See below.
 
 ## Development
+
 Clone the repository:
 
 ```bash
@@ -126,19 +134,23 @@ Configure your Claude Desktop (or similar) to use the local binary:
   }
 }
 ```
+
 Rebuild after making changes.
 
 ## Feedback
 
 Include
+
 ```
 env: {
   "DEBUG": 1
 }
 ```
+
 To get detailed LSP and application logs. Please include as much information as possible when opening issues.
 
 The following features are on my radar:
+
 - [x] Read definition
 - [x] Get references
 - [x] Apply edit

cmd/test-lsp/main.go

@@ -11,7 +11,6 @@ import (
 	"time"
 
 	"github.com/isaacphi/mcp-language-server/internal/lsp"
-	"github.com/isaacphi/mcp-language-server/internal/protocol"
 	"github.com/isaacphi/mcp-language-server/internal/tools"
 )
 
@@ -80,23 +79,18 @@ func main() {
 	}
 	fmt.Printf("Server capabilities: %+v\n\n", initResult.Capabilities)
 
-	err = client.Initialized(ctx, protocol.InitializedParams{})
-	if err != nil {
-		log.Fatalf("Initialized notification failed: %v", err)
-	}
-
 	if err := client.WaitForServerReady(ctx); err != nil {
 		log.Fatalf("Server failed to become ready: %v", err)
 	}
 
 	///////////////////////////////////////////////////////////////////////////
 	// Test Tools
-	// response, err := tools.ReadDefinition(ctx, client, cfg.keyword, true)
-	// if err != nil {
-	// 	log.Fatalf("ReadDefinition failed: %v", err)
-	// }
-	// fmt.Println(response)
-	//
+	response, err := tools.ReadDefinition(ctx, client, cfg.keyword, true)
+	if err != nil {
+		log.Fatalf("ReadDefinition failed: %v", err)
+	}
+	fmt.Println(response)
+
 	// edits := []tools.TextEdit{
 	// 	tools.TextEdit{
 	// 		Type:      tools.Insert,
@@ -117,11 +111,11 @@ func main() {
 	// }
 	// fmt.Println(response)
 
-	response, err := tools.GetDiagnosticsForFile(ctx, client, cfg.keyword, true, true)
-	if err != nil {
-		log.Fatalf("GetDiagnostics failed: %v", err)
-	}
-	fmt.Println(response)
+	// response, err = tools.GetDiagnosticsForFile(ctx, client, cfg.keyword, true, true)
+	// if err != nil {
+	// 	log.Fatalf("GetDiagnostics failed: %v", err)
+	// }
+	// fmt.Println(response)
 
 	time.Sleep(time.Second * 1)
 

internal/lsp/client.go

@@ -6,8 +6,10 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
+	"log"
 	"os"
 	"os/exec"
+	"strings"
 	"sync"
 	"sync/atomic"
 	"time"
@@ -128,7 +130,8 @@ func (c *Client) InitializeLSPClient(ctx context.Context, workspaceDir string) (
 				Name:    "mcp-language-server",
 				Version: "0.1.0",
 			},
-			RootURI: protocol.DocumentUri("file://" + workspaceDir),
+			RootPath: workspaceDir,
+			RootURI:  protocol.DocumentUri("file://" + workspaceDir),
 			Capabilities: protocol.ClientCapabilities{
 				Workspace: protocol.WorkspaceClientCapabilities{
 					Configuration: true,
@@ -204,6 +207,22 @@ func (c *Client) InitializeLSPClient(ctx context.Context, workspaceDir string) (
 	c.RegisterNotificationHandler("textDocument/publishDiagnostics",
 		func(params json.RawMessage) { HandleDiagnostics(c, params) })
 
+	// Notify the LSP server
+	err := c.Initialized(ctx, protocol.InitializedParams{})
+	if err != nil {
+		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
 }
 
@@ -343,10 +362,13 @@ func (c *Client) CloseFile(ctx context.Context, filepath string) error {
 			URI: protocol.DocumentUri(uri),
 		},
 	}
+	log.Println("Closing", params.TextDocument.URI.Dir())
+	// TODO: properly close files. typescript-language-server currently
+	// doesn't work properly whith my file watcher implementation
 
-	if err := c.Notify(ctx, "textDocument/didClose", params); err != nil {
-		return err
-	}
+	// if err := c.Notify(ctx, "textDocument/didClose", params); err != nil {
+	// 	return err
+	// }
 
 	c.openFilesMu.Lock()
 	delete(c.openFiles, uri)

internal/lsp/initializeTypescriptLanguageServer.go

@@ -0,0 +1,65 @@
+package lsp
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+)
+
+// typescript-language-server requires files to be opened in order to load the project
+func initializeTypescriptLanguageServer(ctx context.Context, client *Client, rootDir string) error {
+	tsFiles, err := findAllTypeScriptFiles(rootDir)
+	if err != nil {
+		return fmt.Errorf("error finding TypeScript files: %w", err)
+	}
+
+	if len(tsFiles) == 0 {
+		return fmt.Errorf("no TypeScript files found in %s", rootDir)
+	}
+
+	// Open all the TypeScript files
+	for _, file := range tsFiles {
+		err = client.OpenFile(ctx, file)
+		if err != nil {
+			return fmt.Errorf("error opening TypeScript file %s: %w", file, err)
+		}
+	}
+
+	return nil
+}
+
+func findAllTypeScriptFiles(rootDir string) ([]string, error) {
+	var tsFiles []string
+
+	err := filepath.Walk(rootDir, func(path string, info os.FileInfo, err error) error {
+		// Check for walk errors
+		if err != nil {
+			return err
+		}
+
+		// Skip directories
+		if info.IsDir() {
+			// Skip node_modules directories
+			if info.Name() == "node_modules" {
+				return filepath.SkipDir
+			}
+			return nil
+		}
+
+		// Check if file has .ts or .tsx extension
+		ext := filepath.Ext(path)
+		if ext == ".ts" || ext == ".tsx" {
+			tsFiles = append(tsFiles, path)
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, fmt.Errorf("error walking directory: %w", err)
+	}
+
+	return tsFiles, nil
+}
+

main.go

@@ -13,7 +13,6 @@ import (
 	"time"
 
 	"github.com/isaacphi/mcp-language-server/internal/lsp"
-	"github.com/isaacphi/mcp-language-server/internal/protocol"
 	"github.com/isaacphi/mcp-language-server/internal/watcher"
 	"github.com/metoro-io/mcp-golang"
 	"github.com/metoro-io/mcp-golang/transport/stdio"
@@ -102,11 +101,6 @@ func (s *server) initializeLSP() error {
 		log.Printf("Server capabilities: %+v\n\n", initResult.Capabilities)
 	}
 
-	err = client.Initialized(s.ctx, protocol.InitializedParams{})
-	if err != nil {
-		return fmt.Errorf("initialized notification failed: %v", err)
-	}
-
 	go s.workspaceWatcher.WatchWorkspace(s.ctx, s.config.workspaceDir)
 	return client.WaitForServerReady(s.ctx)
 }
@@ -144,6 +138,7 @@ func main() {
 	parentDeath := make(chan struct{})
 
 	// Monitor parent process termination
+	// Claude desktop does not properly kill child processes for MCP servers
 	go func() {
 		ppid := os.Getppid()
 		if debug {