) -> impl IntoResponse {
104 | let response_html = format!(
105 | r#"
106 |
107 |
108 |
109 | Hello, {name}!
110 |
111 |
112 | Hello, {name}!
113 | The length of your name is {len} letters.
114 |
115 |
116 | "#,
117 | name = name,
118 | len = name.len()
119 | );
120 |
121 | poem::Response::builder()
122 | .header("Content-Type", "text/html; charset=utf-8")
123 | .body(response_html)
124 | }
125 | ```
126 |
127 | ## Explanation for Developers
128 |
129 | Auto-Rust utilizes Rust's powerful procedural macro system to inject code at compile time. When you use the `#[llm_tool]` macro:
130 |
131 | 1. **Parsing:** The macro parses the annotated function's signature, including its name, arguments, return type, and any doc comments.
132 |
133 | 2. **Context Extraction:** It extracts the code within your project, providing some context for the LLM to understand the surrounding code and project better.
134 |
135 | 3. **Prompt Engineering:** It constructs a prompt that includes the extracted information. This prompt is carefully designed to guide the LLM in generating a relevant and correct Rust function implementation.
136 |
137 | 4. **LLM Interaction:** It sends the generated prompt to an LLM API.
138 |
139 | 5. **Code Insertion:** The LLM's response, which contains the generated Rust code, is inserted directly into your codebase, replacing the `todo!()` placeholder.
140 |
141 | ## Limitations
142 |
143 | * **LLM Non-Determinism:** LLM output can vary. You might need to experiment and iterate to achieve the desired results.
144 | * **Limited Context:** Currently, Auto-Rust's context is primarily based on your function signature and doc comments. It has limited awareness of the broader project structure.
145 | * **Dependency Management:** Auto-Rust does not automatically add `use` statements for newly introduced dependencies in the generated code.
146 |
147 | ## Contributing
148 |
149 | We welcome contributions from the Rust community! If you encounter issues, have suggestions, or want to contribute to the development of `auto-rust`, please feel free to open an issue or submit a pull request.
150 |
151 | ## License
152 |
153 | This project is licensed under the MIT and Apache-2.0 licenses.
154 |
--------------------------------------------------------------------------------
/auto/Cargo.toml:
--------------------------------------------------------------------------------
1 | [lib]
2 | proc-macro = true
3 |
4 | [package]
5 | name = "auto-rust"
6 | version = "0.1.5"
7 | edition = "2021"
8 | description = "A tool to automatically generate Rust code using LLMs at compilation time."
9 | license = "MIT AND Apache-2.0"
10 |
11 | [dependencies]
12 | dotenv = "0.15.0"
13 | hyperpolyglot = "0.1.7"
14 | ignore = "0.4.22"
15 | md5 = "0.7.0"
16 | reqwest = { version = "0.12.4", features = ["blocking", "json"] }
17 | serde = "1.0.203"
18 | serde_derive = "1.0.203"
19 | serde_json = "1.0.117"
20 | syn = { version = "2.0.66", features = ["full"] }
21 | tinytemplate = "1.2.1"
22 |
--------------------------------------------------------------------------------
/auto/src/api.rs:
--------------------------------------------------------------------------------
1 | use reqwest::header;
2 | use serde_json::json;
3 | use std::env;
4 |
5 | use crate::data::ChatCompletionResponse;
6 |
7 | pub fn generic_chat_completion(
8 | system_message: String,
9 | user_message: String,
10 | ) -> Result> {
11 | let open_ai_key = env::var("OPENAI_API_KEY").unwrap();
12 | let model_name = env::var("OPENAI_MODEL_NAME").unwrap_or("gpt-3.5-turbo".to_string());
13 |
14 | let mut headers = header::HeaderMap::new();
15 |
16 | headers.insert("Content-Type", "application/json".parse().unwrap());
17 | headers.insert(
18 | "Authorization",
19 | format!("Bearer {}", open_ai_key).parse().unwrap(),
20 | );
21 |
22 | let client = reqwest::blocking::Client::builder()
23 | .redirect(reqwest::redirect::Policy::none())
24 | .build()
25 | .unwrap();
26 |
27 | let body = json!({
28 | "model": model_name,
29 | "messages": [
30 | {"role": "system", "content": system_message},
31 | {"role": "user", "content": user_message}
32 | ]
33 | });
34 |
35 | let res = client
36 | .post("https://openrouter.ai/api/v1/chat/completions")
37 | .headers(headers)
38 | .body(body.to_string())
39 | .send()?
40 | .json::()?;
41 |
42 | Ok(res)
43 | }
44 |
--------------------------------------------------------------------------------
/auto/src/cache.rs:
--------------------------------------------------------------------------------
1 | use serde_derive::{Deserialize, Serialize};
2 | use std::{fs::File, io::Write};
3 |
4 | const AUTO_ARTIFACTS_FOLDER: &str = ".auto";
5 |
6 | #[derive(Debug, Serialize, Deserialize)]
7 | pub struct ResolvedSourceCode {
8 | pub prompt_input: String,
9 | pub implementation: String,
10 | pub hash: String,
11 | }
12 |
13 | impl ResolvedSourceCode {
14 | pub fn save(&self) {
15 | std::fs::create_dir_all(AUTO_ARTIFACTS_FOLDER).unwrap();
16 |
17 | let filepath = format!("{}/{}.json", AUTO_ARTIFACTS_FOLDER, self.hash);
18 |
19 | let mut file = File::create(filepath).unwrap();
20 | let json = serde_json::to_string_pretty(&self).unwrap();
21 | file.write_all(json.as_bytes()).unwrap();
22 | }
23 |
24 | pub fn load(hash: &str) -> Option {
25 | let filepath = format!("{}/{}.json", AUTO_ARTIFACTS_FOLDER, hash);
26 |
27 | if let Ok(file) = File::open(filepath) {
28 | let reader = std::io::BufReader::new(file);
29 | let res: Self = serde_json::from_reader(reader).unwrap();
30 | Some(res)
31 | } else {
32 | None
33 | }
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/auto/src/data.rs:
--------------------------------------------------------------------------------
1 | use serde_derive::Deserialize;
2 | use serde_derive::Serialize;
3 |
4 | #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
5 | #[serde(rename_all = "camelCase")]
6 | pub struct ChatCompletionResponse {
7 | pub id: String,
8 | pub object: String,
9 | pub created: i64,
10 | pub choices: Vec,
11 | pub usage: Usage,
12 | }
13 |
14 | #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
15 | #[serde(rename_all = "camelCase")]
16 | pub struct Choice {
17 | pub index: i64,
18 | pub message: Message,
19 | #[serde(rename = "finish_reason")]
20 | pub finish_reason: String,
21 | }
22 |
23 | #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
24 | #[serde(rename_all = "camelCase")]
25 | pub struct Message {
26 | pub role: String,
27 | pub content: String,
28 | }
29 |
30 | #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
31 | #[serde(rename_all = "camelCase")]
32 | pub struct Usage {
33 | #[serde(rename = "prompt_tokens")]
34 | pub prompt_tokens: i64,
35 | #[serde(rename = "completion_tokens")]
36 | pub completion_tokens: i64,
37 | #[serde(rename = "total_tokens")]
38 | pub total_tokens: i64,
39 | }
40 |
--------------------------------------------------------------------------------
/auto/src/generator.rs:
--------------------------------------------------------------------------------
1 | use std::error::Error;
2 |
3 | use crate::api::generic_chat_completion;
4 |
5 | pub fn generate_body_function_from_head(
6 | head: String,
7 | extra_context: Option,
8 | ) -> Result> {
9 | let system_message = "
10 | You are an advanced AI, trained on the GPT-4 architecture, with expertise in Rust programming. Your task is to generate the body of a Rust function based on its signature. Please adhere to these guidelines:
11 |
12 | 1. Receive the Function Signature: The signature will be provided in a standard Rust format, e.g., 'fn calculate_pi_with_n_iterations(n: u64) -> f64'. Focus on understanding the function's name, parameters, and return type.
13 | 2. Generate Only the Function Body: You are required to write Rust code that fulfills the requirements of the function signature. This code should be the function body only, without including the function signature or any other wrapping code.
14 | 3. Exclude Non-Essential Content: Your response must strictly contain valid Rust code applicable within the function's curly braces. Do not include comments, attributes, nested functions, or any redundant repetitions of the function signature. Do not include any explanation or additional text outside of the function body.
15 | 4. Maintain Simplicity and Clarity: Avoid external crates, unnecessary imports, or extra features like feature flags. Use standard Rust libraries and functionalities. The code should be clear, maintainable, and compile-ready.
16 | 5. Adhere to Rust Best Practices: Ensure that the generated code is idiomatic, efficient, and adheres to Rust standards and best practices.
17 |
18 | Example:
19 | INPUT SIGNATURE: 'fn calculate_pi_with_n_iterations(n: u64) -> f64'
20 | EXPECTED OUTPUT (Function Body Only):
21 | let mut pi = 0.0;
22 | let mut sign = 1.0;
23 | for i in 0..n {
24 | pi += sign / (2 * i + 1) as f64;
25 | sign = -sign;
26 | }
27 | 4.0 * pi
28 | ".to_string();
29 |
30 | let user_message = extra_context
31 | .map(|c| format!("Extra context: {}\n", c))
32 | .unwrap_or("".to_string())
33 | + &format!(
34 | "Function signature: {}\nGenerate only the function body.",
35 | head
36 | );
37 |
38 | // Call the external LLM API to get the function body
39 | let res = generic_chat_completion(system_message, user_message)?;
40 |
41 | let body_str = res.choices.first().unwrap().message.content.trim();
42 |
43 | // Strip backticks and clean up the response
44 | let body_str = body_str.trim_matches('`').to_string();
45 |
46 | // Ensure the response contains only the function body
47 | let body_str = body_str
48 | .lines()
49 | .skip_while(|line| line.starts_with("rust") || line.starts_with("#["))
50 | .collect::>()
51 | .join("\n");
52 |
53 | let implementation = format!(
54 | "{} {{
55 | {}
56 | }}",
57 | head, body_str
58 | );
59 |
60 | println!("implementation: {}", implementation);
61 |
62 | Ok(implementation)
63 | }
64 |
65 | pub fn minimal_llm_function(input: String) -> String {
66 | let system_message = "Your task is respond with a string with double quotes.".to_string();
67 |
68 | let res = generic_chat_completion(system_message, input).unwrap();
69 |
70 | res.choices.first().unwrap().to_owned().message.content
71 | }
72 |
--------------------------------------------------------------------------------
/auto/src/lib.rs:
--------------------------------------------------------------------------------
1 | mod api;
2 | mod cache;
3 | mod data;
4 | mod generator;
5 |
6 | use std::fs::read_to_string;
7 |
8 | use api::generic_chat_completion;
9 | use cache::ResolvedSourceCode;
10 | use dotenv::dotenv;
11 |
12 | use ignore::Walk;
13 | use proc_macro::TokenStream;
14 | use serde::Serialize;
15 |
16 | use tinytemplate::TinyTemplate;
17 |
18 | use syn::{ItemFn, __private::ToTokens};
19 |
20 | struct RawSourceCode {
21 | path: String,
22 | language: String,
23 | content: String,
24 | }
25 |
26 | #[derive(Serialize)]
27 | struct Context {
28 | name: String,
29 | }
30 |
31 | static TEMPLATE: &str = "Hello {name}!";
32 |
33 | #[proc_macro_attribute]
34 | pub fn llm_tool(args: TokenStream, input: TokenStream) -> TokenStream {
35 | dotenv().ok();
36 |
37 | let mut tt = TinyTemplate::new();
38 | tt.add_template("hello", TEMPLATE).unwrap();
39 |
40 | let context = Context {
41 | name: "World".to_string(),
42 | };
43 |
44 | let rendered = tt.render("hello", &context).unwrap();
45 |
46 | println!("args: {:?}", args);
47 |
48 | // detect #[llm_tool(live)] arg
49 |
50 | let is_live = args.to_string().contains("live");
51 |
52 | let ast: ItemFn = syn::parse(input).expect("Failed to parse input as a function");
53 |
54 | let cargo_toml_path = std::env::var("CARGO_MANIFEST_DIR").unwrap_or("".to_string());
55 |
56 | println!("{:?}", cargo_toml_path);
57 |
58 | let mut source_code = vec![];
59 |
60 | for result in Walk::new(cargo_toml_path) {
61 | match result {
62 | Ok(entry) => {
63 | if entry.path().is_file() {
64 | if let Ok(Some(kind)) = hyperpolyglot::detect(entry.path()) {
65 | let path = format!("{}", entry.path().display());
66 |
67 | let content = read_to_string(path.clone()).unwrap();
68 | if content.lines().count() > 500 {
69 | continue;
70 | }
71 |
72 | println!("{}: {:?}", path, kind);
73 |
74 | let language = kind.language().to_string();
75 |
76 | source_code.push(RawSourceCode {
77 | path,
78 | content,
79 | language,
80 | });
81 | }
82 | }
83 | }
84 | Err(err) => println!("ERROR: {}", err),
85 | }
86 | }
87 |
88 | let source_code_context = source_code
89 | .iter()
90 | .map(|x| {
91 | format!(
92 | "## {}\n```{}\n{}\n```\n",
93 | x.path,
94 | x.language.to_lowercase(),
95 | x.content
96 | )
97 | })
98 | .collect::>()
99 | .join("\n");
100 |
101 | // println!("{}", source_code_context);
102 |
103 | let system_message = format!("
104 | You are an advanced AI, trained on the most modern architecture, with expertise in Rust programming. Your task is to generate the body of a Rust function based on its signature. Please adhere to these guidelines:
105 |
106 | 1. Receive the Function Signature: The signature will be provided in a standard Rust format, e.g., 'fn calculate_pi_with_n_iterations(n: u64) -> f64'. Focus on understanding the function's name, parameters, and return type.
107 | 2. Generate Only the Function Body: You are required to write Rust code that fulfills the requirements of the function signature. This code should be the function body only, without including the function signature or any other wrapping code.
108 | 3. Exclude Non-Essential Content: Your response must strictly contain valid Rust code applicable within the function's curly braces. Do not include comments, attributes, nested functions, or any redundant repetitions of the function signature. Do not include any explanation or additional text outside of the function body.
109 | 4. Maintain Simplicity and Clarity: Avoid external crates, unnecessary imports, or extra features like feature flags. Use standard Rust libraries and functionalities. The code should be clear, maintainable, and compile-ready.
110 | 5. Adhere to Rust Best Practices: Ensure that the generated code is idiomatic, efficient, and adheres to Rust standards and best practices.
111 |
112 | Example:
113 | INPUT SIGNATURE: 'fn calculate_pi_with_n_iterations(n: u64) -> f64'
114 | EXPECTED OUTPUT (Function Body Only):
115 | let mut pi = 0.0;
116 | let mut sign = 1.0;
117 | for i in 0..n {{
118 | pi += sign / (2 * i + 1) as f64;
119 | sign = -sign;
120 | }}
121 | 4.0 * pi
122 |
123 | Don't forget only respond with the function body. Don't include nature language text or explanation in your response.
124 |
125 | Global Context:
126 | {}
127 | ", source_code_context);
128 |
129 | let mut prompt_input = String::new();
130 |
131 | let fn_header = ast.sig.to_token_stream().to_string();
132 |
133 | for attr in ast.attrs {
134 | let data = attr.to_token_stream().to_string();
135 |
136 | prompt_input.push_str(&data);
137 | prompt_input.push('\n');
138 | }
139 |
140 | prompt_input.push_str(&fn_header);
141 |
142 | println!("prompt_input: {}", prompt_input);
143 |
144 | let hash = md5::compute(prompt_input.as_bytes());
145 |
146 | let hash_string = format!("{:x}", hash);
147 |
148 | let existing_resolution = ResolvedSourceCode::load(&hash_string);
149 |
150 | if !is_live {
151 | if let Some(resolution) = existing_resolution {
152 | return resolution.implementation.parse().unwrap();
153 | }
154 | }
155 |
156 | let res = generic_chat_completion(system_message, prompt_input.clone()).unwrap();
157 |
158 | println!("res: {:?}", res);
159 |
160 | let body_str = res
161 | .choices
162 | .first()
163 | .unwrap()
164 | .message
165 | .content
166 | .trim()
167 | .trim_matches('`')
168 | .trim_matches('\'')
169 | .to_string()
170 | .lines()
171 | .skip_while(|line| line.starts_with("rust") || line.starts_with("#["))
172 | .collect::>()
173 | .join("\n");
174 |
175 | let implementation = format!(
176 | "{} {{
177 | {}
178 | }}",
179 | prompt_input.clone(),
180 | body_str
181 | );
182 |
183 | println!("impl:\n {}", implementation);
184 |
185 | let new_resolution = ResolvedSourceCode {
186 | implementation: implementation.clone(),
187 | hash: format!("{:x}", hash),
188 | prompt_input,
189 | };
190 |
191 | new_resolution.save();
192 |
193 | implementation.parse().unwrap()
194 | }
195 |
--------------------------------------------------------------------------------
/examples/server/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "server"
3 | version = "0.1.0"
4 | edition = "2021"
5 |
6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
7 |
8 | [dependencies]
9 | poem = "3.0.1"
10 | tokio = { version = "1.38.0", features = ["full"] }
11 | auto-rust.workspace = true
12 |
--------------------------------------------------------------------------------
/examples/server/src/main.rs:
--------------------------------------------------------------------------------
1 | use auto_rust::llm_tool;
2 | use poem::{
3 | get, handler, listener::TcpListener, middleware::Tracing, web::Path, EndpointExt, IntoResponse,
4 | Route, Server,
5 | };
6 |
7 | #[llm_tool]
8 | #[handler]
9 | /// The response will be an html layout with the name and the number of letters in the name.
10 | /// Ensure to return a content type of text/html.
11 | async fn hello(Path(name): Path) -> impl IntoResponse {
12 | todo!()
13 | }
14 |
15 | #[llm_tool]
16 | #[handler]
17 | /// The response will be an html layout with the number of times the page has been visited.
18 | /// The count will be stored in a file.
19 | /// The count will be incremented each time the page is visited.
20 | /// The count will be displayed on the page.
21 | /// Ensure to return a content type of text/html.
22 | async fn count() -> impl IntoResponse {
23 | todo!()
24 | }
25 |
26 | #[tokio::main]
27 | async fn main() -> Result<(), std::io::Error> {
28 | let app = Route::new()
29 | .at("/hello/:name", get(hello))
30 | .at("/count", get(count))
31 | .with(Tracing);
32 |
33 | Server::new(TcpListener::bind("0.0.0.0:3000"))
34 | .name("hello-world")
35 | .run(app)
36 | .await
37 | }
38 |
--------------------------------------------------------------------------------
/public/auto_rust_example.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/minskylab/auto-rust/206e4df9efe11766ba0f8d6f32e1aebc18ae0b72/public/auto_rust_example.png
--------------------------------------------------------------------------------
5 |