Merge pull request #6 from OpacityLabs/Watch

Add watch command

Author: LukasOgunfeitimi

.DS_Store

@@ -23,4 +23,4 @@ tokio = { version = "1.44.2", features = ["full"] }
 uuid = { version = "1.16.0", features = ["v4"] }
 chrono = "0.4.40"
 tracing-subscriber = "0.3.19"
-
+notify = "6.1.1"

Cargo.toml

@@ -5,6 +5,7 @@ A command-line tool for bundling and analyzing Luau files using luau-lsp. This t
 ## Features
 
 - **Bundling**: Bundle Luau files with configurable output formats
+- **Serve Mode**: Serve bundled flows over HTTP with optional file watching
 - **Static Analysis**: Analyze Luau files using luau-lsp for type checking, linting, and code quality
 - **Generate Completions**: Generate completions for the CLI
 - **Platform Organization**: Organize your Luau modules by platform and flows
@@ -31,6 +32,9 @@ opacity-cli bundle --config config.toml
 
 # Analyze your Luau files with luau-lsp
 opacity-cli analyze --config config.toml
+
+# Serve your Luau files, (--watch / -w) will auto bundle them on each save
+opacity-cli serve --watch
 ```
 
 ### Analysis Features
@@ -56,4 +60,4 @@ Example:
 
 ```bash
 opacity-cli completions zsh > ~/.oh-my-zsh/completions/_opacity-cli
-```
+```

README.md

@@ -0,0 +1,40 @@
+use crate::config;
+use anyhow::{Context, Result};
+use which::which;
+
+use std::env;
+
+fn check_luau_lsp() -> Result<()> {
+    which("luau-lsp").context("luau-lsp is not installed. Please install it first (https://github.com/JohnnyMorganz/luau-lsp/releases)")?;
+    Ok(())
+}
+
+
+pub fn analyze(config_path: &str) -> Result<()> {
+    check_luau_lsp()?;
+    let config = config::Config::from_file(config_path)?;
+
+    let execution_dir = env::current_dir()?;
+
+    let definition_files = config.settings.definition_files.clone().unwrap_or_default();
+    let definition_files_args = definition_files
+        .iter()
+        .flat_map(|file| ["--definitions".to_string(), file.to_string()])
+        .collect::<Vec<String>>();
+
+    let file_paths = config.get_flows_paths();
+
+    let status = std::process::Command::new("luau-lsp")
+        .stdout(std::process::Stdio::inherit())
+        .current_dir(execution_dir.clone())
+        .arg("analyze")
+        .args(&definition_files_args)
+        .args(&file_paths)
+        .status()?;
+
+    if status.code().unwrap_or(-1) != 0 {
+        anyhow::bail!("luau-lsp analysis failed");
+    }
+
+    Ok(())
+}

src/commands/analyze.rs

