@ape-egg/vibe 1.0.3 → 1.1.1

package/compiler/src/compiler/compile.rs

@@ -0,0 +1,1209 @@
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::time::Instant;
+use std::collections::{BTreeMap, HashSet, HashMap};
+use thiserror::Error;
+use colored::Colorize;
+use regex::Regex;
+
+use crate::config::Config;
+use crate::parser::HtmlParser;
+
+// =============================================================================
+// MIRROR_MODE: Copy asset files from source to output as-is, preserving
+// directory structure. HTML files are compiled separately.
+//
+// Asset whitelist approach: Common web asset extensions automatically copied.
+// Future refactoring: Replace with configurable include/exclude patterns,
+// or a more sophisticated asset pipeline.
+// =============================================================================
+const MIRROR_EXTENSIONS: &[&str] = &[
+    "css", "js",
+    // Fonts
+    "ttf", "otf", "woff", "woff2", "eot",
+    // Images
+    "png", "jpg", "jpeg", "gif", "svg", "webp", "avif", "ico",
+    // Media
+    "mp4", "webm", "ogg", "mp3", "wav", "flac", "aac",
+    // Documents
+    "pdf",
+    // Data
+    "json", "xml", "csv",
+];
+
+// Directories to skip when walking source
+const SKIP_DIRECTORIES: &[&str] = &[
+    ".git",
+    ".claude",
+    "compiled",      // Don't copy output into itself
+    "target",        // Rust build artifacts
+    "test-results",
+    "playwright-report",
+];
+
+#[derive(Error, Debug)]
+pub enum CompileError {
+    #[error("Source directory not found: {0}")]
+    SourceNotFound(String),
+    #[error("Failed to create output directory: {0}")]
+    CreateDirError(String),
+    #[error("Failed to read file {path}: {source}")]
+    ReadError {
+        path: String,
+        #[source]
+        source: std::io::Error,
+    },
+    #[error("Failed to write file {path}: {source}")]
+    WriteError {
+        path: String,
+        #[source]
+        source: std::io::Error,
+    },
+    #[error("{file}:{line} - {message}")]
+    ValidationError {
+        file: String,
+        line: usize,
+        message: String,
+    },
+    #[error("Parse error: {0}")]
+    ParseError(#[from] crate::parser::html::ParseError),
+    #[error("Failed to execute command: {0}")]
+    CommandError(String),
+    #[error("Package manager not found")]
+    PackageManagerNotFound,
+    #[error("Component validation failed")]
+    ComponentValidationFailed(Vec<ComponentError>),
+}
+
+#[derive(Debug)]
+pub struct ComponentError {
+    pub component_src: String,
+    pub referenced_in: String,
+    pub error_message: String,
+}
+
+pub struct CompileStats {
+    pub files_compiled: usize,
+    pub files_copied: usize,
+    pub internal_components_unique: usize,
+    pub external_components_unique: usize,
+    pub internal_components_total: usize,
+    pub external_components_total: usize,
+    pub compile_time_ms: f64,
+    pub copy_time_ms: f64,
+    pub components_time_ms: f64,
+    pub validation_time_ms: Option<f64>,
+    pub node_modules_time_ms: Option<f64>,
+    pub package_manager: Option<String>,
+    pub node_modules_copied_as_is: bool,
+    pub components_as_is: bool,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+enum FileOperation {
+    Compiled,
+    Copied,
+}
+
+struct VerboseLogger {
+    operations: BTreeMap<String, Vec<(String, FileOperation)>>, // dir -> [(filename, operation)]
+    component_counts: HashMap<String, usize>, // component src -> count
+    component_children: HashMap<String, HashSet<String>>, // component src -> direct children
+    components_as_is: bool,
+}
+
+impl VerboseLogger {
+    fn new(components_as_is: bool) -> Self {
+        Self {
+            operations: BTreeMap::new(),
+            component_counts: HashMap::new(),
+            component_children: HashMap::new(),
+            components_as_is,
+        }
+    }
+
+    fn log_component_occurrence(&mut self, src: String) {
+        // Increment count for this component
+        *self.component_counts.entry(src).or_insert(0) += 1;
+    }
+
+    fn log_component_children(&mut self, src: String, children: Vec<String>) {
+        // Track children relationships
+        if !children.is_empty() {
+            self.component_children
+                .entry(src)
+                .or_insert_with(HashSet::new)
+                .extend(children);
+        }
+    }
+
+    fn log(&mut self, path: &Path, operation: FileOperation, source_root: &Path) {
+        let relative = path.strip_prefix(source_root).unwrap_or(path);
+        let dir = relative.parent()
+            .map(|p| p.to_string_lossy().to_string())
+            .unwrap_or_else(|| String::from(""));
+        let filename = relative.file_name()
+            .map(|f| f.to_string_lossy().to_string())
+            .unwrap_or_default();
+
+        self.operations
+            .entry(dir)
+            .or_insert_with(Vec::new)
+            .push((filename, operation));
+    }
+
+    fn print_components(&self) {
+        if self.components_as_is {
+            println!("\n{} (0 {}, 0 {}) - \"components-as-is\": true",
+                "Compiled components".bright_cyan(),
+                "internal".bright_green(),
+                "external".bright_magenta()
+            );
+            return;
+        }
+
+        if self.component_counts.is_empty() {
+            return;
+        }
+
+        // Count internal vs external
+        let mut internal_total = 0;
+        let mut external_total = 0;
+        for (src, count) in &self.component_counts {
+            if src.starts_with("http://") || src.starts_with("https://") {
+                external_total += count;
+            } else {
+                internal_total += count;
+            }
+        }
+
+        println!("\n{} ({} {}, {} {})",
+            "Compiled components".bright_cyan().bold(),
+            internal_total,
+            "internal".bright_green(),
+            external_total,
+            "external".bright_magenta()
+        );
+        println!();
+
+        // Sort components by count (descending) then alphabetically
+        let mut components: Vec<_> = self.component_counts.iter().collect();
+        components.sort_by(|(a_src, a_count), (b_src, b_count)| {
+            b_count.cmp(a_count).then_with(|| a_src.cmp(b_src))
+        });
+
+        // Find top-level components (those not referenced as children of others)
+        let all_children: HashSet<String> = self.component_children
+            .values()
+            .flat_map(|children| children.iter().cloned())
+            .collect();
+
+        // Print each top-level component with its tree
+        for (src, count) in &components {
+            // Only show as top-level if it's not a child of another component
+            if !all_children.contains(*src) {
+                let is_external = src.starts_with("http://") || src.starts_with("https://");
+
+                let display = if is_external {
+                    format!("{} ({})", src, count).bright_magenta()
+                } else {
+                    format!("{} ({})", src, count).bright_green()
+                };
+
+                println!("{}", display);
+
+                // Print children if any
+                if let Some(children) = self.component_children.get(*src) {
+                    let mut children_vec: Vec<_> = children.iter().collect();
+                    children_vec.sort();
+
+                    for child in children_vec {
+                        let is_external = child.starts_with("http://") || child.starts_with("https://");
+                        let display = if is_external {
+                            format!("  └─ {}", child).bright_magenta()
+                        } else {
+                            format!("  └─ {}", child).bright_green()
+                        };
+                        println!("{}", display);
+                    }
+                }
+            }
+        }
+    }
+
+    fn print_compiled(&self) {
+        self.print_operations("Compiled HTML", FileOperation::Compiled);
+    }
+
+    fn print_copied(&self) {
+        self.print_operations("Copied files", FileOperation::Copied);
+    }
+
+    fn print_operations(&self, label: &str, op_type: FileOperation) {
+        let matching: Vec<_> = self.operations.iter()
+            .map(|(dir, files)| {
+                let filtered: Vec<_> = files.iter()
+                    .filter(|(_, op)| {
+                        match (&op_type, op) {
+                            (FileOperation::Compiled, FileOperation::Compiled) => true,
+                            (FileOperation::Copied, FileOperation::Copied) => true,
+                            _ => false,
+                        }
+                    })
+                    .map(|(name, _)| name.clone())
+                    .collect();
+                (dir.clone(), filtered)
+            })
+            .filter(|(_, files)| !files.is_empty())
+            .collect();
+
+        if matching.is_empty() {
+            return;
+        }
+
+        let total_count: usize = matching.iter().map(|(_, files)| files.len()).sum();
+        println!("\n{} ({})", label.bright_cyan().bold(), total_count);
+        println!();
+
+        // Root files first
+        if let Some((_, files)) = matching.iter().find(|(dir, _)| dir.is_empty()) {
+            for file in files {
+                println!("  {}", file);
+            }
+        }
+
+        // Then directories hierarchically
+        self.print_directories(&matching, "", 1);
+    }
+
+    fn print_directories(&self, matching: &[(String, Vec<String>)], parent: &str, depth: usize) {
+        // Find all directories at this level
+        let mut dirs_at_level: std::collections::BTreeSet<String> = std::collections::BTreeSet::new();
+
+        for (dir, _) in matching {
+            if dir.is_empty() {
+                continue;
+            }
+
+            let remainder = if parent.is_empty() {
+                if dir.starts_with(parent) {
+                    dir.as_str()
+                } else {
+                    continue;
+                }
+            } else {
+                if dir.starts_with(parent) && dir.len() > parent.len() {
+                    &dir[parent.len() + 1..] // +1 for the separator
+                } else {
+                    continue;
+                }
+            };
+
+            if let Some(slash_pos) = remainder.find('/') {
+                dirs_at_level.insert(remainder[..slash_pos].to_string());
+            } else if !remainder.is_empty() {
+                dirs_at_level.insert(remainder.to_string());
+            }
+        }
+
+        // Print each directory
+        for dir_name in dirs_at_level {
+            let full_path = if parent.is_empty() {
+                dir_name.clone()
+            } else {
+                format!("{}/{}", parent, dir_name)
+            };
+
+            let indent = "  ".repeat(depth);
+
+            // Count files directly in this directory (not subdirectories)
+            let file_count = matching.iter()
+                .find(|(d, _)| d == &full_path)
+                .map(|(_, files)| files.len())
+                .unwrap_or(0);
+
+            if file_count > 0 {
+                println!("{}{} ({})", indent, format!("/{}", dir_name).cyan(), file_count);
+            } else {
+                println!("{}{}", indent, format!("/{}", dir_name).cyan());
+            }
+
+            // Print files in this directory
+            if let Some((_, files)) = matching.iter().find(|(d, _)| d == &full_path) {
+                for file in files {
+                    println!("{}  {}", indent, file);
+                }
+            }
+
+            // Recurse into subdirectories
+            self.print_directories(matching, &full_path, depth + 1);
+        }
+    }
+}
+
+pub struct Compiler {
+    config: Config,
+    verbose: bool,
+    logger: Option<VerboseLogger>,
+    unique_components: HashSet<String>,
+    scanned_components: HashSet<String>,
+    external_component_cache: std::collections::HashMap<String, String>,
+}
+
+impl Compiler {
+    pub fn new(config: Config, verbose: bool) -> Self {
+        let logger = if verbose { Some(VerboseLogger::new(config.components_as_is)) } else { None };
+        Self {
+            config,
+            verbose,
+            logger,
+            unique_components: HashSet::new(),
+            scanned_components: HashSet::new(),
+            external_component_cache: HashMap::new(),
+        }
+    }
+
+    pub fn compile(&mut self) -> Result<CompileStats, CompileError> {
+        let mut stats = 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: self.config.components_as_is,
+        };
+
+        // Validate source exists
+        if !self.config.source.exists() {
+            return Err(CompileError::SourceNotFound(
+                self.config.source.display().to_string(),
+            ));
+        }
+
+        // Load components for HTML compilation (needed for validation)
+        let mut parser = HtmlParser::new(self.config.components_path());
+        parser.load_elements()?;
+
+        // Validate all components upfront (before creating output directory or touching filesystem)
+        // This happens AFTER parser.load_elements() so custom tags can be transformed to <component> tags
+        if !self.config.components_as_is {
+            let validation_start = Instant::now();
+            if self.verbose {
+                println!("\nValidating components...");
+            }
+            self.validate_all_components(&parser)?;
+            stats.validation_time_ms = Some(validation_start.elapsed().as_secs_f64() * 1000.0);
+            if self.verbose {
+                println!("  All components validated successfully");
+            }
+        }
+
+        // Create output directory
+        if !self.config.output.exists() {
+            fs::create_dir_all(&self.config.output).map_err(|_| {
+                CompileError::CreateDirError(self.config.output.display().to_string())
+            })?;
+            if self.verbose {
+                println!("  Created output directory: {}", self.config.output.display());
+            }
+        }
+
+
+        // Track compile and copy times separately
+        let compile_start = Instant::now();
+        self.process_directory(&self.config.source.clone(), &parser, "", &mut stats)?;
+        let process_time = compile_start.elapsed();
+
+        // Print verbose output after processing (components first, then HTML, then copied)
+        if let Some(ref logger) = self.logger {
+            logger.print_components();
+            logger.print_compiled();
+            logger.print_copied();
+        }
+
+        // Calculate unique components after processing all files
+        let internal_unique = self.unique_components.iter()
+            .filter(|src| !src.starts_with("http://") && !src.starts_with("https://"))
+            .count();
+        let external_unique = self.unique_components.iter()
+            .filter(|src| src.starts_with("http://") || src.starts_with("https://"))
+            .count();
+
+        stats.internal_components_unique = internal_unique;
+        stats.external_components_unique = external_unique;
+
+        // Calculate times based on counts (rough estimate)
+        // Component operations are part of compile time but tracked separately for user visibility
+        let total_files = stats.files_compiled + stats.files_copied;
+        let total_components = stats.internal_components_total + stats.external_components_total;
+
+        if total_files > 0 {
+            let total_ms = process_time.as_secs_f64() * 1000.0;
+
+            if total_components > 0 {
+                // Component processing is slowest, compile is medium, copy is fastest
+                // Rough weights: component=3, compile=2, copy=1
+                let total_weight = (total_components * 3 + stats.files_compiled * 2 + stats.files_copied) as f64;
+                stats.components_time_ms = (total_ms * (total_components * 3) as f64) / total_weight;
+                stats.compile_time_ms = (total_ms * (stats.files_compiled * 2) as f64) / total_weight;
+                stats.copy_time_ms = (total_ms * stats.files_copied as f64) / total_weight;
+            } else {
+                // No component operations, just split between compile and copy
+                stats.compile_time_ms = (total_ms * stats.files_compiled as f64) / total_files as f64;
+                stats.copy_time_ms = (total_ms * stats.files_copied as f64) / total_files as f64;
+            }
+        }
+
+        // Handle node_modules after successful compilation
+        if self.config.working_dir.join("node_modules").exists() {
+            if self.config.node_modules_as_is {
+                // Copy node_modules as-is (no install, just copy)
+                let nm_start = Instant::now();
+                self.copy_node_modules_as_is()?;
+                stats.node_modules_time_ms = Some(nm_start.elapsed().as_secs_f64() * 1000.0);
+                stats.node_modules_copied_as_is = true;
+
+                if self.verbose {
+                    println!("\n  Copied node_modules as-is");
+                }
+            } else {
+                // Use production-only strategy (runs install commands)
+                let pkg_manager = detect_package_manager(&self.config.working_dir).ok();
+                stats.package_manager = pkg_manager.clone();
+
+                let nm_start = Instant::now();
+                self.copy_production_node_modules()?;
+                stats.node_modules_time_ms = Some(nm_start.elapsed().as_secs_f64() * 1000.0);
+
+                if self.verbose {
+                    println!("  Copied production dependencies");
+                }
+            }
+        }
+
+        Ok(stats)
+    }
+
+    /// Recursively walk source, compile HTML, copy CSS/JS (MIRROR_MODE)
+    fn process_directory(
+        &mut self,
+        dir: &Path,
+        parser: &HtmlParser,
+        relative_path: &str,
+        stats: &mut CompileStats,
+    ) -> Result<(), CompileError> {
+        let entries = fs::read_dir(dir).map_err(|e| CompileError::ReadError {
+            path: dir.display().to_string(),
+            source: e,
+        })?;
+
+        for entry in entries.flatten() {
+            let path = entry.path();
+            let file_name = path.file_name().unwrap().to_str().unwrap();
+
+            if path.is_dir() {
+                // Skip special directories
+                if SKIP_DIRECTORIES.contains(&file_name) {
+                    continue;
+                }
+
+                // Skip node_modules (handled separately after compilation)
+                if file_name == "node_modules" {
+                    continue;
+                }
+
+                // Handle components directory based on components_as_is flag
+                if file_name == self.config.components {
+                    if self.config.components_as_is {
+                        // Copy components directory to output for runtime
+                        let new_relative = if relative_path.is_empty() {
+                            file_name.to_string()
+                        } else {
+                            format!("{}/{}", relative_path, file_name)
+                        };
+                        self.copy_directory(&path, &new_relative, stats)?;
+                    }
+                    // Skip further processing (don't recurse into components)
+                    continue;
+                }
+
+                // Recurse into subdirectory
+                let new_relative = if relative_path.is_empty() {
+                    file_name.to_string()
+                } else {
+                    format!("{}/{}", relative_path, file_name)
+                };
+
+                self.process_directory(&path, parser, &new_relative, stats)?;
+            } else if let Some(ext) = path.extension().and_then(|e| e.to_str()) {
+                match ext {
+                    "html" => {
+                        let (internal, external, component_srcs) = self.compile_html_file(&path, parser, relative_path)?;
+                        stats.files_compiled += 1;
+                        stats.internal_components_total += internal;
+                        stats.external_components_total += external;
+
+                        // Track unique components
+                        for src in &component_srcs {
+                            self.unique_components.insert(src.clone());
+                        }
+
+                        // Build component relationships and count occurrences before borrowing logger
+                        let (component_relationships, all_srcs) = if self.logger.is_some() && !component_srcs.is_empty() {
+                            let relationships = self.build_component_relationships(&component_srcs);
+                            (Some(relationships), Some(component_srcs))
+                        } else {
+                            (None, None)
+                        };
+
+                        if let Some(ref mut logger) = self.logger {
+                            logger.log(&path, FileOperation::Compiled, &self.config.source);
+
+                            // Log each component occurrence (for counting)
+                            if let Some(all_srcs) = all_srcs {
+                                for src in all_srcs {
+                                    logger.log_component_occurrence(src);
+                                }
+                            }
+
+                            // Log unique relationships (for tree structure)
+                            if let Some(relationships) = component_relationships {
+                                for (src, children) in relationships {
+                                    logger.log_component_children(src, children);
+                                }
+                            }
+                        }
+                    }
+                    // MIRROR_MODE: Copy CSS/JS as-is
+                    ext if MIRROR_EXTENSIONS.contains(&ext) => {
+                        self.copy_file(&path, relative_path)?;
+                        stats.files_copied += 1;
+                        if let Some(ref mut logger) = self.logger {
+                            logger.log(&path, FileOperation::Copied, &self.config.source);
+                        }
+                    }
+                    _ => {}
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    fn compile_html_file(
+        &self,
+        path: &Path,
+        parser: &HtmlParser,
+        relative_path: &str,
+    ) -> Result<(usize, usize, Vec<String>), CompileError> {
+        let content = fs::read_to_string(path).map_err(|e| CompileError::ReadError {
+            path: path.display().to_string(),
+            source: e,
+        })?;
+
+        // Validate if requested
+        if self.config.validate {
+            self.validate_html(&content, path)?;
+        }
+
+        // Count <component src="..."> instances before processing (only if not components_as_is)
+        let (internal_count, external_count, component_srcs) = if !self.config.components_as_is {
+            self.extract_components(&content)
+        } else {
+            (0, 0, Vec::new())
+        };
+
+        // Compile: transform custom tags to <component>, inline if needed, accessibility transform
+        let processed = parser.process_html_with_cache(
+            &content,
+            self.config.accessibility,
+            &self.config.exclude_tags,
+            self.config.components_as_is,
+            &self.config.components,
+            &self.external_component_cache,
+        );
+
+        // Minify if requested
+        let output = if self.config.minify {
+            minify_html(&processed)
+        } else {
+            processed
+        };
+
+        // Write to output
+        let output_path = self.get_output_path(path, relative_path)?;
+        fs::write(&output_path, output).map_err(|e| CompileError::WriteError {
+            path: output_path.display().to_string(),
+            source: e,
+        })?;
+
+        // Return component counts and src list
+        Ok((internal_count, external_count, component_srcs))
+    }
+
+    fn extract_components(&self, content: &str) -> (usize, usize, Vec<String>) {
+        let mut internal = 0;
+        let mut external = 0;
+        let mut srcs = Vec::new();
+
+        // Simple regex-based extraction of <component src="..."> tags
+        let re = Regex::new(r#"<component[^>]+src\s*=\s*["']([^"']+)["']"#).unwrap();
+        for cap in re.captures_iter(content) {
+            if let Some(src) = cap.get(1) {
+                let src_str = src.as_str().to_string();
+                if src_str.starts_with("http://") || src_str.starts_with("https://") {
+                    external += 1;
+                } else {
+                    internal += 1;
+                }
+                srcs.push(src_str);
+            }
+        }
+
+        (internal, external, srcs)
+    }
+
+    fn build_component_relationships(&mut self, component_srcs: &[String]) -> Vec<(String, Vec<String>)> {
+        let mut relationships = Vec::new();
+        let mut visited = HashSet::new();
+
+        for src in component_srcs {
+            self.collect_component_children(src, &mut relationships, &mut visited);
+        }
+
+        relationships
+    }
+
+    fn collect_component_children(&mut self, component_src: &str, relationships: &mut Vec<(String, Vec<String>)>, visited: &mut HashSet<String>) {
+        if visited.contains(component_src) {
+            return;
+        }
+        visited.insert(component_src.to_string());
+
+        // Read component content
+        let content = if component_src.starts_with("http://") || component_src.starts_with("https://") {
+            match self.fetch_external_component(component_src) {
+                Ok(c) => c,
+                Err(_) => return,
+            }
+        } else {
+            match self.resolve_component_path(component_src) {
+                Ok(path) => match fs::read_to_string(&path) {
+                    Ok(c) => c,
+                    Err(_) => return,
+                },
+                Err(_) => return,
+            }
+        };
+
+        // Extract immediate children
+        let children = self.extract_component_srcs(&content);
+
+        // Add this component and its children to relationships
+        relationships.push((component_src.to_string(), children.clone()));
+
+        // Recursively collect children's relationships
+        for child in children {
+            self.collect_component_children(&child, relationships, visited);
+        }
+    }
+
+
+    /// MIRROR_MODE: Copy file to output, preserving relative path
+    fn copy_file(&self, path: &Path, relative_path: &str) -> Result<(), CompileError> {
+        let output_path = self.get_output_path(path, relative_path)?;
+
+        fs::copy(path, &output_path).map_err(|e| CompileError::WriteError {
+            path: output_path.display().to_string(),
+            source: e,
+        })?;
+
+        Ok(())
+    }
+
+    fn validate_all_components(&mut self, parser: &HtmlParser) -> Result<(), CompileError> {
+        let mut errors = Vec::new();
+
+        // Find all HTML files in source directory
+        let html_files = self.find_all_html_files(&self.config.source)?;
+
+        // Scan each HTML file for components
+        for html_file in html_files {
+            let content = match fs::read_to_string(&html_file) {
+                Ok(c) => c,
+                Err(e) => {
+                    errors.push(ComponentError {
+                        component_src: html_file.display().to_string(),
+                        referenced_in: "source".to_string(),
+                        error_message: format!("Failed to read file: {}", e),
+                    });
+                    continue;
+                }
+            };
+
+            // Transform custom tags to <component> tags (e.g., <headline> → <component src="/components/Headline.html">)
+            // Use process_html with elements_as_is=true to transform without inlining
+            let transformed = parser.process_html(
+                &content,
+                false, // accessibility
+                &[], // exclude_tags
+                true, // elements_as_is (don't inline, just transform)
+                &self.config.components,
+            );
+
+            // Extract components from transformed content
+            let components = self.extract_component_srcs(&transformed);
+            for component_src in components {
+                self.validate_component_recursive(
+                    &component_src,
+                    &html_file.display().to_string(),
+                    &mut errors,
+                    parser,
+                );
+            }
+        }
+
+        // If any errors, return them all
+        if !errors.is_empty() {
+            return Err(CompileError::ComponentValidationFailed(errors));
+        }
+
+        Ok(())
+    }
+
+    fn validate_component_recursive(
+        &mut self,
+        component_src: &str,
+        referenced_in: &str,
+        errors: &mut Vec<ComponentError>,
+        parser: &HtmlParser,
+    ) {
+        // Skip if we've already scanned this component
+        if self.scanned_components.contains(component_src) {
+            return;
+        }
+        self.scanned_components.insert(component_src.to_string());
+
+        // Check if it's external (http:// or https://)
+        if component_src.starts_with("http://") || component_src.starts_with("https://") {
+            // Fetch external component
+            match self.fetch_external_component(component_src) {
+                Ok(content) => {
+                    // Transform custom tags in fetched content
+                    let transformed = parser.process_html(
+                        &content,
+                        false,
+                        &[],
+                        true,
+                        &self.config.components,
+                    );
+
+                    // Recursively scan for nested components
+                    let nested = self.extract_component_srcs(&transformed);
+                    for nested_src in nested {
+                        self.validate_component_recursive(&nested_src, component_src, errors, parser);
+                    }
+                }
+                Err(e) => {
+                    errors.push(ComponentError {
+                        component_src: component_src.to_string(),
+                        referenced_in: referenced_in.to_string(),
+                        error_message: e,
+                    });
+                }
+            }
+        } else {
+            // Internal component - resolve path
+            let component_path = self.resolve_component_path(component_src);
+            match component_path {
+                Ok(path) => {
+                    // Read component file
+                    match fs::read_to_string(&path) {
+                        Ok(content) => {
+                            // Transform custom tags in component content
+                            let transformed = parser.process_html(
+                                &content,
+                                false,
+                                &[],
+                                true,
+                                &self.config.components,
+                            );
+
+                            // Recursively scan for nested components
+                            let nested = self.extract_component_srcs(&transformed);
+                            for nested_src in nested {
+                                self.validate_component_recursive(&nested_src, component_src, errors, parser);
+                            }
+                        }
+                        Err(e) => {
+                            errors.push(ComponentError {
+                                component_src: component_src.to_string(),
+                                referenced_in: referenced_in.to_string(),
+                                error_message: format!("Failed to read component file: {}", e),
+                            });
+                        }
+                    }
+                }
+                Err(e) => {
+                    errors.push(ComponentError {
+                        component_src: component_src.to_string(),
+                        referenced_in: referenced_in.to_string(),
+                        error_message: e,
+                    });
+                }
+            }
+        }
+    }
+
+    fn fetch_external_component(&mut self, url: &str) -> Result<String, String> {
+        // Check cache first
+        if let Some(cached) = self.external_component_cache.get(url) {
+            return Ok(cached.clone());
+        }
+
+        // Fetch from URL
+        match reqwest::blocking::get(url) {
+            Ok(response) => {
+                if !response.status().is_success() {
+                    return Err(format!("HTTP {} - {}", response.status().as_u16(), response.status().canonical_reason().unwrap_or("Unknown")));
+                }
+                match response.text() {
+                    Ok(content) => {
+                        // Cache the result
+                        self.external_component_cache.insert(url.to_string(), content.clone());
+                        Ok(content)
+                    }
+                    Err(e) => Err(format!("Failed to read response body: {}", e)),
+                }
+            }
+            Err(e) => Err(format!("Failed to fetch: {}", e)),
+        }
+    }
+
+    fn resolve_component_path(&self, component_src: &str) -> Result<PathBuf, String> {
+        // Normalize path (remove leading ./ or /)
+        let normalized = component_src.trim_start_matches("./").trim_start_matches('/');
+
+        // Try relative to source root
+        let path = self.config.source.join(normalized);
+        if path.exists() {
+            return Ok(path);
+        }
+
+        Err(format!("Component file not found: {}", component_src))
+    }
+
+    fn extract_component_srcs(&self, content: &str) -> Vec<String> {
+        let mut srcs = Vec::new();
+        let re = Regex::new(r#"<component[^>]+src\s*=\s*["']([^"']+)["']"#).unwrap();
+        for cap in re.captures_iter(content) {
+            if let Some(src) = cap.get(1) {
+                srcs.push(src.as_str().to_string());
+            }
+        }
+        srcs
+    }
+
+    fn find_all_html_files(&self, dir: &Path) -> Result<Vec<PathBuf>, CompileError> {
+        let mut html_files = Vec::new();
+        self.find_html_files_recursive(dir, &mut html_files)?;
+        Ok(html_files)
+    }
+
+    fn find_html_files_recursive(&self, dir: &Path, files: &mut Vec<PathBuf>) -> Result<(), CompileError> {
+        if !dir.is_dir() {
+            return Ok(());
+        }
+
+        let entries = match fs::read_dir(dir) {
+            Ok(e) => e,
+            Err(_) => return Ok(()), // Skip directories we can't read
+        };
+
+        for entry in entries {
+            let entry = match entry {
+                Ok(e) => e,
+                Err(_) => continue,
+            };
+
+            let path = entry.path();
+            let file_name = entry.file_name();
+            let file_name_str = file_name.to_string_lossy();
+
+            // Skip hidden files and specific directories
+            if file_name_str.starts_with('.') || SKIP_DIRECTORIES.contains(&file_name_str.as_ref()) {
+                continue;
+            }
+
+            // Skip components directory during initial scan (we'll validate them when referenced)
+            if file_name_str == self.config.components {
+                continue;
+            }
+
+            if path.is_dir() {
+                self.find_html_files_recursive(&path, files)?;
+            } else if path.extension().and_then(|e| e.to_str()) == Some("html") {
+                files.push(path);
+            }
+        }
+
+        Ok(())
+    }
+
+    fn get_output_path(&self, path: &Path, relative_path: &str) -> Result<PathBuf, CompileError> {
+        let file_name = path.file_name().unwrap();
+
+        let output_path = if relative_path.is_empty() {
+            self.config.output.join(file_name)
+        } else {
+            let output_subdir = self.config.output.join(relative_path);
+            fs::create_dir_all(&output_subdir).map_err(|_| {
+                CompileError::CreateDirError(output_subdir.display().to_string())
+            })?;
+            output_subdir.join(file_name)
+        };
+
+        Ok(output_path)
+    }
+
+    fn validate_html(&self, content: &str, path: &Path) -> Result<(), CompileError> {
+        let mut line_num = 1;
+
+        for line in content.lines() {
+            let quote_count = line.matches('"').count();
+            if quote_count % 2 != 0 {
+                return Err(CompileError::ValidationError {
+                    file: path.display().to_string(),
+                    line: line_num,
+                    message: "Unclosed quote".to_string(),
+                });
+            }
+            line_num += 1;
+        }
+
+        Ok(())
+    }
+
+    /// Copy an entire directory recursively
+    fn copy_directory(
+        &mut self,
+        dir: &Path,
+        relative_path: &str,
+        stats: &mut CompileStats,
+    ) -> Result<(), CompileError> {
+        let entries = fs::read_dir(dir).map_err(|e| CompileError::ReadError {
+            path: dir.display().to_string(),
+            source: e,
+        })?;
+
+        for entry in entries.flatten() {
+            let path = entry.path();
+            let file_name = path.file_name().unwrap().to_str().unwrap();
+
+            if path.is_dir() {
+                let new_relative = format!("{}/{}", relative_path, file_name);
+                self.copy_directory(&path, &new_relative, stats)?;
+            } else {
+                self.copy_file(&path, relative_path)?;
+                stats.files_copied += 1;
+                if let Some(ref mut logger) = self.logger {
+                    logger.log(&path, FileOperation::Copied, &self.config.source);
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Copy node_modules as-is to output
+    fn copy_node_modules_as_is(&self) -> Result<(), CompileError> {
+        let src = self.config.working_dir.join("node_modules");
+        let dest = self.config.output.join("node_modules");
+
+        // Remove existing node_modules in output if it exists
+        if dest.exists() {
+            fs::remove_dir_all(&dest).map_err(|e| CompileError::WriteError {
+                path: dest.display().to_string(),
+                source: e,
+            })?;
+        }
+
+        // Copy recursively
+        copy_dir_recursive(&src, &dest)?;
+
+        Ok(())
+    }
+
+    /// Install production dependencies directly into output directory
+    fn copy_production_node_modules(&self) -> Result<(), CompileError> {
+        let pkg_manager = detect_package_manager(&self.config.working_dir)?;
+
+        if self.verbose {
+            println!("\n  Detected package manager: {}", pkg_manager);
+            println!("  Installing production dependencies to output...");
+        }
+
+        // 1. Copy package.json to output directory
+        let package_json_src = self.config.working_dir.join("package.json");
+        let package_json_dest = self.config.output.join("package.json");
+
+        fs::copy(&package_json_src, &package_json_dest).map_err(|e| CompileError::WriteError {
+            path: package_json_dest.display().to_string(),
+            source: e,
+        })?;
+
+        // 2. Copy lockfile if it exists (needed for reproducible installs)
+        let lockfile_name = match pkg_manager.as_str() {
+            "bun" => "bun.lockb",
+            "pnpm" => "pnpm-lock.yaml",
+            "yarn" => "yarn.lock",
+            "npm" => "package-lock.json",
+            _ => "",
+        };
+
+        if !lockfile_name.is_empty() {
+            let lockfile_src = self.config.working_dir.join(lockfile_name);
+            let lockfile_dest = self.config.output.join(lockfile_name);
+            if lockfile_src.exists() {
+                fs::copy(&lockfile_src, &lockfile_dest).ok();
+            }
+        }
+
+        // 3. Install production dependencies directly in output directory
+        run_command(&pkg_manager, &["install", "--production"], &self.config.output)?;
+
+        // 4. Cleanup: remove package.json and lockfile from output
+        fs::remove_file(&package_json_dest).ok();
+        if !lockfile_name.is_empty() {
+            let lockfile_dest = self.config.output.join(lockfile_name);
+            fs::remove_file(&lockfile_dest).ok();
+        }
+
+        if self.verbose {
+            println!("  Installed production dependencies to output");
+        }
+
+        Ok(())
+    }
+}
+
+/// Detect package manager from lockfiles
+fn detect_package_manager(dir: &Path) -> Result<String, CompileError> {
+    if dir.join("bun.lockb").exists() {
+        return Ok("bun".to_string());
+    }
+    if dir.join("pnpm-lock.yaml").exists() {
+        return Ok("pnpm".to_string());
+    }
+    if dir.join("yarn.lock").exists() {
+        return Ok("yarn".to_string());
+    }
+    if dir.join("package-lock.json").exists() {
+        return Ok("npm".to_string());
+    }
+
+    Err(CompileError::PackageManagerNotFound)
+}
+
+/// Run a package manager command
+fn run_command(pkg_manager: &str, args: &[&str], cwd: &Path) -> Result<(), CompileError> {
+    let output = Command::new(pkg_manager)
+        .args(args)
+        .current_dir(cwd)
+        .output()
+        .map_err(|e| CompileError::CommandError(format!("{} not found: {}", pkg_manager, e)))?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        return Err(CompileError::CommandError(format!(
+            "{} {} failed: {}",
+            pkg_manager,
+            args.join(" "),
+            stderr
+        )));
+    }
+
+    Ok(())
+}
+
+/// Recursively copy a directory
+fn copy_dir_recursive(src: &Path, dest: &Path) -> Result<(), CompileError> {
+    if !dest.exists() {
+        fs::create_dir_all(dest).map_err(|_| CompileError::CreateDirError(dest.display().to_string()))?;
+    }
+
+    for entry in fs::read_dir(src).map_err(|e| CompileError::ReadError {
+        path: src.display().to_string(),
+        source: e,
+    })? {
+        let entry = entry.map_err(|e| CompileError::ReadError {
+            path: src.display().to_string(),
+            source: e,
+        })?;
+        let path = entry.path();
+        let file_name = entry.file_name();
+        let dest_path = dest.join(&file_name);
+
+        if path.is_dir() {
+            copy_dir_recursive(&path, &dest_path)?;
+        } else {
+            fs::copy(&path, &dest_path).map_err(|e| CompileError::WriteError {
+                path: dest_path.display().to_string(),
+                source: e,
+            })?;
+        }
+    }
+
+    Ok(())
+}
+
+/// Basic HTML minification
+fn minify_html(html: &str) -> String {
+    let mut result = String::with_capacity(html.len());
+    let mut in_pre = false;
+    let mut last_was_space = false;
+
+    for line in html.lines() {
+        let trimmed = line.trim();
+
+        if trimmed.contains("<pre") {
+            in_pre = true;
+        }
+        if trimmed.contains("</pre>") {
+            in_pre = false;
+        }
+
+        if in_pre {
+            result.push_str(line);
+            result.push('\n');
+        } else {
+            for c in trimmed.chars() {
+                if c.is_whitespace() {
+                    if !last_was_space {
+                        result.push(' ');
+                        last_was_space = true;
+                    }
+                } else {
+                    result.push(c);
+                    last_was_space = false;
+                }
+            }
+        }
+    }
+
+    let result = regex::Regex::new(r">\s+<")
+        .unwrap()
+        .replace_all(&result, "><")
+        .to_string();
+
+    result.trim().to_string()
+}