@ape-egg/vibe 1.0.5 → 1.1.2

package/compiler/src/compiler/mod.rs

@@ -0,0 +1,5 @@
+pub mod compile;
+
+pub use compile::Compiler;
+#[allow(unused_imports)]
+pub use compile::CompileStats;

package/compiler/src/config.rs

@@ -0,0 +1,184 @@
+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 accessibility: bool,
+    #[serde(default)]
+    pub manifest: bool,
+    #[serde(default)]
+    pub validate: bool,
+    #[serde(default)]
+    pub source_maps: bool,
+    #[serde(default)]
+    pub exclude_tags: Vec<String>,
+    #[serde(default)]
+    pub node_modules_as_is: bool,
+    #[serde(default)]
+    pub components_as_is: bool,
+}
+
+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() }
+
+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,
+            accessibility: false,
+            manifest: false,
+            validate: false,
+            source_maps: false,
+            exclude_tags: vec![],
+            node_modules_as_is: false,
+            components_as_is: false,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+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 accessibility: bool,
+    pub manifest: bool,
+    pub validate: bool,
+    pub source_maps: bool,
+    pub exclude_tags: Vec<String>,
+    pub node_modules_as_is: bool,
+    pub components_as_is: 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 {
+        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);
+
+        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,
+            accessibility: config.accessibility,
+            manifest: config.manifest,
+            validate: config.validate,
+            source_maps: config.source_maps,
+            exclude_tags: config.exclude_tags,
+            node_modules_as_is: config.node_modules_as_is,
+            components_as_is: config.components_as_is,
+            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)
+    }
+}
+
+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/compiler/src/main.rs

@@ -0,0 +1,284 @@
+mod config;
+mod parser;
+mod compiler;
+
+use clap::Parser as ClapParser;
+use colored::Colorize;
+use std::path::PathBuf;
+use std::time::Instant;
+
+use config::Config;
+use compiler::compile::CompileError;
+use compiler::Compiler;
+
+/// Track which config values were overridden by flags
+#[derive(Debug, Default)]
+struct ConfigOverrides {
+    minify: bool,
+    accessibility: bool,
+    manifest: bool,
+    validate: bool,
+    source_maps: bool,
+    node_modules_as_is: bool,
+    components_as_is: bool,
+}
+
+/// Vibe Compiler - Compiles Vibe source files into optimized output
+#[derive(ClapParser, Debug)]
+#[command(name = "vibe-compile")]
+#[command(author = "Kim Korte")]
+#[command(version = "0.1.0")]
+#[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,
+
+    /// Transform custom HTML elements to divs with classes for accessibility
+    #[arg(long)]
+    accessibility: bool,
+
+    /// Generate hydration manifest
+    #[arg(long, name = "create-manifest")]
+    create_manifest: bool,
+
+    /// Generate source maps
+    #[arg(long, name = "source-maps")]
+    source_maps: bool,
+
+    /// Validate HTML syntax
+    #[arg(long)]
+    validate: 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,
+}
+
+fn main() {
+    let args = Args::parse();
+    let start = Instant::now();
+
+    // 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_accessibility = config.accessibility;
+    let original_manifest = config.manifest;
+    let original_validate = config.validate;
+    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;
+
+    // Track overrides for verbose output
+    let mut overrides = ConfigOverrides::default();
+
+    if args.minify {
+        overrides.minify = !original_minify;
+        config.minify = true;
+    }
+    if args.accessibility {
+        overrides.accessibility = !original_accessibility;
+        config.accessibility = true;
+    }
+    if args.create_manifest {
+        overrides.manifest = !original_manifest;
+        config.manifest = true;
+    }
+    if args.validate {
+        overrides.validate = !original_validate;
+        config.validate = 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.verbose {
+        println!("{}", "Vibe Compiler".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())
+        }
+
+        // Alphabetically ordered with padding (longest key is "node-modules-as-is" = 18 chars)
+        println!("  {}: {}", format!("{:<18}", "accessibility").cyan(), format_bool_with_flag(config.accessibility, overrides.accessibility, original_accessibility));
+        println!("  {}: {}", format!("{:<18}", "assets").cyan(), format_value_no_flag(&config._assets));
+        println!("  {}: {}", format!("{:<18}", "components").cyan(), format_value_no_flag(&config.components));
+        println!("  {}: {}", format!("{:<18}", "components-as-is").cyan(), format_bool_with_flag(config.components_as_is, overrides.components_as_is, original_components_as_is));
+        println!("  {}: {}", format!("{:<18}", "exclude-tags").cyan(), format_value_no_flag(format!("{:?}", config.exclude_tags)));
+        println!("  {}: {}", format!("{:<18}", "manifest").cyan(), format_bool_with_flag(config.manifest, overrides.manifest, original_manifest));
+        println!("  {}: {}", format!("{:<18}", "minify").cyan(), format_bool_with_flag(config.minify, overrides.minify, original_minify));
+        println!("  {}: {}", format!("{:<18}", "node-modules-as-is").cyan(), format_bool_with_flag(config.node_modules_as_is, overrides.node_modules_as_is, original_node_modules_as_is));
+        println!("  {}: {}", format!("{:<18}", "output").cyan(), format_value_no_flag(&config._output_str));
+        println!("  {}: {}", format!("{:<18}", "pages").cyan(), format_value_no_flag(&config.pages));
+        println!("  {}: {}", format!("{:<18}", "root").cyan(), format_value_no_flag(config._root.as_ref().map(|s| s.as_str()).unwrap_or("null")));
+        println!("  {}: {}", format!("{:<18}", "source").cyan(), format_value_no_flag(&config._source_str));
+        println!("  {}: {}", format!("{:<18}", "source-maps").cyan(), format_bool_with_flag(config.source_maps, overrides.source_maps, original_source_maps));
+        println!("  {}: {}", format!("{:<18}", "validate").cyan(), format_bool_with_flag(config.validate, overrides.validate, original_validate));
+        println!();
+    }
+
+    let mut compiler = Compiler::new(config, args.verbose);
+
+    match compiler.compile() {
+        Ok(stats) => {
+            let duration = start.elapsed();
+
+            // Show success headline
+            println!("\n{}", "Compilation successful! ✅".green().bold());
+            println!();
+
+            // Show individual phase timings (validation first, then components, HTML, 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
+                );
+            }
+
+            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);
+                }
+            }
+
+            println!("\n{} in {:.0}ms", "Compiled".green(), duration.as_secs_f64() * 1000.0);
+        }
+        Err(e) => {
+            match e {
+                CompileError::ComponentValidationFailed(errors) => {
+                    eprintln!("\n{}: Component validation failed\n", "Error".red());
+                    for err in errors {
+                        eprintln!("  {} {}", "✗".red(), err.component_src);
+                        eprintln!("    Referenced in: {}", err.referenced_in);
+                        eprintln!("    Error: {}\n", err.error_message);
+                    }
+                    eprintln!("Fix the errors above and try again.");
+                }
+                _ => {
+                    eprintln!("{}: {}", "Error".red(), e);
+                }
+            }
+            std::process::exit(1);
+        }
+    }
+
+    if args.watch {
+        println!("{}", "Watch mode not yet implemented".yellow());
+    }
+}