@@ -0,0 +1,119 @@
+use crate::config;
+use crate::config::{Flow, Platform};
+
+use darklua_core::rules::bundle::BundleRequireMode;
+use darklua_core::rules::{
+    InjectGlobalValue, RemoveCompoundAssignment, RemoveContinue, RemoveIfExpression, RemoveTypes,
+    Rule,
+};
+use darklua_core::{
+    process, BundleConfiguration, Configuration, GeneratorParameters, Options, Resources,
+};
+use std::path::PathBuf;
+use std::time::Instant;
+use anyhow::Result;
+use tracing::info;
+
+
+fn get_global_inject_rules(platform: &Platform, flow: &Flow) -> Vec<Box<dyn Rule>> {
+    let mut rules: Vec<Box<dyn Rule>> = vec![
+        Box::new(InjectGlobalValue::string("FLOW_NAME", flow.name.clone())),
+        Box::new(InjectGlobalValue::string("FLOW_ALIAS", flow.alias.clone())),
+        Box::new(InjectGlobalValue::string(
+            "PLATFORM_NAME",
+            platform.name.clone(),
+        )),
+        Box::new(InjectGlobalValue::string(
+            "PLATFORM_DESCRIPTION",
+            platform.description.clone(),
+        )),
+    ];
+
+    if let Some(min_sdk_version) = &flow.min_sdk_version {
+        rules.push(Box::new(InjectGlobalValue::string(
+            "MIN_SDK_VERSION",
+            min_sdk_version.clone(),
+        )));
+    }
+
+    if let Some(retrieves) = &flow.retrieves {
+        rules.push(Box::new(InjectGlobalValue::string(
+            "RETRIEVES",
+            retrieves.join(", "),
+        )));
+    }
+
+    rules
+}
+
+
+fn process_bundle(resources: &Resources, options: Options) -> Result<()> {
+    let process_start = Instant::now();
+    let result =
+        process(resources, options).map_err(|e| anyhow::anyhow!("Processing failed: {:?}", e))?;
+
+    match result.result() {
+        Ok(_) => {
+            println!("Successfully processed in {:?}", process_start.elapsed());
+            Ok(())
+        }
+        Err(err) => {
+            anyhow::bail!("Failed to process: {:?}", err);
+        }
+    }
+}
+
+pub fn bundle(config_path: &str, is_rebundle: bool) -> Result<()> {
+    let config = config::Config::from_file(config_path)?;
+    let resources = Resources::from_file_system();
+
+    std::fs::create_dir_all(&config.settings.output_directory)?;
+
+    for platform in &config.platforms {
+        println!("Processing platform: {}", platform.name);
+
+        for flow in &platform.flows {
+            println!("Bundling {} ({})", flow.name, flow.alias);
+            let input = PathBuf::from(&flow.path);
+
+            let output = PathBuf::from(&config.settings.output_directory)
+                .join(format!("{}.bundle.lua", flow.alias));
+
+            let mut config = Configuration::empty();
+            config = config.with_bundle_configuration(
+                BundleConfiguration::new(BundleRequireMode::Path(Default::default()))
+                    .with_modules_identifier("__BUNDLE_MODULES"),
+            );
+
+            let rules: Vec<Box<dyn Rule>> = vec![
+                Box::new(RemoveContinue::default()),
+                Box::new(RemoveCompoundAssignment::default()),
+                Box::new(RemoveTypes::default()),
+                Box::new(RemoveIfExpression::default()),
+            ];
+            let rules = rules
+                .into_iter()
+                .chain(get_global_inject_rules(platform, flow))
+                .collect::<Vec<Box<dyn Rule>>>();
+
+            for rule in rules {
+                config = config.with_rule(rule);
+            }
+
+            let options = Options::new(&input)
+                .with_output(&output)
+                .with_generator_override(GeneratorParameters::RetainLines)
+                .with_configuration(config);
+
+            process_bundle(&resources, options)?;
+        }
+    }
+
+    if is_rebundle {
+        info!("Rebundled all flows successfully");
+    } else {
+        info!("Bundled all flows successfully");
+    }
+
+    Ok(())
+}

src/commands/bundle.rs

@@ -0,0 +1,36 @@
+use crate::Cli;
+use anyhow::Result;
+use clap::CommandFactory;
+
+pub fn generate_completions(shell: &str) -> Result<()> {
+    let mut app = Cli::command();
+
+    match shell {
+        "bash" => clap_complete::generate(
+            clap_complete::shells::Bash,
+            &mut app,
+            "opacity-cli",
+            &mut std::io::stdout(),
+        ),
+        "zsh" => clap_complete::generate(
+            clap_complete::shells::Zsh,
+            &mut app,
+            "opacity-cli",
+            &mut std::io::stdout(),
+        ),
+        "fish" => clap_complete::generate(
+            clap_complete::shells::Fish,
+            &mut app,
+            "opacity-cli",
+            &mut std::io::stdout(),
+        ),
+        "powershell" => clap_complete::generate(
+            clap_complete::shells::PowerShell,
+            &mut app,
+            "opacity-cli",
+            &mut std::io::stdout(),
+        ),
+        _ => anyhow::bail!("Unsupported shell: {}", shell),
+    }
+    Ok(())
+}

src/commands/generate_completions.rs

