┌─────────────────────────────────────────────────────────────────┐
│                        Editor (Client)                         │
│                                                                 │
│   ┌──────────────┐    ┌──────────────┐    ┌──────────────┐    │
│   │  TextEditor  │    │   LSP Client │    │  Diagnostics │    │
│   └──────┬───────┘    └──────┬───────┘    └──────────────┘    │
│          │                   │                                  │
│          └───────────────────┼────────────────────────────────┘
│                              │ JSON-RPC (stdin/stdout)
│                              ▼
│   ┌────────────────────────────────────────────────────────┐   │
│   │              Language Server (如 gopls)                 │   │
│   │                                                        │   │
│   │  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌───────┐ │   │
│   │  │Completions│  │ GotoDef  │  │ Hover    │  │Search │ │   │
│   │  └──────────┘  └──────────┘  └──────────┘  └───────┘ │   │
│   └────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Client                               Server
  │                                     │
  │ ─── initialize (request) ──────────▶│
  │                                     │
  │◀─── initialize (response) ──────────│
  │                                     │
  │ ─── initialized (notification) ──────▶│
  │                                     │
  │ ─── textDocument/didOpen ───────────▶│
  │ ─── textDocument/didChange ─────────▶│
  │                                     │
  │        ... ongoing communication ...  │
  │                                     │

internal/lsp/
├── client.go       # LSP 客户端核心
├── handlers.go    # 请求/通知处理器
├── transport.go   # 传输层实现
├── watcher/       # 文件监视器
├── util/          # 工具函数
└── protocol/      # LSP 协议定义

// internal/lsp/client.go
type Client struct {
    Cmd    *exec.Cmd
    stdin  io.WriteCloser
    stdout *bufio.Reader
    stderr io.ReadCloser

    // Request ID counter
    nextID atomic.Int32

    // Response handlers (等待响应的回调)
    handlers   map[int32]chan *Message
    handlersMu sync.RWMutex

    // Server request handlers (服务器发起的请求)
    serverRequestHandlers map[string]ServerRequestHandler
    notificationHandlers map[string]NotificationHandler

    // Diagnostic cache
    diagnostics   map[protocol.DocumentUri][]protocol.Diagnostic
    diagnosticsMu sync.RWMutex

    // Currently open files
    openFiles   map[string]*OpenFileInfo
    openFilesMu sync.RWMutex

    serverState atomic.Value
}

func NewClient(ctx context.Context, command string, args ...string) (*Client, error) {
    cmd := exec.CommandContext(ctx, command, args...)
    cmd.Env = os.Environ()  // 继承环境变量

    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()

    client := &Client{
        Cmd:                   cmd,
        stdin:                 stdin,
        stdout:                bufio.NewReader(stdout),
        handlers:              make(map[int32]chan *Message),
        serverRequestHandlers: make(map[string]ServerRequestHandler),
        notificationHandlers:  make(map[string]NotificationHandler),
        diagnostics:           make(map[protocol.DocumentUri][]protocol.Diagnostic),
        openFiles:             make(map[string]*OpenFileInfo),
    }

    // Start the LSP server process
    if err := cmd.Start(); err != nil {
        return nil, fmt.Errorf("failed to start LSP server: %w", err)
    }

    // Start reading messages in background
    go client.readMessages()

    return client, nil
}

func (c *Client) sendRequest(method string, params interface{}) (*Message, error) {
    id := c.nextID.Add(1)
    
    msg := Message{
        ID:     id,
        Method: method,
        Params: params,
    }
    
    // 创建响应 channel
    respCh := make(chan *Message, 1)
    c.handlersMu.Lock()
    c.handlers[id] = respCh
    c.handlersMu.Unlock()
    
    // 发送请求
    if err := c.writeMessage(msg); err != nil {
        return nil, err
    }
    
    // 等待响应
    select {
    case resp := <-respCh:
        return resp, nil
    case <-time.After(30 * time.Second):
        return nil, errors.New("request timeout")
    }
}