package/compiler/src/parser/element.rs

@@ -0,0 +1,96 @@
+use std::collections::HashMap;
+use std::path::PathBuf;
+
+/// Represents a parsed Vibe element/component
+#[derive(Debug, Clone)]
+pub struct Element {
+    /// Tag name (derived from filename, e.g., "counter" from counter.html)
+    pub _tag_name: String,
+    /// Original file path
+    pub _path: PathBuf,
+    /// Raw HTML content (the inner content of the element)
+    pub content: String,
+    /// Bindings found in this element (@[property])
+    pub _bindings: Vec<String>,
+    /// Nested element references (custom tags used within this element)
+    pub _nested_elements: Vec<String>,
+}
+
+impl Element {
+    pub fn new(tag_name: String, path: PathBuf, content: String) -> Self {
+        let bindings = extract_bindings(&content);
+        let nested_elements = extract_custom_tags(&content);
+
+        Self {
+            _tag_name: tag_name,
+            _path: path,
+            content,
+            _bindings: bindings,
+            _nested_elements: nested_elements,
+        }
+    }
+}
+
+/// Extract all @[property] bindings from content
+fn extract_bindings(content: &str) -> Vec<String> {
+    let mut bindings = Vec::new();
+    let re = regex::Regex::new(r"@\[([^\]]+)\]").unwrap();
+
+    for cap in re.captures_iter(content) {
+        if let Some(m) = cap.get(1) {
+            let binding = m.as_str().to_string();
+            if !bindings.contains(&binding) {
+                bindings.push(binding);
+            }
+        }
+    }
+
+    bindings
+}
+
+/// Extract custom HTML tags (potential element references)
+/// Custom tags are lowercase with hyphens, or single-word lowercase non-standard tags
+fn extract_custom_tags(content: &str) -> Vec<String> {
+    let mut tags = Vec::new();
+    // Match opening tags: <tag-name> or <tagname (self-closing handled too)
+    let re = regex::Regex::new(r"<([a-z][a-z0-9-]*)[>\s/]").unwrap();
+
+    // Standard HTML5 elements to exclude
+    let standard_tags: std::collections::HashSet<&str> = [
+        "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",
+    ].into_iter().collect();
+
+    for cap in re.captures_iter(content) {
+        if let Some(m) = cap.get(1) {
+            let tag = m.as_str().to_string();
+            if !standard_tags.contains(tag.as_str()) && !tags.contains(&tag) {
+                tags.push(tag);
+            }
+        }
+    }
+
+    tags
+}
+
+/// Cache of loaded elements by tag name
+pub type ElementCache = HashMap<String, Element>;