@@ -1,3 +1,5 @@
+use crate::commands::bundle::bundle;
+
 use axum::{
     extract::Query,
     response::{IntoResponse, Response},
@@ -12,6 +14,15 @@ use tower_http::trace::{self, TraceLayer};
 use tracing::{info, Level};
 use uuid::Uuid;
 
+use anyhow::Result;
+use std::path::Path;
+
+use notify::event::{DataChange, EventKind, ModifyKind};
+use notify::{Event, RecommendedWatcher, RecursiveMode, Watcher};
+use tokio::sync::mpsc;
+
+
+
 #[derive(Deserialize)]
 struct FlowQuery {
     name: String,
@@ -34,7 +45,6 @@ struct SessionResponse {
 }
 
 async fn read_flow(name: &str) -> Result<FlowResponse, String> {
-
     let config = crate::config::Config::from_file("./opacity.toml").unwrap();
 
     let matched_flow = config
@@ -44,15 +54,19 @@ async fn read_flow(name: &str) -> Result<FlowResponse, String> {
         .find(|flow| flow.alias == name)
         .ok_or_else(|| String::from("Flow not found"))?;
 
-    let script_path = PathBuf::from(config.settings.output_directory).join(format!("{}.bundle.lua", name));
+    let script_path =
+        PathBuf::from(config.settings.output_directory).join(format!("{}.bundle.lua", name));
     let script_content =
         fs::read_to_string(script_path).map_err(|_| String::from("Script file not found"))?;
 
     Ok(FlowResponse {
         name: matched_flow.alias.clone(),
         min_sdk: match &matched_flow.min_sdk_version {
             None => {
-                info!("No min SDK version found for flow {}; Defaulting to '1'", name);
+                info!(
+                    "No min SDK version found for flow {}; Defaulting to '1'",
+                    name
+                );
                 "1".to_string()
             }
             Some(min_sdk) => min_sdk.clone(),
@@ -67,10 +81,9 @@ async fn flows(Query(query): Query<FlowQuery>) -> Response {
         Err(e) => {
             let (status, message) = match e.as_str() {
                 "Flow not found" => (axum::http::StatusCode::NOT_FOUND, "Flow not found"),
-                "Script file not found" => (
-                    axum::http::StatusCode::NOT_FOUND,
-                    "Script file not found",
-                ),
+                "Script file not found" => {
+                    (axum::http::StatusCode::NOT_FOUND, "Script file not found")
+                }
                 _ => (
                     axum::http::StatusCode::INTERNAL_SERVER_ERROR,
                     "Error processing flow request",
@@ -93,7 +106,33 @@ async fn sessions() -> Json<SessionResponse> {
     })
 }
 
-pub async fn serve() -> Result<(), Box<dyn std::error::Error>> {
+async fn watch(config_path: &str) -> notify::Result<()> {
+    let (tx, mut rx) = mpsc::channel::<Event>(100);
+
+    let mut watcher: RecommendedWatcher = notify::recommended_watcher(move |res| {
+        if let Ok(event) = res {
+            let _ = tx.try_send(event);
+        } else if let Err(e) = res {
+            eprintln!("Watch error: {:?}", e);
+        }
+    })?;
+
+    watcher.watch(Path::new("src"), RecursiveMode::Recursive)?;
+    watcher.watch(Path::new(config_path), RecursiveMode::NonRecursive)?;
+    info!("Watching all files in 'src' and '{}'", config_path);
+
+    while let Some(_event) = rx.recv().await {
+        if _event.kind == EventKind::Modify(ModifyKind::Data(DataChange::Content)) {
+            if let Err(err) = bundle(config_path, true) {
+                tracing::error!("🟥 Rebundle failed: {:?}", err)
+            }
+        }
+    }
+
+    Ok(())
+}
+
+pub async fn serve(config_path: &str, should_watch: &bool) -> Result<(), Box<dyn std::error::Error>> {
     let port = 8080;
     let addr = SocketAddr::from(([0, 0, 0, 0], port));
 
@@ -119,8 +158,21 @@ pub async fn serve() -> Result<(), Box<dyn std::error::Error>> {
 
     info!("Listening on port {}...", port);
 
-    let listener = tokio::net::TcpListener::bind(addr).await?;
-    axum::serve(listener, app.into_make_service()).await?;
+    if *should_watch {
+        tokio::try_join!(
+            async {
+                let listener = tokio::net::TcpListener::bind(addr).await?;
+                axum::serve(listener, app.into_make_service()).await?;
+                Ok::<_, Box<dyn std::error::Error>>(())
+            },
+            async {
+                watch(config_path).await.map_err(|e| Box::new(e) as Box<dyn std::error::Error>)
+            }
+        )?;
+    } else {
+        let listener = tokio::net::TcpListener::bind(addr).await?;
+        axum::serve(listener, app.into_make_service()).await?;
+    }
 
     Ok(())
 }