@ape-egg/vibe 1.6.1 → 1.7.1

package/compiler/src/compiler/watcher.rs

@@ -328,7 +328,7 @@ pub fn watch(config: Config, verbose: bool) -> std::result::Result<(), Box<dyn s
 
     // Keep compiler and parser alive to reuse component cache across incremental compilations
     let mut watch_compiler = Compiler::new(config.clone(), false);
-    let parser = {
+    let mut parser = {
         use crate::parser::HtmlParser;
         let mut p = HtmlParser::new(config.components_path());
         if let Err(e) = p.load_elements() {
@@ -396,10 +396,52 @@ pub fn watch(config: Config, verbose: bool) -> std::result::Result<(), Box<dyn s
                                 let dependent_pages = graph.get_all_dependent_pages(&path_canonical);
                                 if !dependent_pages.is_empty() {
                                     println!("{} {} changed", "[watch]".cyan(), relative_path.display());
+
+                                    // Invalidate component cache so stale content isn't used
+                                    watch_compiler.clear_component_cache();
+
+                                    // Reload the changed component in the parser's element cache
+                                    // (used for custom element syntax like <Layout>)
+                                    if path.exists() {
+                                        let _ = parser.reload_element(path);
+                                    }
+
                                     pages_to_recompile.extend(dependent_pages);
                                 }
                             } else if let Some(ext) = path.extension() {
                                 if ext == "html" {
+                                    // Check if file still exists (handle deletions)
+                                    if !path.exists() {
+                                        // File was deleted - clean up dependency graph
+                                        println!("{} {} deleted", "[watch]".yellow(), relative_path.display());
+
+                                        if let Some(old_deps) = graph.page_to_components.remove(path) {
+                                            for dep in old_deps {
+                                                if let Some(pages) = graph.component_to_pages.get_mut(&dep) {
+                                                    pages.remove(path);
+                                                }
+                                            }
+                                        }
+
+                                        // Delete corresponding compiled output
+                                        let output_path = canonical_output.join(relative_path);
+                                        if output_path.exists() {
+                                            if let Err(e) = std::fs::remove_file(&output_path) {
+                                                eprintln!("{}: Failed to delete {}: {}", "Warning".yellow(), output_path.display(), e);
+                                            }
+                                        }
+
+                                        // Delete corresponding manifest
+                                        let manifest_path = canonical_output.join("vibe-hyperspeed").join(format!("{}.manifest.js", relative_path.display()));
+                                        if manifest_path.exists() {
+                                            if let Err(e) = std::fs::remove_file(&manifest_path) {
+                                                eprintln!("{}: Failed to delete manifest {}: {}", "Warning".yellow(), manifest_path.display(), e);
+                                            }
+                                        }
+
+                                        continue;
+                                    }
+
                                     // Page changed - recompile just this page
                                     println!("{} {} changed", "[watch]".cyan(), relative_path.display());
                                     pages_to_recompile.insert(path.clone());
@@ -431,7 +473,10 @@ pub fn watch(config: Config, verbose: bool) -> std::result::Result<(), Box<dyn s
                         }
 
                         // Separate HTML files (from dependency graph) and CSS/JS assets (from changed_paths)
-                        let html_files: Vec<PathBuf> = pages_to_recompile.into_iter().collect();
+                        // Filter out deleted files
+                        let html_files: Vec<PathBuf> = pages_to_recompile.into_iter()
+                            .filter(|p| p.exists())
+                            .collect();
 
                         let mut asset_files: Vec<PathBuf> = Vec::new();
                         for path in &changed_paths {
@@ -446,6 +491,24 @@ pub fn watch(config: Config, verbose: bool) -> std::result::Result<(), Box<dyn s
                                 continue;
                             }
 
+                            // Handle deleted asset files
+                            if !path.exists() {
+                                if let Some(ext) = path.extension().and_then(|e| e.to_str()) {
+                                    if ext == "css" || ext == "js" {
+                                        let relative_path = path.strip_prefix(&config.source).unwrap_or(path);
+                                        let output_path = canonical_output.join(relative_path);
+                                        if output_path.exists() {
+                                            if let Err(e) = std::fs::remove_file(&output_path) {
+                                                eprintln!("{}: Failed to delete {}: {}", "Warning".yellow(), output_path.display(), e);
+                                            } else {
+                                                println!("{} {} deleted", "[watch]".yellow(), relative_path.display());
+                                            }
+                                        }
+                                    }
+                                }
+                                continue;
+                            }
+
                             if let Some(ext) = path.extension().and_then(|e| e.to_str()) {
                                 if ext == "css" || ext == "js" {
                                     asset_files.push(path.clone());
@@ -482,6 +545,10 @@ pub fn watch(config: Config, verbose: bool) -> std::result::Result<(), Box<dyn s
 
                         // Compile HTML files
                         if !html_files.is_empty() {
+                                // Always clear component cache before recompiling so components
+                                // are read fresh from disk (prevents stale cache from previous triggers)
+                                watch_compiler.clear_component_cache();
+
                                 match watch_compiler.compile_specific_html_files(&html_files, &parser) {
                                     Ok(stats) => {
                                         total_stats.files_compiled = stats.files_compiled;

package/compiler/src/config.rs

@@ -31,8 +31,6 @@ pub struct VibeCompilerConfig {
     #[serde(default)]
     pub elements_as_is: bool,
     #[serde(default)]
-    pub validate: bool,
-    #[serde(default)]
     pub source_maps: bool,
     #[serde(default)]
     pub reserved_elements: Vec<String>,
@@ -44,6 +42,10 @@ pub struct VibeCompilerConfig {
     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,
 }
 
 fn default_source() -> String { "./".to_string() }
@@ -92,13 +94,14 @@ impl Default for VibeCompilerConfig {
             root: None,
             minify: false,
             elements_as_is: false,
-            validate: false,
             source_maps: false,
             reserved_elements: 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,
         }
     }
 }
@@ -115,13 +118,14 @@ pub struct Config {
     pub _root: Option<String>,
     pub minify: bool,
     pub elements_as_is: bool,
-    pub validate: bool,
     pub source_maps: bool,
     pub reserved_elements: 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 working_dir: PathBuf,
 }
 
@@ -161,13 +165,14 @@ impl Config {
             _root: config.root,
             minify: config.minify,
             elements_as_is: config.elements_as_is,
-            validate: config.validate,
             source_maps: config.source_maps,
             reserved_elements,
             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,
             working_dir,
         }
     }

package/compiler/src/main.rs

@@ -14,7 +14,6 @@ use compiler::Compiler;
 struct ConfigOverrides {
     minify: bool,
     elements_as_is: bool,
-    validate: bool,
     source_maps: bool,
     node_modules_as_is: bool,
     components_as_is: bool,
@@ -53,10 +52,6 @@ struct Args {
     #[arg(long, name = "source-maps")]
     source_maps: bool,
 
-    /// Validate HTML syntax
-    #[arg(long)]
-    validate: bool,
-
     /// Initialize configuration in package.json
     #[arg(long)]
     init: bool,
@@ -84,6 +79,14 @@ struct Args {
     /// 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,
 }
 
 fn main() {
@@ -119,7 +122,6 @@ fn main() {
     // Store original config values before applying flag overrides
     let original_minify = config.minify;
     let original_elements_as_is = config.elements_as_is;
-    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;
@@ -137,10 +139,6 @@ fn main() {
         overrides.elements_as_is = !original_elements_as_is;
         config.elements_as_is = 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;
@@ -161,6 +159,12 @@ fn main() {
         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.verbose {
         println!("{}", format!("Vibe Compiler v{}", env!("CARGO_PKG_VERSION")).cyan().bold());
@@ -191,21 +195,30 @@ fn main() {
             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}", "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}", "elements-as-is").cyan(), format_bool_with_flag(config.elements_as_is, overrides.elements_as_is, original_elements_as_is));
-        println!("  {}: {}", format!("{:<18}", "exclude-tags").cyan(), format_value_no_flag(format!("{:?}", config.reserved_elements)));
-        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}", "runtime-as-is").cyan(), format_bool_with_flag(config.runtime_as_is, overrides.runtime_as_is, original_runtime_as_is));
-        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));
+        fn format_reserved_elements(elements: &[String]) -> String {
+            if elements.len() <= 2 {
+                format!("{:?}", elements)
+            } else {
+                let remaining = elements.len() - 2;
+                format!("[\"component\", \"div\", ... + {} more]", remaining)
+            }
+        }
+
+        // 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}", "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!();
     } else {
         // Show version in non-verbose mode