Run code blocks

Cargo.toml

@@ -23,18 +23,20 @@ async-trait = "0.1"
 bytes = "1.1.0"
 clap = { version = "4.2.2", features = ["derive"] }
 crossterm = "0.27"
-lazy_static = "1.4.0"
 num-traits = "0.2"
+once_cell = "1.18"
 pin-project = "1.1"
 regex = "1.7.3"
 reqwest = { version = "0.11", features = ["gzip", "brotli", "deflate", "json", "stream", "default-tls"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0.95"
 serde_yaml = "0.9"
 smartstring = { version = "1.0", features = ["serde"] }
+tempfile = "3.8"
 thiserror = "1.0"
 tokio = { version = "1", features = ["full"] }
 tokio-stream = "0.1.12"
+tokio-util = {version = "0.7", features = ["io"]}
 
 aio-cargo-info = { path = "./crates/aio-cargo-info", version = "0.1" }
 

src/arguments.rs

@@ -1,33 +1,5 @@
-use std::fmt::Display;
-
 use clap::{Parser, ValueEnum};
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, ValueEnum)]
-pub enum FormatterChoice {
-    Markdown,
-    Raw,
-}
-
-impl Default for FormatterChoice {
-    fn default() -> Self {
-        use std::io::IsTerminal;
-        if std::io::stdout().is_terminal() {
-            FormatterChoice::Markdown
-        } else {
-            FormatterChoice::Raw
-        }
-    }
-}
-
-impl Display for FormatterChoice {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            FormatterChoice::Markdown => write!(f, "markdown"),
-            FormatterChoice::Raw => write!(f, "raw"),
-        }
-    }
-}
-
 /// Program to communicate with large language models and AI API 
 #[derive(Parser, Debug)]
 #[command(author, version, about, long_about = None)]
@@ -47,17 +19,44 @@ pub struct Args {
     /// Formatter
     /// 
     /// Possible values: markdown, raw
-    #[arg(long, short, default_value_t = Default::default())]
+    #[arg(long, short, value_enum, default_value_t = Default::default())]
     pub formatter: FormatterChoice,
+    /// Run code block if the language is supported
+    #[arg(long, short, value_enum, default_value_t = Default::default())]
+    pub run: RunChoice,
+    /// Force to run code 
     /// User text prompt
     pub input: Option<String>,
 }
 
+#[derive(Default, Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, ValueEnum)]
+#[value(rename_all = "lowercase")]
+pub enum FormatterChoice {
+    /// Markdown display
+    #[default]
+    Markdown,
+    /// Raw display
+    Raw,
+}
+
+#[derive(Default, Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, ValueEnum)]
+#[value(rename_all = "lowercase")]
+pub enum RunChoice {
+    /// Doesn't run anything
+    #[default]
+    No,
+    /// Ask to run code
+    Ask,
+    /// Run code without asking
+    Force
+}
+
 pub struct ProcessedArgs {
     pub config_path: String,
     pub creds_path: String,
     pub engine: String,
     pub formatter: FormatterChoice,
+    pub run: RunChoice,
     pub input: String,
 }
 
@@ -68,6 +67,7 @@ impl From<Args> for ProcessedArgs {
             creds_path: args.creds_path,
             engine: args.engine,
             formatter: args.formatter,
+            run: args.run,
             input: args.input.unwrap_or_default(),
         }
     }

src/config.rs

@@ -1,4 +1,5 @@
 use std::borrow::Cow;
+use once_cell::sync::Lazy;
 use regex::Regex;
 use serde::{Deserialize, Serialize};
 
@@ -24,9 +25,7 @@ impl Default for Config {
 }
 
 pub fn format_content<'a>(content: &'a str, args: &args::ProcessedArgs) -> Cow<'a, str> {
