New feature: generate project by AI

Author: ktiays

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

@@ -5,14 +5,9 @@ pub(super) mod user_message;
 pub(super) mod user_request;
 
 pub(super) use bot_message::*;
-use rand::Rng;
 pub(super) use request_body::*;
 pub(super) use user_request::*;
 
-fn random() -> i32 {
-    rand::thread_rng().gen_range(0..=1000)
-}
-
 // Split the code into chunks of 20 line blocks.
 pub fn split_code_into_blocks(code: &str) -> Vec<String> {
     let lines = code.split("\n");

crates/cursor-core/src/project/handler.rs

@@ -0,0 +1,41 @@
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(typescript_custom_section)]
+const IPROJECT_HANDLER: &'static str = r#"
+interface IProjectHandler {
+    async createFileRecursive(path: string): void;
+    makeFileWriter(path: string): IProjectFileWriter | undefined;
+}
+"#;
+
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(typescript_type = "IProjectHandler")]
+    pub type ProjectHandler;
+
+    #[wasm_bindgen(method, structural, js_name = createFileRecursive)]
+    pub async fn create_file_recursive(this: &ProjectHandler, path: &str);
+
+    #[wasm_bindgen(method, structural, js_name = makeFileWriter)]
+    pub fn make_file_writer(this: &ProjectHandler, path: &str) -> Option<ProjectFileWriter>;
+}
+
+#[wasm_bindgen(typescript_custom_section)]
+const IPROJECT_FILE_WRITER: &'static str = r#"
+interface IProjectFileWriter {
+    write(contents: string): void;
+    end(): void;
+}
+"#;
+
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(typescript_type = "IProjectFileWriter")]
+    pub type ProjectFileWriter;
+
+    #[wasm_bindgen(method, structural)]
+    pub fn write(this: &ProjectFileWriter, contents: &str);
+
+    #[wasm_bindgen(method, structural)]
+    pub fn end(this: &ProjectFileWriter);
+}

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

@@ -1,3 +1,5 @@
+mod handler;
+
 use futures::StreamExt;
 use node_bridge::{bindings::AbortSignal, prelude::*};
 use serde_json::json;
@@ -12,6 +14,8 @@ use crate::{
     request::stream::{make_stream_request, StreamResponseState},
 };
 
+use self::handler::ProjectHandler;
+
 const STEP_MESSAGE: &str = "cursor-step";
 const CREATE_MESSAGE: &str = "cursor-create";
 const APPEND_MESSAGE: &str = "cursor-append";
@@ -35,7 +39,7 @@ impl Task {
 }
 
 #[wasm_bindgen(js_name = generateProject)]
