@ape-egg/vibe 1.3.2 → 1.6.0

package/compiler/src/compiler/watcher.rs

@@ -0,0 +1,579 @@
+use std::collections::{HashMap, HashSet};
+use std::path::{Path, PathBuf};
+use std::sync::mpsc::channel;
+use std::time::Duration;
+use colored::Colorize;
+use notify_debouncer_full::{new_debouncer, notify::{RecursiveMode, Watcher}};
+use regex::Regex;
+
+use super::{Compiler, compile::should_skip_path};
+use crate::config::Config;
+
+/// Tracks which pages and components depend on which components
+pub struct DependencyGraph {
+    /// component path -> set of page paths that use it
+    component_to_pages: HashMap<PathBuf, HashSet<PathBuf>>,
+    /// component path -> set of component paths that use it (for transitive dependencies)
+    component_to_components: HashMap<PathBuf, HashSet<PathBuf>>,
+    /// page path -> set of component paths it uses
+    page_to_components: HashMap<PathBuf, HashSet<PathBuf>>,
+}
+
+impl DependencyGraph {
+    pub fn new() -> Self {
+        Self {
+            component_to_pages: HashMap::new(),
+            component_to_components: HashMap::new(),
+            page_to_components: HashMap::new(),
+        }
+    }
+
+    /// Add a dependency: file (page or component) uses component
+    pub fn add_dependency(&mut self, file: PathBuf, component: PathBuf, file_is_component: bool) {
+        if file_is_component {
+            // Component uses another component
+            self.component_to_components
+                .entry(component.clone())
+                .or_insert_with(HashSet::new)
+                .insert(file);
+        } else {
+            // Page uses component
+            self.component_to_pages
+                .entry(component.clone())
+                .or_insert_with(HashSet::new)
+                .insert(file.clone());
+
+            self.page_to_components
+                .entry(file)
+                .or_insert_with(HashSet::new)
+                .insert(component);
+        }
+    }
+
+    /// Get all pages that transitively depend on a component (includes component -> component -> page chains)
+    pub fn get_all_dependent_pages(&self, component: &Path) -> HashSet<PathBuf> {
+        let mut all_pages = HashSet::new();
+        let mut visited_components = HashSet::new();
+        self.collect_dependent_pages(component, &mut all_pages, &mut visited_components);
+        all_pages
+    }
+
+    fn collect_dependent_pages(
+        &self,
+        component: &Path,
+        all_pages: &mut HashSet<PathBuf>,
+        visited: &mut HashSet<PathBuf>,
+    ) {
+        // Avoid infinite loops in circular dependencies
+        if !visited.insert(component.to_path_buf()) {
+            return;
+        }
+
+        // Add pages that directly use this component
+        if let Some(pages) = self.component_to_pages.get(component) {
+            all_pages.extend(pages.iter().cloned());
+        }
+
+        // Recursively add pages that use components that use this component
+        if let Some(dependent_components) = self.component_to_components.get(component) {
+            for dep_component in dependent_components {
+                self.collect_dependent_pages(dep_component, all_pages, visited);
+            }
+        }
+    }
+}
+
+/// Extract component references from HTML content
+pub fn extract_component_dependencies(html: &str, components_dir: &Path) -> HashSet<PathBuf> {
+    let mut deps = HashSet::new();
+
+    // 1. <component src="/components/card.html"> - works in both compiled and runtime modes
+    let component_tag_re = Regex::new(r#"<component\s+[^>]*src=["']([^"']+)["']"#).unwrap();
+    for cap in component_tag_re.captures_iter(html) {
+        if let Some(src) = cap.get(1) {
+            let src_path = src.as_str().trim_start_matches('/');
+            deps.insert(PathBuf::from(src_path));
+        }
+    }
+
+    // 2. Custom elements: <UserCard> -> /components/user-card.html
+    let custom_element_re = Regex::new(r"<([A-Z][a-zA-Z0-9]*)[\s>]").unwrap();
+    for cap in custom_element_re.captures_iter(html) {
+        if let Some(tag) = cap.get(1) {
+            let kebab = to_kebab_case(tag.as_str());
+            let component_path = components_dir.join(format!("{}.html", kebab));
+            // Store relative to source root
+            if let Ok(rel_path) = component_path.strip_prefix("/") {
+                deps.insert(rel_path.to_path_buf());
+            } else {
+                deps.insert(component_path);
+            }
+        }
+    }
+
+    deps
+}
+
+/// Convert PascalCase to kebab-case
+fn to_kebab_case(s: &str) -> String {
+    let mut result = String::new();
+    for (i, ch) in s.chars().enumerate() {
+        if ch.is_uppercase() && i > 0 {
+            result.push('-');
+        }
+        result.push(ch.to_ascii_lowercase());
+    }
+    result
+}
+
+/// Check if a path should be blacklisted based on SKIP_FILES patterns
+/// This checks both the filename and all path components relative to source root
+fn is_path_blacklisted(path: &Path, source_root: &Path) -> bool {
+    let file_name = path.file_name().and_then(|n| n.to_str()).unwrap_or("");
+
+    // Check filename against blacklist
+    if should_skip_path(path, file_name) {
+        return true;
+    }
+
+    // Check if any path component (relative to source) matches blacklist
+    if let Ok(relative) = path.strip_prefix(source_root) {
+        for component in relative.components() {
+            if let Some(component_str) = component.as_os_str().to_str() {
+                if should_skip_path(path, component_str) {
+                    return true;
+                }
+            }
+        }
+    }
+
+    false
+}
+
+/// Build dependency graph by scanning all HTML files
+pub fn build_dependency_graph(config: &Config) -> std::result::Result<DependencyGraph, std::io::Error> {
+    let mut graph = DependencyGraph::new();
+
+    // Canonicalize output path for reliable comparison
+    let canonical_output = config.output.canonicalize()
+        .unwrap_or_else(|_| config.output.clone());
+
+    // Scan all HTML files in source directory
+    scan_directory(&config.source, &config.source, &config.components, &canonical_output, &mut graph)?;
+
+    Ok(graph)
+}
+
+fn scan_directory(
+    dir: &Path,
+    source_root: &Path,
+    components_dir: &str,
+    output_dir: &Path,
+    graph: &mut DependencyGraph,
+) -> std::result::Result<(), std::io::Error> {
+    if !dir.is_dir() {
+        return Ok(());
+    }
+
+    let components_path = source_root.join(components_dir);
+
+    for entry in std::fs::read_dir(dir)? {
+        let entry = entry?;
+        let path = entry.path();
+        let file_name = path.file_name().and_then(|n| n.to_str()).unwrap_or("");
+
+        if path.is_dir() {
+            // Skip output directory (dynamically check, not hardcoded "compiled")
+            let canonical_path = path.canonicalize().unwrap_or_else(|_| path.clone());
+            if canonical_path.starts_with(output_dir) {
+                continue;
+            }
+
+            // Skip directories using shared skip logic
+            if should_skip_path(&path, file_name) {
+                continue;
+            }
+
+            scan_directory(&path, source_root, components_dir, output_dir, graph)?;
+        } else if let Some(ext) = path.extension() {
+            if ext == "html" {
+                let html = std::fs::read_to_string(&path)?;
+                let deps = extract_component_dependencies(&html, &components_path);
+
+                // Check if this file is itself a component
+                let file_is_component = path.starts_with(&components_path);
+
+                for dep in deps {
+                    let dep_absolute = source_root.join(&dep);
+                    // Canonicalize to handle case-insensitive filesystems (macOS)
+                    let dep_canonical = dep_absolute.canonicalize().unwrap_or(dep_absolute);
+                    graph.add_dependency(path.clone(), dep_canonical, file_is_component);
+                }
+            }
+        }
+    }
+
+    Ok(())
+}
+
+/// Start watching for file changes
+pub fn watch(config: Config, verbose: bool) -> std::result::Result<(), Box<dyn std::error::Error>> {
+    println!("{}", "Building dependency graph...".cyan());
+    let mut graph = build_dependency_graph(&config)?;
+
+    println!("{}", "Running initial compilation...".cyan());
+    let mut compiler = Compiler::new(config.clone(), 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 !config.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.");
+                    }
+                }
+            }
+
+            // Show success headline
+            println!("\n{}", "Initial compilation complete!".green().bold());
+            println!();
+
+            // Show individual phase timings (same as main.rs output)
+
+            // 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);
+            println!();
+        }
+        Err(e) => {
+            eprintln!("{}: {}", "Error".red(), e);
+            eprintln!("Fix the errors and save to retry.");
+            println!();
+        }
+    }
+
+    println!("{}", "Watching for changes... (Ctrl+C to stop)".cyan());
+    println!();
+
+    // Canonicalize output path for reliable comparison
+    let canonical_output = config.output.canonicalize()
+        .unwrap_or_else(|_| config.output.clone());
+
+    // Keep compiler and parser alive to reuse component cache across incremental compilations
+    let mut watch_compiler = Compiler::new(config.clone(), false);
+    let parser = {
+        use crate::parser::HtmlParser;
+        let mut p = HtmlParser::new(config.components_path());
+        if let Err(e) = p.load_elements() {
+            eprintln!("{}: Failed to load parser: {}", "Error".red(), e);
+            return Err(Box::new(e));
+        }
+        p
+    };
+
+    let (tx, rx) = channel();
+    let mut debouncer = new_debouncer(Duration::from_millis(100), None, tx)?;
+
+    debouncer.watcher().watch(&config.source, RecursiveMode::Recursive)?;
+
+    loop {
+        match rx.recv() {
+            Ok(result) => {
+                match result {
+                    Ok(events) => {
+                        // Collect unique paths from events
+                        let mut changed_paths: HashSet<PathBuf> = HashSet::new();
+
+                        for event in events {
+                            for path in &event.paths {
+                                // Skip blacklisted files/directories (check entire path, not just filename)
+                                if is_path_blacklisted(path, &config.source) {
+                                    continue;
+                                }
+
+                                if let Some(ext) = path.extension() {
+                                    if ext == "html" || ext == "css" || ext == "js" {
+                                        changed_paths.insert(path.clone());
+                                    }
+                                }
+                            }
+                        }
+
+                        if changed_paths.is_empty() {
+                            continue;
+                        }
+
+                        // Determine what needs recompiling
+                        let mut pages_to_recompile: HashSet<PathBuf> = HashSet::new();
+
+                        for path in &changed_paths {
+                            // Skip files in output directory (avoid infinite loop)
+                            let canonical_path = path.canonicalize().unwrap_or_else(|_| path.clone());
+                            if canonical_path.starts_with(&canonical_output) {
+                                continue;
+                            }
+
+                            // Skip blacklisted files/directories
+                            if is_path_blacklisted(path, &config.source) {
+                                continue;
+                            }
+
+                            let relative_path = path.strip_prefix(&config.source)
+                                .unwrap_or(path);
+
+                            // Check if it's a component
+                            if path.starts_with(&config.source.join(&config.components)) {
+                                // Component changed - recompile all transitively dependent pages
+                                // Canonicalize to match how dependencies were stored (handles case sensitivity)
+                                let path_canonical = path.canonicalize().unwrap_or_else(|_| path.clone());
+                                let dependent_pages = graph.get_all_dependent_pages(&path_canonical);
+                                if !dependent_pages.is_empty() {
+                                    println!("{} {} changed", "[watch]".cyan(), relative_path.display());
+                                    pages_to_recompile.extend(dependent_pages);
+                                }
+                            } else if let Some(ext) = path.extension() {
+                                if ext == "html" {
+                                    // Page changed - recompile just this page
+                                    println!("{} {} changed", "[watch]".cyan(), relative_path.display());
+                                    pages_to_recompile.insert(path.clone());
+
+                                    // Rebuild dependencies for this page
+                                    if let Ok(html) = std::fs::read_to_string(path) {
+                                        let components_path = config.source.join(&config.components);
+                                        let deps = extract_component_dependencies(&html, &components_path);
+
+                                        // Clear old dependencies for this page
+                                        if let Some(old_deps) = graph.page_to_components.get(path) {
+                                            for dep in old_deps {
+                                                if let Some(pages) = graph.component_to_pages.get_mut(dep) {
+                                                    pages.remove(path);
+                                                }
+                                            }
+                                        }
+
+                                        // Add new dependencies
+                                        graph.page_to_components.insert(path.clone(), HashSet::new());
+                                        for dep in deps {
+                                            let dep_absolute = config.source.join(&dep);
+                                            let dep_canonical = dep_absolute.canonicalize().unwrap_or(dep_absolute);
+                                            graph.add_dependency(path.clone(), dep_canonical, false);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+
+                        // Separate HTML files (from dependency graph) and CSS/JS assets (from changed_paths)
+                        let html_files: Vec<PathBuf> = pages_to_recompile.into_iter().collect();
+
+                        let mut asset_files: Vec<PathBuf> = Vec::new();
+                        for path in &changed_paths {
+                            // Skip files in output directory
+                            let canonical_path = path.canonicalize().unwrap_or_else(|_| path.clone());
+                            if canonical_path.starts_with(&canonical_output) {
+                                continue;
+                            }
+
+                            // Skip blacklisted files/directories
+                            if is_path_blacklisted(path, &config.source) {
+                                continue;
+                            }
+
+                            if let Some(ext) = path.extension().and_then(|e| e.to_str()) {
+                                if ext == "css" || ext == "js" {
+                                    asset_files.push(path.clone());
+                                }
+                            }
+                        }
+
+                        if html_files.is_empty() && asset_files.is_empty() {
+                            continue;
+                        }
+
+                        let start = std::time::Instant::now();
+
+                        // Use persistent compiler and parser (cache is preserved)
+                        let mut total_stats = super::CompileStats {
+                            files_compiled: 0,
+                            files_copied: 0,
+                            internal_components_unique: 0,
+                            external_components_unique: 0,
+                            internal_components_total: 0,
+                            external_components_total: 0,
+                            compile_time_ms: 0.0,
+                            copy_time_ms: 0.0,
+                            components_time_ms: 0.0,
+                            validation_time_ms: None,
+                            node_modules_time_ms: None,
+                            package_manager: None,
+                            node_modules_copied_as_is: false,
+                            components_as_is: config.components_as_is,
+                        };
+
+                        let mut manifest_stats_result = None;
+                        let mut had_errors = false;
+
+                        // Compile HTML files
+                        if !html_files.is_empty() {
+                                match watch_compiler.compile_specific_html_files(&html_files, &parser) {
+                                    Ok(stats) => {
+                                        total_stats.files_compiled = stats.files_compiled;
+                                        total_stats.internal_components_total = stats.internal_components_total;
+                                        total_stats.external_components_total = stats.external_components_total;
+                                        total_stats.internal_components_unique = stats.internal_components_unique;
+                                        total_stats.external_components_unique = stats.external_components_unique;
+                                        total_stats.compile_time_ms = stats.compile_time_ms;
+
+                                        // Generate manifests for affected HTML files
+                                        if !config.runtime_as_is {
+                                            match watch_compiler.generate_manifests_for_files(&html_files) {
+                                                Ok(manifest_stats) => {
+                                                    manifest_stats_result = Some(manifest_stats);
+                                                }
+                                                Err(e) => {
+                                                    eprintln!("{}: Manifest generation failed: {}", "Warning".yellow(), e);
+                                                }
+                                            }
+                                        }
+                                    }
+                                    Err(e) => {
+                                        eprintln!("{}: {}", "Error".red(), e);
+                                        eprintln!("Fix the errors and save to retry.");
+                                        println!();
+                                        had_errors = true;
+                                    }
+                                }
+                        }
+
+                        // Copy asset files
+                        if !asset_files.is_empty() && !had_errors {
+                            match watch_compiler.copy_specific_asset_files(&asset_files) {
+                                Ok(stats) => {
+                                    total_stats.files_copied = stats.files_copied;
+                                    total_stats.copy_time_ms = stats.copy_time_ms;
+                                }
+                                Err(e) => {
+                                    eprintln!("{}: {}", "Error".red(), e);
+                                    eprintln!("Fix the errors and save to retry.");
+                                    println!();
+                                    had_errors = true;
+                                }
+                            }
+                        }
+
+                        if !had_errors {
+                            // Show what was updated
+                            if total_stats.files_compiled > 0 {
+                                println!("{} Compiled {} HTML file{}",
+                                    "✓".green(),
+                                    total_stats.files_compiled,
+                                    if total_stats.files_compiled == 1 { "" } else { "s" }
+                                );
+                            }
+
+                            if let Some(manifest_stats) = manifest_stats_result {
+                                if manifest_stats.pages_processed > 0 {
+                                    println!("{} Generated {} manifest{}",
+                                        "✓".green(),
+                                        manifest_stats.pages_processed,
+                                        if manifest_stats.pages_processed == 1 { "" } else { "s" }
+                                    );
+                                }
+                            }
+
+                            if total_stats.files_copied > 0 {
+                                println!("{} Copied {} asset file{}",
+                                    "✓".green(),
+                                    total_stats.files_copied,
+                                    if total_stats.files_copied == 1 { "" } else { "s" }
+                                );
+                            }
+
+                            let elapsed = start.elapsed().as_millis();
+                            println!("{} Updated in {}ms", "✓".green(), elapsed);
+                        }
+                        println!();
+                    }
+                    Err(errors) => {
+                        for error in errors {
+                            eprintln!("{}: {:?}", "Watch error".red(), error);
+                        }
+                    }
+                }
+            }
+            Err(e) => {
+                eprintln!("{}: {}", "Channel error".red(), e);
+                break;
+            }
+        }
+    }
+
+    Ok(())
+}