-    lazy_static::lazy_static!{
-        static ref RE: Regex = Regex::new(r"(?P<prefix>\$\$?)(?P<name>\w+)").expect("Failed to compile regex");
-    }
+    static RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"(?P<prefix>\$\$?)(?P<name>\w+)").expect("Failed to compile regex"));
     RE.replace_all(content, |caps: &regex::Captures| {
         let prefix = &caps["prefix"];
         if prefix == "$$" {

src/formatters/markdown/renderer/terminal/utils.rs

@@ -1,5 +1,4 @@
-use lazy_static::lazy_static;
-
+use once_cell::sync::Lazy;
 use super::{token, queue};
 use std::io::Error;
 
@@ -77,9 +76,9 @@ pub fn repeat_char(c: char, n: usize) -> String {
 
 #[inline]
 pub fn draw_line() -> Result<(), Error> {
-    lazy_static! {
-        static ref LINE_STRING: String = repeat_char(CODE_BLOCK_LINE_CHAR[0], CODE_BLOCK_MARGIN.max(crossterm::terminal::size().unwrap_or_default().0 as usize));
-    }
+    static LINE_STRING: Lazy<String> = Lazy::new(|| {
+        repeat_char(CODE_BLOCK_LINE_CHAR[0], CODE_BLOCK_MARGIN.max(crossterm::terminal::size().unwrap_or_default().0 as usize))
+    });
     queue!(std::io::stdout(), 
         crossterm::style::Print(&*LINE_STRING)
     )

src/generators/debug.rs

@@ -0,0 +1,14 @@
+use crate::args;
+use super::{ResultRun, ResultStream, Error};
+
+pub async fn run(_: crate::config::Config, args: args::ProcessedArgs) -> ResultRun {
+    use tokio_stream::StreamExt;
+    let input = args.input;
+    let file = tokio::fs::File::open(&input).await.map_err(|e| Error::Custom(std::borrow::Cow::Owned(e.to_string())))?;
+
+    let stream = tokio_util::io::ReaderStream::new(file).map(|r| -> ResultStream {
+        let bytes = r.map_err(|e| Error::Custom(std::borrow::Cow::Owned(e.to_string())))?;
+        Ok(String::from_utf8(bytes.as_ref().to_vec()).map_err(|e| Error::Custom(std::borrow::Cow::Owned(e.to_string())))?)
+    });
+    Ok(Box::pin(stream))
+}

src/generators/mod.rs

@@ -1,4 +1,5 @@
 pub mod openai;
+pub mod debug;
 
 use tokio_stream::Stream;
 use thiserror::Error;

src/main.rs

@@ -1,4 +1,5 @@
 pub mod arguments;
+mod runner;
 mod generators;
 mod formatters;
 mod config;
@@ -21,13 +22,24 @@ macro_rules! raise_str {
     };
 }
 
-fn resolve_path(path: &str) -> Cow<str> {
-    if path.starts_with("~/") {
+fn home_dir() -> &'static str {
+    static HOME: once_cell::sync::Lazy<String> = once_cell::sync::Lazy::new(|| {
         #[cfg(unix)]
-        let home = std::env::var("HOME").expect("Failed to resolve home path");
+        let path = std::env::var("HOME")
+            .expect("Failed to resolve home path");
+
         #[cfg(windows)]
-        let home = std::env::var("USERPROFILE").expect("Failed to resolve user profile path");
-        Cow::Owned(format!("{}{}{}", home, std::path::MAIN_SEPARATOR, &path[2..]))
+        let path = std::env::var("USERPROFILE")
+            .expect("Failed to resolve user profile path");
+        path
+    });
+
+    &*HOME
+}
+
+fn resolve_path(path: &str) -> Cow<str> {
+    if path.starts_with("~/") {
+        Cow::Owned(format!("{}{}{}", home_dir(), std::path::MAIN_SEPARATOR, &path[2..]))
     } else {
         Cow::Borrowed(path)
     }
@@ -67,23 +79,30 @@ async fn main() -> Result<(), String> {
         args::FormatterChoice::Markdown => Box::new(formatters::new_markdown_formatter()),
         args::FormatterChoice::Raw => Box::new(formatters::new_raw_formatter()),
     };
+    let mut runner = runner::Runner::new(args.run);
 
-    let engine = args.engine
+    let (engine, _prompt) = args.engine
         .find(':')
-        .map(|i| &args.engine[..i])
-        .unwrap_or(args.engine.as_str());
+        .map(|i| (&args.engine[..i], Some(&args.engine[i+1..])))
+        .unwrap_or((args.engine.as_str(), None));
+
     let mut stream = match engine {
         "openai" => generators::openai::run(creds.openai, config, args).await,
+        "from-file" => generators::debug::run(config, args).await,
         _ => panic!("Unknown engine: {}", engine),
     }.map_err(|e| format!("Failed to request OpenAI API: {}", e))?;
 
     loop {
         match stream.next().await {
-            Some(Ok(token)) => raise_str!(formatter.push(&token), "Failed to parse markdown: {}"),
+            Some(Ok(token)) => {
+                raise_str!(formatter.push(&token), "Failed to parse markdown: {}");
+                raise_str!(runner.push(&token), "Failed push text in the runner system: {}");
+            },
             Some(Err(e)) => Err(e.to_string())?,
             None => break,
         }
     }
     raise_str!(formatter.end_of_document(), "Failed to end markdown: {}");
+    raise_str!(runner.end_of_document(), "Failed to run code: {}");
     Ok(())
 }