func (c *Client) readMessages() {
    for {
        msg, err := c.readMessage()
        if err != nil {
            if err == io.EOF {
                return  // 服务器关闭
            }
            logging.Error("Error reading LSP message", "error", err)
            continue
        }

        // 根据消息类型处理
        switch {
        case msg.ID != 0 && msg.Result != nil:
            // 响应消息：找到对应的请求处理器
            c.handlersMu.Lock()
            ch, ok := c.handlers[msg.ID]
            if ok {
                ch <- msg
                delete(c.handlers, msg.ID)
            }
            c.handlersMu.Unlock()

        case msg.Method != "" && msg.ID == 0:
            // 通知消息：查找并调用处理器
            c.notificationMu.RLock()
            handler, ok := c.notificationHandlers[msg.Method]
            c.notificationMu.RUnlock()
            if ok {
                go handler(msg.Params)
            }

        case msg.Method != "" && msg.ID != 0:
            // 服务器请求：调用处理器并发送响应
            c.serverHandlersMu.RLock()
            handler, ok := c.serverRequestHandlers[msg.Method]
            c.serverHandlersMu.RUnlock()
            if ok {
                result, err := handler(msg.Params)
                c.sendResponse(msg.ID, result, err)
            }
        }
    }
}

// 注册服务器请求处理器
func (c *Client) RegisterRequestHandler(method string, handler ServerRequestHandler) {
    c.serverHandlersMu.Lock()
    defer c.serverHandlersMu.Unlock()
    c.serverRequestHandlers[method] = handler
}

// 注册通知处理器
func (c *Client) RegisterNotificationHandler(method string, handler NotificationHandler) {
    c.notificationMu.Lock()
    defer c.notificationMu.Unlock()
    c.notificationHandlers[method] = handler
}

func (c *Client) Initialize(rootURI string) (*protocol.InitializeResult, error) {
    result, err := c.sendRequest("initialize", protocol.InitializeParams{
        RootURI: rootURI,
        Capabilities: protocol.ClientCapabilities{
            TextDocument: protocol.TextDocumentClientCapabilities{
                Synchronization: &protocol.TextDocumentSyncClientCapabilities{
                    WillSave: true,
                },
                Completion: &protocol.CompletionClientCapabilities{
                    CompletionItem: &protocol.CompletionItemCapability{
                        SnippetSupport: true,
                    },
                },
            },
        },
    })
    if err != nil {
        return nil, err
    }

    var initResult protocol.InitializeResult
    if err := json.Unmarshal(result.Result, &initResult); err != nil {
        return nil, err
    }

    // 发送 initialized 通知
    c.Notify("initialized", protocol.InitializedParams{})

    return &initResult, nil
}

// 打开文档
func (c *Client) DidOpen(ctx context.Context, uri, languageID, text string) error {
    c.openFilesMu.Lock()
    c.openFiles[uri] = &OpenFileInfo{
        LanguageID: languageID,
        Version:    1,
    }
    c.openFilesMu.Unlock()

    return c.Notify("textDocument/didOpen", protocol.DidOpenTextDocumentParams{
        TextDocument: protocol.TextDocumentItem{
            URI:       protocol.DocumentUri(uri),
            LanguageID: languageID,
            Version:    1,
            Text:       text,
        },
    })
}

// 文档变更
func (c *Client) DidChange(ctx context.Context, uri string, changes []protocol.TextDocumentContentChangeEvent) error {
    c.openFilesMu.Lock()
    if info, ok := c.openFiles[uri]; ok {
        info.Version++
    }
    c.openFilesMu.Unlock()

    return c.Notify("textDocument/didChange", protocol.DidChangeTextDocumentParams{
        TextDocument: protocol.VersionedTextDocumentIdentifier{
            URI:     protocol.DocumentUri(uri),
            Version: c.openFiles[uri].Version,
        },
        ContentChanges: changes,
    })
}