-pub async fn generate_project(prompt: &str) -> Result<JsValue, JsValue> {
+pub async fn generate_project(prompt: &str, handler: ProjectHandler) -> Result<JsValue, JsValue> {
     let prompt = prompt.to_owned();
     Ok(get_extension_context()
         .with_progress(
@@ -53,6 +57,7 @@ pub async fn generate_project(prompt: &str) -> Result<JsValue, JsValue> {
                             .into();
                     let mut data_stream = state.data_stream();
                     let mut current_task = None;
+                    let mut file_writer = None;
                     while let Some(data) = data_stream.next().await {
                         #[cfg(debug_assertions)]
                         console::log_str(&data);
@@ -65,30 +70,39 @@ pub async fn generate_project(prompt: &str) -> Result<JsValue, JsValue> {
                             current_task = Some(Task::Step(task.to_owned()));
                         } else if data.starts_with(CREATE_MESSAGE) {
                             let task = data[CREATE_MESSAGE.len() + 1..].trim();
-                            current_task = Some(Task::Create(task.to_owned()));
+                            current_task = Some(Task::Create(format!("Creating {}", task)));
+
+                            // The title of the "create" message is a file path,
+                            // which requires creating a file based on the path.
+                            handler.create_file_recursive(task).await;
                         } else if data.starts_with(APPEND_MESSAGE) {
                             let task = data[APPEND_MESSAGE.len() + 1..].trim();
-                            current_task = Some(Task::Append(task.to_owned()));
+                            current_task =
+                                Some(Task::Append(format!("Appending contents to {}", task)));
+
+                            file_writer = handler.make_file_writer(task);
                         } else if data.starts_with(END_MESSAGE) {
                             current_task = None;
+                            file_writer.as_ref().map(|w| w.end());
+                            file_writer = None;
                         } else if data.starts_with(FINISHED_MESSAGE) {
+                            file_writer.as_ref().map(|w| w.end());
                             break;
+                        } else {
+                            match &current_task {
+                                Some(Task::Append(_)) => {
+                                    if let Some(writer) = file_writer.as_ref() {
+                                        writer.write(&data);
+                                    }
+                                }
+                                _ => {}
+                            }
                         }
 
                         // The message sent by the report will automatically disappear after a short period of time.
                         // In order to keep the text displayed on the dialog box, report the title every time data is returned.
                         if current_task.is_some() {
                             progress.report(current_task.as_ref().unwrap().title());
-                            continue;
-                        }
-                        match &current_task {
-                            Some(Task::Create(_)) => {
-                                todo!()
-                            }
-                            Some(Task::Append(_)) => {
-                                todo!()
-                            }
-                            _ => {}
                         }
                     }
                     drop(data_stream);

package.json

@@ -84,6 +84,7 @@
             {
                 "command": "aicursor.generateProject",
                 "title": "Generate Project",
+                "enablement": "workspaceFolders != null && workspaceFolderCount > 0",
                 "category": "CodeCursor"
             }
         ],

src/extension/index.ts

@@ -1,5 +1,6 @@
 import * as vscode from "vscode";
 import * as crypto from "crypto";
+import * as fs from "node:fs";
 
 import { GenerateSession, getScratchpadManager } from "./generate";
 import { getGlobalState } from "./globalState";

src/extension/project.ts

@@ -1,13 +1,84 @@
 import * as vscode from "vscode";
+import * as fs from "node:fs";
 import { generateProject } from "@crates/cursor-core";
 
 export async function handleGenerateProjectCommand() {
+    const workspace = getCurrentWorkspace();
+    if (!workspace) {
+        return;
+    }
+
     const input = await vscode.window.showInputBox({
         title: "Generate A New Project",
         placeHolder: "Instructions for project to generate...",
     });
     if (!input) {
         return;
     }
-    await generateProject(input);
+
+    // Check if the workspace is empty.
+    const files = await vscode.workspace.fs.readDirectory(workspace.uri);
+    // Exclude hidden files.
+    files.filter((file) => !file[0].startsWith("."));
+    if (files.length > 0) {
+        const confirmMessage = "Yes, I am sure";
+        const cancelMessage = "No";
+        const result = await vscode.window.showWarningMessage(
+            "The current workspace is not empty. Your existing files may be accidentally modified. Are you sure you want to continue?",
+            confirmMessage,
+            cancelMessage
+        );
+        if (result !== confirmMessage) {
+            return;
+        }
+    }
+
+    await generateProject(input, {
+        async createFileRecursive(path) {
+            // `path` is the relative path to the current workspace.
+            const absolutePath = getAbsolutePath(path);
+            if (!absolutePath) {
+                return;
+            }
+            // Create a file and recursively create intermediate folders if they do not exist.
+            const uri = vscode.Uri.file(absolutePath);
+            const parent = uri.with({
+                path: uri.path.substring(0, uri.path.lastIndexOf("/")),
+            });
+            await vscode.workspace.fs.createDirectory(parent);
+            await vscode.workspace.fs.writeFile(uri, new Uint8Array());
+        },
+        makeFileWriter(path) {
+            const absolutePath = getAbsolutePath(path);
+            if (!absolutePath) {
+                return;
+            }
+            // Using the ability of stream writing files provided by NodeJS.
+            const writeStream = fs.createWriteStream(absolutePath);
+            return {
+                write(data) {
+                    writeStream.write(data);
+                },
+                end() {
+                    writeStream.end();
+                },
+            };
+        },
+    });
+}
+
+function getAbsolutePath(path: string) {
+    const workspace = getCurrentWorkspace();
+    if (!workspace) {
+        return;
+    }
+    return workspace.uri.path + "/" + path;
+}
+
+function getCurrentWorkspace() {
+    const workspaceFolders = vscode.workspace.workspaceFolders;
+    if (!workspaceFolders) {
+        return;
+    }
+    return workspaceFolders[0];
 }