Optimize project structure

Author: ktiays

Cargo.lock

@@ -18,4 +18,5 @@ chrono = "0.4"
 js-sys = "0.3"
 sha256 = "1"
 rand = "0.8"
-getrandom = { version = "0.2", features = ["js"] }
+getrandom = { version = "0.2", features = ["js"] }
+uuid = { version = "1", features = ["v4", "wasm-bindgen"] }

crates/cursor-core/Cargo.toml

@@ -1,10 +1,8 @@
-use node_bridge::prelude::*;
 use rand::RngCore;
-use wasm_bindgen::prelude::*;
 
 fn random_bytes() -> Vec<u8> {
     let mut rng = rand::thread_rng();
     let mut bytes = vec![0u8; 32];
-    rng.try_fill_bytes(&mut bytes);
+    let _ = rng.try_fill_bytes(&mut bytes);
     bytes
 }

crates/cursor-core/src/auth/mod.rs

@@ -1,10 +1,13 @@
 use futures::StreamExt;
-use node_bridge::{bindings::uuid, prelude::*};
+use node_bridge::prelude::*;
+use uuid::Uuid;
 use wasm_bindgen::JsValue;
 
 use crate::{
-    models::{user_message::UserMessage, BotMessage, MessageType, RequestBody, UserRequest},
-    request::make_request,
+    conversation::{
+        make_conversation_request,
+        models::{user_message::UserMessage, BotMessage, MessageType, RequestBody, UserRequest},
+    },
     GenerateInput,
 };
 