// 关闭文档
func (c *Client) DidClose(ctx context.Context, uri string) error {
    c.openFilesMu.Lock()
    delete(c.openFiles, uri)
    c.diagnosticsMu.Lock()
    delete(c.diagnostics, protocol.DocumentUri(uri))
    c.diagnosticsMu.Unlock()
    c.openFilesMu.Unlock()

    return c.Notify("textDocument/didClose", protocol.DidCloseTextDocumentParams{
        TextDocument: protocol.TextDocumentIdentifier{
            URI: protocol.DocumentUri(uri),
        },
    })
}

func (c *Client) Completion(ctx context.Context, uri string, position protocol.Position) (*protocol.CompletionList, error) {
    result, err := c.sendRequest("textDocument/completion", protocol.CompletionParams{
        TextDocumentPositionParams: protocol.TextDocumentPositionParams{
            TextDocument: protocol.TextDocumentIdentifier{
                URI: protocol.DocumentUri(uri),
            },
            Position: position,
        },
    })
    if err != nil {
        return nil, err
    }

    var completions protocol.CompletionList
    if err := json.Unmarshal(result.Result, &completions); err != nil {
        return nil, err
    }

    return &completions, nil
}

func (c *Client) GotoDefinition(ctx context.Context, uri string, position protocol.Position) ([]protocol.Location, error) {
    result, err := c.sendRequest("textDocument/definition", protocol.DefinitionParams{
        TextDocumentPositionParams: protocol.TextDocumentPositionParams{
            TextDocument: protocol.TextDocumentIdentifier{
                URI: protocol.DocumentUri(uri),
            },
            Position: position,
        },
    })
    if err != nil {
        return nil, err
    }

    var locations []protocol.Location
    if err := json.Unmarshal(result.Result, &locations); err != nil {
        return nil, err
    }

    return locations, nil
}

func (c *Client) Hover(ctx context.Context, uri string, position protocol.Position) (*protocol.Hover, error) {
    result, err := c.sendRequest("textDocument/hover", protocol.HoverParams{
        TextDocumentPositionParams: protocol.TextDocumentPositionParams{
            TextDocument: protocol.TextDocumentIdentifier{
                URI: protocol.DocumentUri(uri),
            },
            Position: position,
        },
    })
    if err != nil {
        return nil, err
    }

    if result.Result == nil {
        return nil, nil  // 没有悬停信息
    }

    var hover protocol.Hover
    if err := json.Unmarshal(result.Result, &hover); err != nil {
        return nil, err
    }

    return &hover, nil
}

// 列出文档中的符号
func (c *Client) DocumentSymbols(ctx context.Context, uri string) ([]protocol.DocumentSymbol, error) {
    result, err := c.sendRequest("textDocument/documentSymbol", protocol.DocumentSymbolParams{
        TextDocument: protocol.TextDocumentIdentifier{
            URI: protocol.DocumentUri(uri),
        },
    })
    if err != nil {
        return nil, err
    }

    var symbols []protocol.DocumentSymbol
    if err := json.Unmarshal(result.Result, &symbols); err != nil {
        return nil, err
    }

    return symbols, nil
}

// 搜索工作区中的符号
func (c *Client) WorkspaceSymbols(ctx context.Context, query string) ([]protocol.SymbolInformation, error) {
    result, err := c.sendRequest("workspace/symbol", protocol.WorkspaceSymbolParams{
        Query: query,
    })
    if err != nil {
        return nil, err
    }

    var symbols []protocol.SymbolInformation
    if err := json.Unmarshal(result.Result, &symbols); err != nil {
        return nil, err
    }

    return symbols, nil
}

func (c *Client) RegisterNotificationHandler(
    "textDocument/publishDiagnostics",
    func(params json.RawMessage) {
        var notification protocol.PublishDiagnosticsParams
        if err := json.Unmarshal(params, &notification); err != nil {
            logging.Error("Error unmarshaling diagnostics", "error", err)
            return
        }

        c.diagnosticsMu.Lock()
        c.diagnostics[notification.URI] = notification.Diagnostics
        c.diagnosticsMu.Unlock()
    },
)

