@ape-egg/vibe-compiler 3.0.0

package/src/config.rs

@@ -0,0 +1,286 @@
+use serde::{Deserialize, Serialize};
+use std::fs;
+use std::path::PathBuf;
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum ConfigError {
+    #[error("Failed to read package.json: {0}")]
+    ReadError(#[from] std::io::Error),
+    #[error("Failed to parse package.json: {0}")]
+    ParseError(#[from] serde_json::Error),
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct VibeCompilerConfig {
+    #[serde(default = "default_source")]
+    pub source: String,
+    #[serde(default = "default_output")]
+    pub output: String,
+    #[serde(default = "default_components")]
+    pub components: String,
+    #[serde(default = "default_pages")]
+    pub pages: String,
+    #[serde(default = "default_assets")]
+    pub assets: String,
+    #[serde(default)]
+    pub root: Option<String>,
+    #[serde(default)]
+    pub minify: bool,
+    #[serde(default)]
+    pub elements_as_is: bool,
+    #[serde(default)]
+    pub source_maps: bool,
+    #[serde(default)]
+    pub reserved_elements: Vec<String>,
+    #[serde(default)]
+    pub skip_files: Vec<String>,
+    #[serde(default)]
+    pub node_modules_as_is: bool,
+    #[serde(default)]
+    pub components_as_is: bool,
+    #[serde(default)]
+    pub runtime_as_is: bool,
+    #[serde(default)]
+    pub iterations_as_is: bool,
+    #[serde(default)]
+    pub no_clean: bool,
+    #[serde(default)]
+    pub fouc_as_is: bool,
+    #[serde(default, deserialize_with = "deserialize_spa")]
+    pub spa: bool,
+}
+
+// "spa" is a boolean. An object form (a hypothetical future per-page
+// selection config) has NO semantics on this compiler — guessing (treating it
+// as `true`) would silently convert the entire pages tree when the author
+// asked for a subset. Unsupported input is a hard, targeted error; the rest
+// of the vibe-compiler section still parses.
+fn deserialize_spa<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<bool, D::Error> {
+    match serde_json::Value::deserialize(deserializer)? {
+        serde_json::Value::Bool(enabled) => Ok(enabled),
+        other => Err(serde::de::Error::custom(format!(
+            "\"spa\" must be true or false — got {other}. This compiler has no per-page SPA selection; remove the object form or upgrade."
+        ))),
+    }
+}
+
+fn default_source() -> String { "./".to_string() }
+fn default_output() -> String { "./compiled".to_string() }
+fn default_components() -> String { "components".to_string() }
+fn default_pages() -> String { "pages".to_string() }
+fn default_assets() -> String { "assets".to_string() }
+
+/// Get list of standard HTML5 elements + "component"
+/// Component names matching these are reserved and not allowed
+pub fn get_default_reserved_elements() -> Vec<String> {
+    vec![
+        "a", "abbr", "address", "area", "article", "aside", "audio",
+        "b", "base", "bdi", "bdo", "blockquote", "body", "br", "button",
+        "canvas", "caption", "cite", "code", "col", "colgroup",
+        "data", "datalist", "dd", "del", "details", "dfn", "dialog", "div", "dl", "dt",
+        "em", "embed",
+        "fieldset", "figcaption", "figure", "footer", "form",
+        "h1", "h2", "h3", "h4", "h5", "h6", "head", "header", "hgroup", "hr", "html",
+        "i", "iframe", "img", "input", "ins",
+        "kbd",
+        "label", "legend", "li", "link",
+        "main", "map", "mark", "menu", "meta", "meter",
+        "nav", "noscript",
+        "object", "ol", "optgroup", "option", "output",
+        "p", "param", "picture", "pre", "progress",
+        "q",
+        "rp", "rt", "ruby",
+        "s", "samp", "script", "search", "section", "select", "slot", "small", "source", "span", "strong", "style", "sub", "summary", "sup", "svg",
+        "table", "tbody", "td", "template", "textarea", "tfoot", "th", "thead", "time", "title", "tr", "track",
+        "u", "ul",
+        "var", "video",
+        "wbr",
+        "component", // Always reserved
+    ].into_iter().map(|s| s.to_string()).collect()
+}
+
+impl Default for VibeCompilerConfig {
+    fn default() -> Self {
+        Self {
+            source: default_source(),
+            output: default_output(),
+            components: default_components(),
+            pages: default_pages(),
+            assets: default_assets(),
+            root: None,
+            minify: false,
+            elements_as_is: false,
+            source_maps: false,
+            reserved_elements: vec![],
+            skip_files: vec![],
+            node_modules_as_is: false,
+            components_as_is: false,
+            runtime_as_is: false,
+            iterations_as_is: false,
+            no_clean: false,
+            fouc_as_is: false,
+            spa: false,
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct Config {
+    pub source: PathBuf,
+    pub output: PathBuf,
+    pub _source_str: String, // Original config value for display
+    pub _output_str: String, // Original config value for display
+    pub components: String,
+    pub pages: String,
+    pub _assets: String,
+    pub root: Option<String>,
+    pub minify: bool,
+    pub elements_as_is: bool,
+    pub source_maps: bool,
+    pub reserved_elements: Vec<String>,
+    pub skip_files: Vec<String>,
+    pub node_modules_as_is: bool,
+    pub components_as_is: bool,
+    pub runtime_as_is: bool,
+    pub iterations_as_is: bool,
+    pub no_clean: bool,
+    pub fouc_as_is: bool,
+    pub spa: bool,
+    pub working_dir: PathBuf,
+}
+
+impl Config {
+    /// Load config from package.json, or use defaults if not found
+    pub fn load(working_dir: PathBuf) -> Self {
+        // A relative --cwd must become absolute HERE: every derived path
+        // (source, output, pages) joins from working_dir, and downstream
+        // strip_prefix against filesystem-event paths (always absolute)
+        // otherwise fails — in watch mode that once routed a manifest write
+        // and a stamped page INTO the source tree.
+        let working_dir = working_dir.canonicalize().unwrap_or(working_dir);
+        let package_path = working_dir.join("package.json");
+
+        let config = if package_path.exists() {
+            fs::read_to_string(&package_path)
+                .ok()
+                .and_then(|content| serde_json::from_str::<serde_json::Value>(&content).ok())
+                .and_then(|package| package.get("vibe-compiler").cloned())
+                .and_then(|vibe_config| serde_json::from_value::<VibeCompilerConfig>(vibe_config).ok())
+                .unwrap_or_default()
+        } else {
+            VibeCompilerConfig::default()
+        };
+
+        let source_str = config.source.clone();
+        let output_str = config.output.clone();
+        let source = working_dir.join(&config.source);
+        let output = working_dir.join(&config.output);
+
+        // Combine default reserved elements with user-provided ones
+        let mut reserved_elements = get_default_reserved_elements();
+        reserved_elements.extend(config.reserved_elements);
+
+        // Combine built-in skip patterns with user-provided ones (append, not replace)
+        let mut skip_files: Vec<String> = crate::compiler::compile::SKIP_FILES
+            .iter()
+            .map(|s| s.to_string())
+            .collect();
+        skip_files.extend(config.skip_files);
+
+        Self {
+            source,
+            output,
+            _source_str: source_str,
+            _output_str: output_str,
+            components: config.components,
+            pages: config.pages,
+            _assets: config.assets,
+            root: config.root,
+            minify: config.minify,
+            elements_as_is: config.elements_as_is,
+            source_maps: config.source_maps,
+            reserved_elements,
+            skip_files,
+            node_modules_as_is: config.node_modules_as_is,
+            components_as_is: config.components_as_is,
+            runtime_as_is: config.runtime_as_is,
+            iterations_as_is: config.iterations_as_is,
+            no_clean: config.no_clean,
+            fouc_as_is: config.fouc_as_is,
+            spa: config.spa,
+            working_dir,
+        }
+    }
+
+    pub fn components_path(&self) -> PathBuf {
+        self.source.join(&self.components)
+    }
+
+    pub fn _pages_path(&self) -> PathBuf {
+        self.source.join(&self.pages)
+    }
+
+    pub fn _assets_path(&self) -> PathBuf {
+        self.source.join(&self._assets)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn parse(json: &str) -> VibeCompilerConfig {
+        serde_json::from_str(json).unwrap()
+    }
+
+    #[test]
+    fn spa_parses_bool_and_rejects_unsupported_forms() {
+        assert!(!parse(r#"{}"#).spa);
+        assert!(parse(r#"{"spa": true}"#).spa);
+        assert!(!parse(r#"{"spa": false}"#).spa);
+        // An object form has no semantics on this compiler — guessing would
+        // silently convert the whole pages tree. Hard, targeted error.
+        let err = serde_json::from_str::<VibeCompilerConfig>(r#"{"spa": {"pages": ["docs"]}}"#)
+            .unwrap_err()
+            .to_string();
+        assert!(err.contains("\"spa\" must be true or false"));
+    }
+}
+
+pub fn init_config(working_dir: &PathBuf) -> Result<(), ConfigError> {
+    let package_path = working_dir.join("package.json");
+
+    if !package_path.exists() {
+        // Create minimal package.json with vibe-compiler config
+        let config = VibeCompilerConfig::default();
+        let package = serde_json::json!({
+            "vibe-compiler": config
+        });
+        let formatted = serde_json::to_string_pretty(&package)?;
+        fs::write(&package_path, formatted)?;
+        println!("Created package.json with vibe-compiler config");
+        return Ok(());
+    }
+
+    let content = fs::read_to_string(&package_path)?;
+    let mut package: serde_json::Value = serde_json::from_str(&content)?;
+
+    // Don't overwrite existing config
+    if package.get("vibe-compiler").is_some() {
+        println!("vibe-compiler config already exists in package.json");
+        return Ok(());
+    }
+
+    let default_config = VibeCompilerConfig::default();
+    let config_value = serde_json::to_value(&default_config)?;
+
+    package["vibe-compiler"] = config_value;
+
+    let formatted = serde_json::to_string_pretty(&package)?;
+    fs::write(&package_path, formatted)?;
+
+    println!("Added vibe-compiler config to package.json");
+    Ok(())
+}

package/src/main.rs

@@ -0,0 +1,358 @@
+mod config;
+mod parser;
+mod compiler;
+
+use clap::Parser as ClapParser;
+use colored::Colorize;
+use std::path::PathBuf;
+
+use config::Config;
+use compiler::Compiler;
+
+/// Track which config values were overridden by flags
+#[derive(Debug, Default)]
+struct ConfigOverrides {
+    minify: bool,
+    elements_as_is: bool,
+    source_maps: bool,
+    node_modules_as_is: bool,
+    components_as_is: bool,
+    runtime_as_is: bool,
+    iterations_as_is: bool,
+    spa: bool,
+}
+
+/// Vibe Compiler - Compiles Vibe source files into optimized output
+#[derive(ClapParser, Debug)]
+#[command(name = "vibe-compile")]
+#[command(author = "Kim Korte")]
+#[command(version)]
+#[command(about = "Compiles Vibe source files into optimized output")]
+struct Args {
+    /// Working directory (defaults to current directory)
+    #[arg(long)]
+    cwd: Option<PathBuf>,
+
+    /// Watch for file changes
+    #[arg(long)]
+    watch: bool,
+
+    /// Minify output
+    #[arg(long)]
+    minify: bool,
+
+    /// Enable verbose logging with step-by-step output
+    #[arg(long)]
+    verbose: bool,
+
+    /// Keep custom HTML elements as-is (don't transform to divs for accessibility)
+    #[arg(long, name = "elements-as-is")]
+    elements_as_is: bool,
+
+    /// Generate source maps
+    #[arg(long, name = "source-maps")]
+    source_maps: bool,
+
+    /// Initialize configuration in package.json
+    #[arg(long)]
+    init: bool,
+
+    /// Custom source directory (overrides config)
+    #[arg(long)]
+    source: Option<PathBuf>,
+
+    /// Custom output directory (overrides config)
+    #[arg(long)]
+    output: Option<PathBuf>,
+
+    /// Copy node_modules as-is without production-only install (overrides config)
+    #[arg(long, name = "node-modules-as-is")]
+    node_modules_as_is: bool,
+
+    /// Keep components directory and <component> tags as-is (don't inline components)
+    #[arg(long, name = "components-as-is")]
+    components_as_is: bool,
+
+    /// Skip manifest generation - output will use runtime-only mode (no FOUC prevention)
+    #[arg(long, name = "runtime-as-is")]
+    runtime_as_is: bool,
+
+    /// Skip iteration optimization - use runtime DOM cloning instead of compiled batch functions
+    #[arg(long, name = "iterations-as-is")]
+    iterations_as_is: bool,
+
+    /// Skip cleaning output directory before compilation
+    #[arg(long, name = "no-clean", hide = true)]
+    no_clean: bool,
+
+    /// Keep FOUC prevention class/attribute in compiled output
+    #[arg(long, name = "fouc-as-is")]
+    fouc_as_is: bool,
+
+    /// Compile the pages tree to SPA output: fragments + route table + shell
+    #[arg(long)]
+    spa: bool,
+}
+
+fn main() {
+    let args = Args::parse();
+
+    // Determine working directory
+    let working_dir = args.cwd
+        .unwrap_or_else(|| std::env::current_dir().unwrap_or_else(|_| PathBuf::from(".")));
+
+    if args.init {
+        match config::init_config(&working_dir) {
+            Ok(_) => {
+                return;
+            }
+            Err(e) => {
+                eprintln!("{}: {}", "Error".red(), e);
+                std::process::exit(1);
+            }
+        }
+    }
+
+    // Load config from package.json (uses defaults if not found)
+    let mut config = Config::load(working_dir);
+
+    // Override config with CLI args
+    if let Some(source) = args.source {
+        config.source = config.working_dir.join(source);
+    }
+    if let Some(output) = args.output {
+        config.output = config.working_dir.join(output);
+    }
+
+    // Store original config values before applying flag overrides
+    let original_minify = config.minify;
+    let original_elements_as_is = config.elements_as_is;
+    let original_source_maps = config.source_maps;
+    let original_node_modules_as_is = config.node_modules_as_is;
+    let original_components_as_is = config.components_as_is;
+    let original_runtime_as_is = config.runtime_as_is;
+    let original_iterations_as_is = config.iterations_as_is;
+    let original_spa = config.spa;
+
+    // Track overrides for verbose output
+    let mut overrides = ConfigOverrides::default();
+
+    if args.minify {
+        overrides.minify = !original_minify;
+        config.minify = true;
+    }
+    if args.elements_as_is {
+        overrides.elements_as_is = !original_elements_as_is;
+        config.elements_as_is = true;
+    }
+    if args.source_maps {
+        overrides.source_maps = !original_source_maps;
+        config.source_maps = true;
+    }
+    if args.node_modules_as_is {
+        overrides.node_modules_as_is = !original_node_modules_as_is;
+        config.node_modules_as_is = true;
+    }
+    if args.components_as_is {
+        overrides.components_as_is = !original_components_as_is;
+        config.components_as_is = true;
+    }
+    if args.runtime_as_is {
+        overrides.runtime_as_is = !original_runtime_as_is;
+        config.runtime_as_is = true;
+    }
+    if args.iterations_as_is {
+        overrides.iterations_as_is = !original_iterations_as_is;
+        config.iterations_as_is = true;
+    }
+    if args.no_clean {
+        config.no_clean = true;
+    }
+    if args.fouc_as_is {
+        config.fouc_as_is = true;
+    }
+    if args.spa {
+        overrides.spa = !original_spa;
+        config.spa = true;
+    }
+
+    if args.verbose {
+        println!("{}", format!("Vibe Compiler v{}", env!("CARGO_PKG_VERSION")).cyan().bold());
+        println!();
+        println!("  {}: {}", "Working dir".cyan(), config.working_dir.display());
+        println!("  {}: {}", "Source".cyan(), config.source.display());
+        println!("  {}: {}", "Output".cyan(), config.output.display());
+        println!("  {}: {}", "Components".cyan(), config.components);
+        println!("  {}: {}", "Pages".cyan(), config.pages);
+        println!("  {}: {}", "Assets".cyan(), config._assets);
+        println!();
+
+        // Show config values (alphabetically ordered)
+        println!("{}", "Compiler config".cyan().bold());
+        println!();
+        println!("  CLI flags override package.json config");
+        println!();
+
+        fn format_bool_with_flag(final_value: bool, overridden: bool, original_value: bool) -> String {
+            if overridden {
+                format!("{} (config: {}, flag: {})", final_value.to_string().green(), original_value.to_string().yellow(), final_value.to_string().green())
+            } else {
+                format!("{} (config: {})", final_value.to_string().green(), original_value.to_string().yellow())
+            }
+        }
+
+        fn format_value_no_flag<T: std::fmt::Display>(value: T) -> String {
+            format!("{} (config: {})", value.to_string().green(), value.to_string().yellow())
+        }
+
+        fn format_reserved_elements(elements: &[String]) -> String {
+            if elements.len() <= 2 {
+                format!("{:?}", elements)
+            } else {
+                let remaining = elements.len() - 2;
+                format!("[\"component\", \"div\", ... + {} more]", remaining)
+            }
+        }
+
+        fn format_list_preview(items: &[String]) -> String {
+            if items.len() <= 2 {
+                format!("{:?}", items)
+            } else {
+                format!("[{:?}, {:?}, ... + {} more]", items[0], items[1], items.len() - 2)
+            }
+        }
+
+        // Alphabetically ordered with padding (longest key is "reservedElements" = 16 chars)
+        println!("  {}: {}", format!("{:<16}", "assets").cyan(), format_value_no_flag(&config._assets));
+        println!("  {}: {}", format!("{:<16}", "components").cyan(), format_value_no_flag(&config.components));
+        println!("  {}: {}", format!("{:<16}", "componentsAsIs").cyan(), format_bool_with_flag(config.components_as_is, overrides.components_as_is, original_components_as_is));
+        println!("  {}: {}", format!("{:<16}", "elementsAsIs").cyan(), format_bool_with_flag(config.elements_as_is, overrides.elements_as_is, original_elements_as_is));
+        println!("  {}: {}", format!("{:<16}", "iterationsAsIs").cyan(), format_bool_with_flag(config.iterations_as_is, overrides.iterations_as_is, original_iterations_as_is));
+        println!("  {}: {}", format!("{:<16}", "minify").cyan(), format_bool_with_flag(config.minify, overrides.minify, original_minify));
+        println!("  {}: {}", format!("{:<16}", "nodeModulesAsIs").cyan(), format_bool_with_flag(config.node_modules_as_is, overrides.node_modules_as_is, original_node_modules_as_is));
+        println!("  {}: {}", format!("{:<16}", "output").cyan(), format_value_no_flag(&config._output_str));
+        println!("  {}: {}", format!("{:<16}", "pages").cyan(), format_value_no_flag(&config.pages));
+        println!("  {}: {}", format!("{:<16}", "reservedElements").cyan(), format_value_no_flag(format_reserved_elements(&config.reserved_elements)));
+        println!("  {}: {}", format!("{:<16}", "root").cyan(), format_value_no_flag(config.root.as_ref().map(|s| s.as_str()).unwrap_or("null")));
+        println!("  {}: {}", format!("{:<16}", "runtimeAsIs").cyan(), format_bool_with_flag(config.runtime_as_is, overrides.runtime_as_is, original_runtime_as_is));
+        println!("  {}: {}", format!("{:<16}", "skipFiles").cyan(), format_value_no_flag(format_list_preview(&config.skip_files)));
+        println!("  {}: {}", format!("{:<16}", "source").cyan(), format_value_no_flag(&config._source_str));
+        println!("  {}: {}", format!("{:<16}", "sourceMaps").cyan(), format_bool_with_flag(config.source_maps, overrides.source_maps, original_source_maps));
+        println!("  {}: {}", format!("{:<16}", "spa").cyan(), format_bool_with_flag(config.spa, overrides.spa, original_spa));
+        println!();
+    } else {
+        // Show version in non-verbose mode
+        println!("{}", format!("Vibe Compiler v{}", env!("CARGO_PKG_VERSION")).cyan());
+    }
+
+    // Handle watch mode
+    if args.watch {
+        if let Err(e) = compiler::watcher::watch(config, args.verbose) {
+            eprintln!("{}: {}", "Error".red(), e);
+            std::process::exit(1);
+        }
+        return;
+    }
+
+    // Save runtime_as_is before moving config
+    let runtime_as_is = config.runtime_as_is;
+
+    let mut compiler = Compiler::new(config, args.verbose);
+
+    match compiler.compile() {
+        Ok(stats) => {
+            // Generate manifests BEFORE showing success (unless runtime-as-is is enabled)
+            let mut manifest_time_ms = 0.0;
+            let mut manifest_stats_result = None;
+            if !runtime_as_is {
+                match compiler.generate_manifests() {
+                    Ok(manifest_stats) => {
+                        manifest_time_ms = manifest_stats.total_time_ms;
+                        manifest_stats_result = Some(manifest_stats);
+                    }
+                    Err(e) => {
+                        eprintln!("\n{}: Manifest generation failed: {}", "Warning".yellow(), e);
+                        eprintln!("Compilation succeeded but manifests were not generated.");
+                        eprintln!("Use --runtime-as-is to skip manifest generation.");
+                    }
+                }
+            }
+
+            // Show success headline
+            println!("\n{}", format!("Compilation successful! (v{}) ✅", env!("CARGO_PKG_VERSION")).green().bold());
+            println!();
+
+            // Show individual phase timings (validation first, then components, HTML, manifests, copied)
+
+            // Show validation time if it happened
+            if let Some(validation_time) = stats.validation_time_ms {
+                println!("* Validated components in {:.0}ms", validation_time);
+            }
+
+            let total_components_unique = stats.internal_components_unique + stats.external_components_unique;
+
+            // Always show components line
+            if stats.components_as_is {
+                println!("* Compiled components (0 internal, 0 external) - \"components-as-is\": true");
+            } else if total_components_unique > 0 {
+                println!("* Compiled components ({} internal, {} external) in {:.0}ms",
+                    stats.internal_components_unique,
+                    stats.external_components_unique,
+                    stats.components_time_ms
+                );
+            }
+
+            if stats.files_compiled > 0 {
+                println!("* Compiled HTML ({} file{}) in {:.0}ms",
+                    stats.files_compiled,
+                    if stats.files_compiled == 1 { "" } else { "s" },
+                    stats.compile_time_ms
+                );
+            }
+
+            // Show manifest stats between HTML and Copied files
+            if let Some(manifest_stats) = manifest_stats_result {
+                println!("* Generated manifests ({} file{}, {} skipped) in {:.0}ms",
+                    manifest_stats.pages_processed,
+                    if manifest_stats.pages_processed == 1 { "" } else { "s" },
+                    manifest_stats.pages_skipped,
+                    manifest_stats.total_time_ms
+                );
+            }
+
+            if stats.files_copied > 0 {
+                println!("* Copied files ({} file{}) in {:.0}ms",
+                    stats.files_copied,
+                    if stats.files_copied == 1 { "" } else { "s" },
+                    stats.copy_time_ms
+                );
+            }
+
+            // Show node_modules handling
+            if let Some(nm_time) = stats.node_modules_time_ms {
+                if stats.node_modules_copied_as_is {
+                    println!("* copied node_modules in {:.0}ms", nm_time);
+                } else if let Some(ref pkg_manager) = stats.package_manager {
+                    println!("* {} install in {:.0}ms", pkg_manager, nm_time);
+                }
+            }
+
+            // Calculate total duration as sum of all individual operations
+            let total_duration_ms = stats.validation_time_ms.unwrap_or(0.0)
+                + stats.components_time_ms
+                + stats.compile_time_ms
+                + stats.copy_time_ms
+                + stats.node_modules_time_ms.unwrap_or(0.0)
+                + manifest_time_ms;
+
+            println!("\n{} in {:.0}ms", "Compiled".green(), total_duration_ms);
+
+            // Exit explicitly to kill background server thread
+            std::process::exit(0);
+        }
+        Err(e) => {
+            eprintln!("{}: {}", "Error".red(), e);
+            std::process::exit(1);
+        }
+    }
+}