@@ -60,13 +63,13 @@ impl Session {
     pub fn new() -> Self {
         Self {
             request_body: None,
-            conversation_id: uuid::uuid_v4(),
+            conversation_id: Uuid::new_v4().to_string(),
         }
     }
 
     pub async fn send_message(&mut self, input: &GenerateInput) -> Result<(), JsValue> {
         let request_body = self.body_with_input(input);
-        let mut state = make_request("/conversation", request_body, true).await?;
+        let mut state = make_conversation_request("/conversation", request_body, true).await?;
 
         let mut message: String = "".to_owned();
 

crates/cursor-core/src/chat/mod.rs …cursor-core/src/conversation/chat/mod.rscrates/cursor-core/src/chat/mod.rs renamed to crates/cursor-core/src/conversation/chat/mod.rs crates/cursor-core/src/chat/mod.rs renamed to crates/cursor-core/src/conversation/chat/mod.rs

@@ -1,14 +1,21 @@
 use std::future::IntoFuture;
 
-use crate::{models::*, request::make_request, GenerateInput};
 use futures::{
     future::{select, Either},
     StreamExt,
 };
 use node_bridge::futures::Defer;
 use node_bridge::prelude::*;
+use uuid::Uuid;
 use wasm_bindgen::prelude::*;
 
+use crate::GenerateInput;
+
+use super::{
+    make_conversation_request,
+    models::{BotMessage, MessageType, RequestBody},
+};
+
 async fn generate_code_inner(input: &GenerateInput) -> Result<(), JsValue> {
     let file_path = input.file_path();
     let selection = input.selection_range();
@@ -34,7 +41,7 @@ async fn generate_code_inner(input: &GenerateInput) -> Result<(), JsValue> {
         #[cfg(debug_assertions)]
         console::log_str(&serde_json::to_string(&request_body).unwrap());
 
-        let mut state = make_request(
+        let mut state = make_conversation_request(
             if interrupted {
                 "/continue/"
             } else {
@@ -78,7 +85,7 @@ async fn generate_code_inner(input: &GenerateInput) -> Result<(), JsValue> {
 
         // Generate an UUID as conversation ID.
         if conversation_id.is_none() {
-            conversation_id = Some(node_bridge::bindings::uuid::uuid_v4());
+            conversation_id = Some(Uuid::new_v4().to_string());
         }
         let bot_message = BotMessage::new(
             conversation_id.clone().unwrap(),

crates/cursor-core/src/chat/session.rs …or-core/src/conversation/chat/session.rscrates/cursor-core/src/chat/session.rs renamed to crates/cursor-core/src/conversation/chat/session.rs crates/cursor-core/src/chat/session.rs renamed to crates/cursor-core/src/conversation/chat/session.rs

@@ -0,0 +1,108 @@
+pub mod chat;
+pub mod generate;
+pub mod models;
+
+use std::cell::Cell;
+
+use futures::{stream, Stream, StreamExt};
+use node_bridge::{
+    http_client::{HttpMethod, HttpResponse},
+    prelude::console,
+};
+use wasm_bindgen::JsValue;
+
+use crate::request::make_request;
+
+use self::models::RequestBody;
+
+struct ResponseState {
+    response: HttpResponse,
+    started: Cell<bool>,
+    ended: Cell<bool>,
+    first_newline_dropped: Cell<bool>,
+    expect_begin_message: bool,
+}
+
+impl ResponseState {
+    fn new(response: HttpResponse, expect_begin_message: bool) -> Self {
+        Self {
+            response,
+            started: Cell::new(false),
+            ended: Cell::new(false),
+            first_newline_dropped: Cell::new(false),
+            expect_begin_message,
+        }
+    }
+
+    pub fn data_stream(&mut self) -> impl Stream<Item = String> + '_ {
+        #[cfg(debug_assertions)]
+        if !self.expect_begin_message {
+            console::log_str(&format!("ignore begin message"));
+        }
+        self.started.set(!self.expect_begin_message);
+
+        self.response.body().flat_map(|chunk| {
+            let chunk = chunk.to_string("utf-8");
+            #[cfg(debug_assertions)]
+            console::log_str(&chunk);
+
+            let lines: Vec<_> = chunk
+                .split("\n")
+                .filter_map(|l| {
+                    if l.len() > 0 && l.starts_with("data: \"") {
+                        serde_json::from_str::<String>(&l["data: ".len()..]).ok()
+                    } else {
+                        None
+                    }
+                })
+                .filter(|s| {
+                    if self.ended.get() {
+                        return false;
+                    }
+                    if s == "<|BEGIN_message|>" {
+                        self.started.set(true);
+                        return false;
+                    }
+                    if s == "<|END_message|>" {
+                        self.ended.set(true);
+                        return false;
+                    }
+                    if !self.started.get() {
+                        return false;
+                    }
+                    // Server may produce newlines at the head of response, we need
+                    // to do this trick to ignore them in the final edit.
+                    if !self.first_newline_dropped.get()
+                        && s.trim().is_empty()
+                        && self.expect_begin_message
+                    {
+                        self.first_newline_dropped.set(true);
+                        return false;
+                    }
+                    true
+                })
+                .collect();
+            stream::iter(lines)
+        })
+    }
+
+    pub async fn complete(self) -> Result<(), JsValue> {
+        self.response.await
+    }
+}
+
+async fn make_conversation_request(
+    path: &str,
+    body: &RequestBody,
+    expect_begin_message: bool,
+) -> Result<ResponseState, JsValue> {
+    let response = make_request(path, body, HttpMethod::Post).await?;
+    if response.status_code() != 200 {
+        return Err(js_sys::Error::new(&format!(
+            "Server returned status code {}",
+            response.status_code()
+        ))
+        .into());
+    }
+    Ok(ResponseState::new(response, expect_begin_message))
+}

crates/cursor-core/src/generate/mod.rs …or-core/src/conversation/generate/mod.rscrates/cursor-core/src/generate/mod.rs renamed to crates/cursor-core/src/conversation/generate/mod.rs crates/cursor-core/src/generate/mod.rs renamed to crates/cursor-core/src/conversation/generate/mod.rs

@@ -1,6 +1,6 @@
 use serde::Serialize;
 
-use super::{random, request_body::MessageType};
+use super::{request_body::MessageType, random};
 
 #[derive(Debug, Serialize, Clone)]
 pub struct BotMessage {

crates/cursor-core/src/conversation/mod.rs

@@ -1,15 +1,16 @@
-pub(crate) mod bot_message;
+mod bot_message;
 mod code_area;
-pub(crate) mod request_body;
-pub(crate) mod user_message;
-pub(crate) mod user_request;
+pub(super) mod request_body;
+pub(super) mod user_message;
+pub(super) mod user_request;
 
-pub(crate) use bot_message::*;
-pub(crate) use request_body::*;
-pub(crate) use user_request::*;
+pub(super) use bot_message::*;
+use rand::Rng;
+pub(super) use request_body::*;
+pub(super) use user_request::*;
 
 fn random() -> i32 {
-    js_sys::Math::floor(js_sys::Math::random() * 1000.0) as i32
+    rand::thread_rng().gen_range(0..=1000)
 }
 
 // Split the code into chunks of 20 line blocks.