func (c *Client) GetDiagnostics(ctx context.Context, uri string) []protocol.Diagnostic {
    c.diagnosticsMu.RLock()
    defer c.diagnosticsMu.RUnlock()
    return c.diagnostics[protocol.DocumentUri(uri)]
}

func HandleWorkspaceConfiguration(params json.RawMessage) (any, error) {
    // 返回空配置，让服务器使用默认配置
    return []map[string]any{{}}, 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 {
        logging.Error("Error applying workspace edit", "error", err)
        return protocol.ApplyWorkspaceEditResult{
            Applied: false,
            FailureReason: err.Error(),
        }, nil
    }

    return protocol.ApplyWorkspaceEditResult{Applied: true}, nil
}

func HandleRegisterCapability(params json.RawMessage) (any, error) {
    var registerParams protocol.RegistrationParams
    if err := json.Unmarshal(params, &registerParams); err != nil {
        return nil, err
    }

    for _, reg := range registerParams.Registrations {
        switch reg.Method {
        case "workspace/didChangeWatchedFiles":
            // 解析文件监视器注册
            optionsJSON, _ := json.Marshal(reg.RegisterOptions)
            var options protocol.DidChangeWatchedFilesRegistrationOptions
            json.Unmarshal(optionsJSON, &options)

            // 通知文件监视器处理器
            notifyFileWatchRegistration(reg.ID, options.Watchers)
        }
    }

    return nil, nil
}

// internal/app/app.go
type App struct {
    // ...
    LSPClients map[string]*lsp.Client  // 按语言命名的 LSP 客户端
    // ...
}

// internal/config/config.go
type LSPConfig struct {
    Disabled bool     `json:"enabled"`
    Command  string   `json:"command"`
    Args     []string `json:"args"`
    Options  any      `json:"options"`
}

// 配置示例
// {
//   "lsp": {
//     "gopls": {
//       "command": "gopls"
//     },
//     "typescript": {
//       "command": "typescript-language-server",
//       "args": ["--stdio"]
//     }
//   }
// }

// cmd/opencode.go
func run(cmd *cobra.Command, args []string) error {
    // 加载配置
    cfg, _ := config.Load(workingDir, debug)
    
    // 初始化 LSP 客户端
    lspClients := make(map[string]*lsp.Client)
    for name, lspConfig := range cfg.LSP {
        if lspConfig.Disabled {
            continue
        }
        
        ctx := context.Background()
        client, err := lsp.NewClient(ctx, lspConfig.Command, lspConfig.Args...)
        if err != nil {
            logging.Warn("Failed to start LSP server", "name", name, "error", err)
            continue
        }
        
        // 初始化
        rootURI := "file://" + workingDir
        _, err = client.Initialize(rootURI)
        if err != nil {
            logging.Warn("Failed to initialize LSP", "name", name, "error", err)
            continue
        }
        
        lspClients[name] = client
        logging.Info("Started LSP server", "name", name)
    }
    
    // 创建 App
    app := &app.App{
        LSPClients: lspClients,
        // ...
    }
    
    // ...
}

// internal/llm/tools/view.go
type ViewTool struct {
    lspClients map[string]*lsp.Client
}

// 工具中可以：
// 1. 获取当前文件的符号列表
// 2. 获取符号的定义位置
// 3. 获取悬停文档
// 4. 获取诊断信息

{
  "lsp": {
    "gopls": {
      "command": "gopls"
    },
    "typescript": {
      "command": "typescript-language-server",
      "args": ["--stdio"]
    },
    "clangd": {
      "command": "clangd",
      "args": ["--background-index"]
    }
  }
}

// 发送请求后立即返回，通过 channel 接收响应
result, err := c.sendRequest("textDocument/completion", params)