Added code action request

crates/lsp-ai/src/main.rs

@@ -2,8 +2,9 @@ use anyhow::Result;
 
 use lsp_server::{Connection, ExtractError, Message, Notification, Request, RequestId};
 use lsp_types::{
-    request::Completion, CompletionOptions, DidChangeTextDocumentParams, DidOpenTextDocumentParams,
+    request::{CodeActionRequest, Completion},
-    RenameFilesParams, ServerCapabilities, TextDocumentSyncKind,
+    CompletionOptions, DidChangeTextDocumentParams, DidOpenTextDocumentParams, RenameFilesParams,
+    ServerCapabilities, TextDocumentSyncKind,
 };
 use std::{
     collections::HashMap,
@@ -30,7 +31,9 @@ use config::Config;
 use custom_requests::generation::Generation;
 use memory_backends::MemoryBackend;
 use transformer_backends::TransformerBackend;
-use transformer_worker::{CompletionRequest, GenerationRequest, WorkerRequest};
+use transformer_worker::{
+    CodeActionRequestRequest, CompletionRequest, GenerationRequest, WorkerRequest,
+};
 
 use crate::{
     custom_requests::generation_stream::GenerationStream,
@@ -73,6 +76,7 @@ fn main() -> Result<()> {
         text_document_sync: Some(lsp_types::TextDocumentSyncCapability::Kind(
             TextDocumentSyncKind::INCREMENTAL,
         )),
+        code_action_provider: Some(lsp_types::CodeActionProviderCapability::Simple(true)),
         ..Default::default()
     })?;
     let initialization_args = connection.initialize(server_capabilities)?;
@@ -152,6 +156,15 @@ fn main_loop(connection: Connection, args: serde_json::Value) -> Result<()> {
                         }
                         Err(err) => error!("{err:?}"),
                     }
+                } else if request_is::<CodeActionRequest>(&req) {
+                    match cast::<CodeActionRequest>(req) {
+                        Ok((id, params)) => {
+                            let code_action_request = CodeActionRequestRequest::new(id, params);
+                            transformer_tx
+                                .send(WorkerRequest::CodeActionRequest(code_action_request))?;
+                        }
+                        Err(err) => error!("{err:?}"),
+                    }
                 } else {
                     error!("lsp-ai currently only supports textDocument/completion, textDocument/generation and textDocument/generationStream")
                 }

crates/lsp-ai/src/transformer_worker.rs

@@ -1,8 +1,8 @@
 use anyhow::Context;
 use lsp_server::{Connection, Message, RequestId, Response};
 use lsp_types::{
-    CompletionItem, CompletionItemKind, CompletionList, CompletionParams, CompletionResponse,
+    CodeActionParams, CompletionItem, CompletionItemKind, CompletionList, CompletionParams,
-    Position, Range, TextEdit,
+    CompletionResponse, Position, Range, TextEdit,
 };
 use std::collections::HashMap;
 use std::sync::mpsc::RecvTimeoutError;
@@ -57,11 +57,24 @@ impl GenerationStreamRequest {
     }
 }
 
+#[derive(Clone, Debug)]
+pub struct CodeActionRequestRequest {
+    id: RequestId,
+    params: CodeActionParams,
+}
+
+impl CodeActionRequestRequest {
+    pub fn new(id: RequestId, params: CodeActionParams) -> Self {
+        Self { id, params }
+    }
+}
+
 #[derive(Clone, Debug)]
 pub(crate) enum WorkerRequest {
     Completion(CompletionRequest),
     Generation(GenerationRequest),
     GenerationStream(GenerationStreamRequest),
+    CodeActionRequest(CodeActionRequestRequest),
 }
 
 impl WorkerRequest {
@@ -70,6 +83,7 @@ impl WorkerRequest {
             WorkerRequest::Completion(r) => r.id.clone(),
             WorkerRequest::Generation(r) => r.id.clone(),
             WorkerRequest::GenerationStream(r) => r.id.clone(),
+            WorkerRequest::CodeActionRequest(r) => r.id.clone(),
         }
     }
 }
@@ -297,9 +311,15 @@ async fn generate_response(
         WorkerRequest::GenerationStream(_) => {
             anyhow::bail!("Streaming is not yet supported")
         }
+        WorkerRequest::CodeActionRequest(request) => do_code_action(&request).await,
     }
 }
 
+async fn do_code_action(request: &CodeActionRequestRequest) -> anyhow::Result<Response> {
+    eprintln!("WE GOT HERE: {:?}", request);
+    todo!()
+}
+
 async fn do_completion(
     transformer_backend: &Box<dyn TransformerBackend + Send + Sync>,
     memory_backend_tx: std::sync::mpsc::Sender<memory_worker::WorkerRequest>,