static-site-builder 0.1.4 → 1.0.0

data/lib/static_site_builder/builder.rb

@@ -9,23 +9,47 @@ require "json"
 require "pathname"
 require "digest"
 
+# Create minimal ActionController stub for meta-tags gem compatibility
+# meta-tags expects ActionController to be available but we're using ActionView standalone
+unless defined?(ActionController)
+  module ActionController
+    class Base
+      # meta-tags gem calls ActionController::Base.helpers
+      # In Rails, this returns an instance that includes ActionView::Helpers
+      # We create a simple object that extends ActionView::Helpers modules
+      def self.helpers
+        @helpers ||= Object.new.tap do |helper_obj|
+          helper_obj.extend(ActionView::Helpers::TagHelper)
+          helper_obj.extend(ActionView::Helpers::OutputSafetyHelper)
+          helper_obj.extend(ActionView::Helpers::TextHelper)
+        end
+      end
+    end
+  end
+end
+
+# Require meta-tags gem (handle Railtie gracefully for non-Rails usage)
 begin
-  require "importmap-rails"
-rescue LoadError
-  # importmap-rails is optional
+  require "meta_tags"
+rescue NameError => e
+  # If Rails::Railtie is not available, require components directly
+  if e.message.include?("Railtie")
+    require "meta_tags/meta_tags_collection"
+    require "meta_tags/view_helper"
+  else
+    raise
+  end
 end
 
+
 module StaticSiteBuilder
   class Builder
-    def initialize(root: Dir.pwd, template_engine: "erb", js_bundler: "importmap", importmap_config: nil, annotate_template_file_names: nil)
+    # Output directory name
+    DIST_DIR = "dist"
+    # Default JavaScript entry point
+    JS_ENTRY_POINT = "application"
+    def initialize(root: Dir.pwd, annotate_template_file_names: nil)
       @root = Pathname.new(root)
-      @template_engine = template_engine
-      @js_bundler = js_bundler
-      @importmap_config_path = if importmap_config
-        Pathname.new(importmap_config)
-      else
-        @root.join("config", "importmap.rb")
-      end
 
       # Auto-enable annotations in development (when LIVE_RELOAD is enabled)
       @annotate_template_file_names = if annotate_template_file_names.nil?
@@ -33,428 +57,213 @@ module StaticSiteBuilder
       else
         annotate_template_file_names
       end
-
-      @importmap = if defined?(Importmap::Map)
-        Importmap::Map.new
-      else
-        SimpleImportMap.new(root: @root)
-      end
-
-      load_importmap_config if @js_bundler == "importmap"
     end
 
-    # Build the static site
+    # Builds the complete static site.
     #
-    # Compiles all templates, copies assets, generates importmap (if needed),
-    # and outputs everything to the dist/ directory.
+    # Compiles ERB templates to HTML, copies JavaScript and CSS assets, and outputs
+    # everything to the dist/ directory. In development mode, files are updated in place
+    # to prevent 404 errors during live reload. In production mode, the dist directory
+    # is cleaned first for a fresh build.
     #
     # @return [void]
     def build
       puts "Building static site..."
 
-      dist_dir = @root.join("dist")
+      dist_dir = @root.join(DIST_DIR)
       
-      # Only clean dist directory for production/release builds
-      # In development, update files in place to prevent 404s during rebuilds
+      # Clean dist directory only for production/release builds
+      # In development, update files in place to prevent 404s during live reload
       production_build = ENV["PRODUCTION"] == "true" || ENV["RELEASE"] == "true"
       if production_build
         if dist_dir.exist?
           puts "Cleaning dist directory for production build..."
           FileUtils.rm_rf(dist_dir)
-        else
-          puts "Dist directory does not exist, skipping clean"
         end
       end
       
       # Ensure dist directory exists
       FileUtils.mkdir_p(dist_dir)
 
-      # Copy assets (overwrites existing files)
+      # Copy JavaScript and CSS assets to dist
       copy_assets(dist_dir)
 
-      # Generate importmap JSON if using importmap (overwrites existing file)
-      generate_importmap(dist_dir) if @js_bundler == "importmap"
+      # Compile ERB templates to static HTML pages
+      compile_erb_pages(dist_dir)
 
-      # Compile pages based on template engine (overwrites existing files)
-      case @template_engine
-      when "erb"
-        compile_erb_pages(dist_dir)
-      when "phlex"
-        compile_phlex_pages(dist_dir)
-      end
-
-      # Copy static files (overwrites existing files)
+      # Copy static files from public/ directory to dist
       copy_static_files(dist_dir)
 
-      # Notify WebSocket server (always update, even if file doesn't exist yet)
+      # Notify WebSocket server of rebuild for live reload
+      # Always update the reload file, even if it doesn't exist yet
       reload_file = @root.join(".reload")
-      File.write(reload_file, Time.now.to_f.to_s)
+      File.write(reload_file, Time.current.to_f.to_s)
 
       puts "\n✓ Build complete! Output in #{dist_dir}"
     end
 
-    # Public method to render partials - no longer needed as ActionView handles this directly
-    # ActionView's render method automatically finds and renders partials from app/views
-    # This method is kept for backwards compatibility but should not be called
-    def render_partial(partial_path, view_context, locals = {})
-      # ActionView handles partial rendering automatically through its render method
-      # When templates call render 'shared/header', ActionView finds _header.html.erb automatically
-      begin
-        view_context.render(partial: partial_path, locals: locals)
-      rescue ActionView::MissingTemplate => e
-        # Convert ActionView's error to our format for backwards compatibility
-        raise "Partial not found: #{partial_path} (looked for #{e.path})"
-      end
-    end
-
-    private
-
-    def load_importmap_config
-      return unless @importmap_config_path.exist?
-
-      config_content = File.read(@importmap_config_path)
-      # Replace relative paths with absolute paths
-      config_content = config_content.gsub(/"app\//, %("#{@root.join("app").to_s}/))
-      config_content = config_content.gsub(/"vendor\//, %("#{@root.join("vendor").to_s}/))
-
-      # Replace File.expand_path calls with actual paths
-      config_content = config_content.gsub(/File\.expand_path\(["'](.*?)["'], __dir__\)/) do |match|
-        path = $1
-        @root.join("config", path).expand_path.to_s.inspect
-      end
-
-      @importmap.instance_eval(config_content, @importmap_config_path.to_s)
-    end
-
-    def copy_assets(dist_dir)
-      puts "Copying assets..."
-
-      # Copy JavaScript files
-      js_dir = @root.join("app", "javascript")
-      if js_dir.exist? && js_dir.directory?
-        dist_js = dist_dir.join("assets", "javascripts")
-        FileUtils.mkdir_p(dist_js)
-        # Copy all files and subdirectories from js_dir to dist_js
-        Dir.glob(js_dir.join("*")).each do |item|
-          FileUtils.cp_r(item, dist_js, preserve: true)
-        end
-      end
-
-      # Copy vendor JavaScript files directly from node_modules to dist (for importmap)
-      if @js_bundler == "importmap"
-        copy_vendor_files_from_node_modules(dist_dir)
-      end
-
-      # Copy CSS (skip if Tailwind is handling it - check for tailwind.config.js)
-      # Tailwind outputs directly to dist, so we don't want to overwrite with raw files
-      # But we still need to ensure the directory exists for Tailwind to write to
-      tailwind_config = @root.join("tailwind.config.js")
-      css_dir = @root.join("app", "assets", "stylesheets")
-      dist_css = dist_dir.join("assets", "stylesheets")
-      
-      if tailwind_config.exist?
-        # Tailwind is handling CSS - ensure directory exists but don't copy raw files
-        FileUtils.mkdir_p(dist_css)
-      elsif css_dir.exist? && css_dir.directory?
-        # No Tailwind - copy CSS files normally
-        FileUtils.mkdir_p(dist_css)
-        Dir.glob(css_dir.join("*")).each do |item|
-          FileUtils.cp_r(item, dist_css, preserve: true)
-        end
-      end
-    end
-
-    def copy_vendor_files_from_node_modules(dist_dir)
-      return unless @importmap_config_path && @importmap_config_path.exist?
-
-      config_content = File.read(@importmap_config_path.to_s)
-      dist_js = dist_dir.join("assets", "javascripts")
-      FileUtils.mkdir_p(dist_js)
-
-      # Extract vendor file references from importmap config
-      # Look for patterns like: pin "@hotwired/stimulus", to: "stimulus.min.js"
-      # Only process pins that have 'to:' specified (vendor files), not local app files
-      config_content.scan(/pin\s+["']([^"']+)["'],\s*to:\s*["']([^"']+)["']/) do |package_name, file_name|
-        # Skip if this is a local app file
-        next if file_name.start_with?("app/") || file_name.start_with?("./app/")
-
-        # Only try to copy npm packages (scoped packages like @hotwired/stimulus or known packages)
-        # Skip simple names like "application" that are local files
-        next unless package_name.include?("/") || package_name.start_with?("@")
-
-        dest_file = dist_js.join(file_name)
-        next if dest_file.exist?
-
-        # Try to copy directly from node_modules to dist
-        if copy_vendor_file_from_node_modules(package_name, file_name, dest_file)
-          puts "  ✓ Copied #{file_name} from #{package_name}"
-        else
-          puts "  ⚠️  Warning: Could not find #{file_name} for #{package_name} in node_modules"
-          puts "     Ensure 'npm install' has been run and the package is installed."
-        end
-      end
-    end
-
-    def copy_vendor_file_from_node_modules(package_name, file_name, dest_file)
-      node_modules = @root.join("node_modules")
-      return false unless node_modules.exist?
-
-      package_dir = node_modules.join(*package_name.split("/"))
-      return false unless package_dir.exist?
-
-      # Try common source paths for the package
-      # Extract base name from file_name (e.g., "stimulus.min.js" -> "stimulus")
-      base_name = file_name.gsub(/\.(min\.)?js$/, "")
-      source_paths = [
-        "dist/#{base_name}.js",
-        "dist/#{base_name}.min.js",
-        "dist/index.js",
-        "#{base_name}.js",
-        "index.js",
-        "dist/#{file_name}",
-        file_name
-      ]
-
-      source_paths.each do |source_path|
-        source_file = package_dir.join(*source_path.split("/"))
-        if source_file.exist? && source_file.file?
-          FileUtils.cp(source_file, dest_file)
-          return true
-        end
-      end
-
-      false
-    end
-
-    def generate_importmap(dist_dir)
-      return unless defined?(@importmap) && @importmap
-
-      puts "Generating importmap..."
-
-      # Create a simple resolver for asset paths
-      resolver = AssetResolver.new(@root, dist_dir)
-
-      importmap_json = @importmap.to_json(resolver: resolver)
-
-      FileUtils.mkdir_p(dist_dir.join("assets"))
-      File.write(dist_dir.join("assets", "importmap.json"), JSON.pretty_generate(JSON.parse(importmap_json)))
-    end
-
-    def compile_erb_pages(dist_dir)
-      pages_dir = @root.join("app", "views", "pages")
-      return unless pages_dir.exist?
-
-      # Generate importmap JSON once for all pages
-      resolver = AssetResolver.new(@root, dist_dir)
-      importmap_json_str = @importmap.to_json(resolver: resolver) if defined?(@importmap) && @importmap
-
-      # Find all ERB files, including nested directories
-      Dir.glob(pages_dir.join("**", "*.html.erb")).each do |erb_file|
-        relative_path = Pathname.new(erb_file).relative_path_from(pages_dir)
-        page_name = relative_path.to_s.gsub(/\.html\.erb$/, ".html")
+    # Helper methods that need to be accessible from closures.
+    #
+    # These methods are public to allow access from ActionView template closures,
+    # but they are considered internal API and should not be called directly.
 
-        compile_erb_page(erb_file, page_name, dist_dir, importmap_json_str)
+    # Accesses hash values using either symbol or string keys.
+    #
+    # Tries each key in order until a non-nil value is found. This allows
+    # compatibility with both symbol and string keys in options hashes.
+    #
+    # @param hash [Hash] The hash to search
+    # @param keys [Array<Symbol, String>] Keys to try in order
+    # @return [Object, nil] The first non-nil value found, or nil if none found
+    def hash_value(hash, *keys)
+      keys.each do |key|
+        value = hash[key]
+        return value if value.present?
       end
+      nil
     end
 
-    def compile_erb_page(erb_file, page_name, dist_dir, importmap_json_str)
-      puts "Compiling #{page_name}..."
-
-      # Read ERB content - ActionView will process it directly
-      content = File.read(erb_file)
-
-      # Default layout
-      layout = "application"
 
-      # Load layout - try .html.erb first, then .html
-      layout_file = @root.join("app", "views", "layouts", "#{layout}.html.erb")
-      layout_file = @root.join("app", "views", "layouts", "#{layout}.html") unless layout_file.exist?
+    # Load layout content, trying .html.erb first, then .html, or default layout
+    def load_layout_content
+      layout = StaticSiteBuilder::DEFAULT_LAYOUT_NAME
+      layout_file = @root.join('app', 'views', 'layouts', "#{layout}.html.erb")
+      layout_file = @root.join('app', 'views', 'layouts', "#{layout}.html") unless layout_file.exist?
       layout_content = layout_file.exist? ? File.read(layout_file) : default_layout
 
       # Inject live reload script if enabled and using custom layout
-      if ENV["LIVE_RELOAD"] == "true" && layout_file.exist?
-        # Inject live reload into custom layouts too
-        unless layout_content.include?("live reload") || layout_content.include?("LIVE_RELOAD")
-          ws_port = ENV["WS_PORT"] || 3001
-          live_reload_script = <<~HTML
-            <script>
-              (function() {
-                function connect() {
-                  var ws = new WebSocket('ws://localhost:#{ws_port}');
-                  ws.onmessage = function(e) {
-                    if (e.data === 'reload') window.location.reload();
-                  };
-                  ws.onclose = function() { setTimeout(connect, 1000); };
-                  ws.onerror = function() {};
-                }
-                connect();
-              })();
-            </script>
-          HTML
-          layout_content = layout_content.gsub(/<\/body>/, "#{live_reload_script}</body>")
+      if ENV['LIVE_RELOAD'] == 'true' && layout_file.exist?
+        unless layout_content.include?('live reload') || layout_content.include?('LIVE_RELOAD')
+          script = live_reload_script
+          layout_content = layout_content.gsub(/<\/body>/, "#{script}</body>") unless script.blank?
         end
       end
 
-      # Set current_page based on the file being compiled
-      current_page_path = if page_name == 'index.html'
-        '/'
-      else
-        "/#{page_name.gsub(/\.html$/, '')}"
-      end
+      [layout_content, layout_file]
+    end
 
-      # Create ActionView lookup context with view paths
-      view_paths = ActionView::PathSet.new([@root.join("app", "views").to_s])
+    # Setup ActionView context and create view instance
+    #
+    # Creates an ActionView::Base instance with helpers included (Rails pattern).
+    # Helpers are included on the class before instantiation, which is more
+    # Rails-like than extending individual instances.
+    def setup_action_view_context
+      view_paths = ActionView::PathSet.new([@root.join('app', 'views').to_s])
       lookup_context = ActionView::LookupContext.new(view_paths)
-      
-      # Create ActionView::Base instance for rendering using with_empty_template_cache
-      # This is the recommended way for standalone ActionView usage
       view_class = ActionView::Base.with_empty_template_cache
-      view = view_class.new(lookup_context, {}, self)
-
-      # Include PageHelpers if available (look in project root)
-      # Only require once (first time)
-      unless defined?(@page_helpers_loaded)
-        begin
-          page_helpers_path = @root.join('lib', 'page_helpers.rb')
-          if page_helpers_path.exist?
-            require page_helpers_path.to_s
-            @page_helpers_loaded = true
-          end
-        rescue LoadError
-          # PageHelpers not available, continue without it
-        end
-      end
       
-      # Extend view with PageHelpers if available
-      if defined?(PageHelpers)
-        view.extend(PageHelpers) unless view.singleton_class.included_modules.include?(PageHelpers)
-      end
-
-      # Set instance variables that will be available in templates
-      # Pages can set @title, @js_modules, etc. via ERB at the top
-      view.instance_variable_set(:@js_modules, [])
-      view.instance_variable_set(:@importmap_json, importmap_json_str) if importmap_json_str
-      view.instance_variable_set(:@current_page, current_page_path)
-      view.instance_variable_set(:@page_content, nil)
+      # Include helpers on the class (Rails pattern) rather than extending instances
+      view_class.include(MetaTags::ViewHelper) unless view_class.included_modules.include?(MetaTags::ViewHelper)
       
-      # Set title and metadata from PageHelpers BEFORE rendering page content
-      # This ensures partials rendered within the page have access to metadata
-      page_helpers_path = @root.join('lib', 'page_helpers.rb')
-      begin
-        if page_helpers_path.exist?
-          require page_helpers_path.to_s
-          pages = ::PageHelpers::PAGES rescue nil
-          if pages && pages.is_a?(Hash) && pages.key?(current_page_path)
-            metadata = pages[current_page_path]
-            view.instance_variable_set(:@title, metadata[:title])
-            view.instance_variable_set(:@description, metadata[:description])
-            view.instance_variable_set(:@url, metadata[:url])
-            view.instance_variable_set(:@image, metadata[:image])
-          end
-        end
-      rescue => e
-        # Silently continue if PageHelpers can't be loaded
-      end
+      # Automatically load helpers from app/helpers/
+      load_helpers(view_class)
       
-      # Override render to handle 'footer' -> 'shared/footer' conversion
-      # and ensure locals are passed to partials
-      view.define_singleton_method(:render) do |options = {}, locals = {}, &block|
+      view = view_class.new(lookup_context, {}, self)
+      view
+    end
+
+    # Automatically load helper modules from app/helpers/ directory
+    def load_helpers(view_class)
+      helpers_dir = @root.join('app', 'helpers')
+      return unless helpers_dir.exist? && helpers_dir.directory?
+
+      Dir.glob(helpers_dir.join('**', '*_helper.rb')).each do |helper_file|
         begin
-          # Handle string/symbol partial names: render 'footer' -> render 'shared/footer'
-          if options.is_a?(String) || options.is_a?(Symbol)
-            partial_name = options.to_s
-            # If no path separator, assume it's in shared/
-            unless partial_name.include?('/')
-              partial_name = "shared/#{partial_name}"
-            end
-            # Merge page locals with any provided locals
-            merged_locals = {
-              importmap_json: importmap_json_str,
-              current_page: current_page_path
-            }.merge(locals.is_a?(Hash) ? locals : {})
-            super(partial: partial_name, locals: merged_locals, &block)
-          elsif options.is_a?(Hash)
-            # Handle hash options: render partial: 'footer', locals: {}
-            partial_path = options[:partial] || options['partial']
-            if partial_path
-              # Convert 'footer' to 'shared/footer' if no path
-              unless partial_path.to_s.include?('/')
-                partial_path = "shared/#{partial_path}"
-              end
-              # Merge page locals with provided locals
-              provided_locals = options[:locals] || options['locals'] || {}
-              merged_locals = {
-                importmap_json: importmap_json_str,
-                current_page: current_page_path
-              }.merge(provided_locals)
-              super(partial: partial_path, locals: merged_locals, &block)
-            else
-              # Other render options (template, etc.)
-              super(options, locals, &block)
-            end
-          else
-            super(options, locals, &block)
+          # Get the module name from the file (e.g., app/helpers/application_helper.rb -> ApplicationHelper)
+          relative_path = Pathname.new(helper_file).relative_path_from(helpers_dir)
+          module_name = relative_path.to_s.gsub(/\.rb$/, '').split('_').map(&:capitalize).join
+          
+          # Load the file (use load instead of require for absolute paths)
+          load helper_file
+          
+          # Include the module if it exists
+          if Object.const_defined?(module_name)
+            helper_module = Object.const_get(module_name)
+            view_class.include(helper_module) unless view_class.included_modules.include?(helper_module)
           end
-        rescue ActionView::MissingTemplate => e
-          # Convert ActionView's error to our format for backwards compatibility
-          raise "Partial not found: #{partial_path || partial_name || 'unknown'} (looked for #{e.path})"
+        rescue LoadError, NameError => e
+          # Silently skip if helper can't be loaded (e.g., missing dependencies)
+          # This allows users to have helpers that require additional gems
         end
       end
+    end
+
+
+
+    # Render page template using ActionView (file-based, not inline)
+    def render_page_template(view, content, page_name, erb_file)
+      # Calculate the template path relative to app/views
+      # e.g., app/views/pages/index.html.erb -> pages/index
+      pages_dir = @root.join("app", "views", "pages")
+      template_path = Pathname.new(erb_file).relative_path_from(pages_dir).to_s.gsub(/\.html\.erb$/, '')
+      full_template_path = "pages/#{template_path}"
+
+      # Set prefixes on lookup_context so ActionView can resolve partials relative to template directory
+      # For pages/index -> prefix is 'pages', for pages/blog/index -> prefix is 'pages/blog'
+      lookup_context = view.lookup_context
+      original_prefixes = lookup_context.prefixes.dup
+      template_dir = File.dirname(full_template_path)
+      lookup_context.prefixes = [template_dir]
 
-      # Render page content using ActionView
-      # Pages can set instance variables via ERB (e.g., <% @title = '...' %>)
-      page_template = ActionView::Template.new(
-        content,
-        "inline:page",
-        ActionView::Template::Handlers::ERB.new,
-        virtual_path: "pages/#{page_name.gsub(/\.html$/, '')}",
-        format: :html,
-        locals: [:importmap_json, :current_page]
-      )
-      
       begin
-        page_content = view.render(template: page_template, locals: {
-          importmap_json: importmap_json_str,
-          current_page: current_page_path
-        })
+        # Set instance variables on view (Rails pattern: controllers set instance variables)
+        # Templates set their own @title, @description etc. using meta-tags gem
+        
+        # Use file-based rendering - ActionView will find the actual file
+        # With prefixes set, partials can be resolved relative to the template directory
+        template = lookup_context.find_template(full_template_path, [], false, [], {})
+        page_content = view.render(template: template)
       rescue ActionView::Template::Error => e
-        # Convert ActionView errors to our format
         if e.cause.is_a?(ActionView::MissingTemplate)
-          raise "Partial not found: #{e.cause.path} (looked for #{e.cause.path})"
+          raise "Partial template not found. Searched in: #{e.cause.path}"
         end
         raise
+      ensure
+        # Restore original prefixes
+        lookup_context.prefixes = original_prefixes
       end
 
-      # Annotate page content if enabled
       if @annotate_template_file_names
         relative_template_path = Pathname.new(erb_file).relative_path_from(@root)
         page_content = annotate_template(page_content, relative_template_path.to_s)
       end
 
-      # Render layout using ActionView
-      # Instance variables set in the page template are available in the layout
+      page_content
+    end
+
+    # Render layout template using ActionView with proper yield mechanism
+    def render_layout_template(view, layout_content, layout_file, page_content)
+      layout = StaticSiteBuilder::DEFAULT_LAYOUT_NAME
+      
+      # Make page content safe for HTML output
+      safe_page_content = page_content.respond_to?(:html_safe) ? page_content.html_safe : page_content
+      
+      # Create layout template
       layout_template = ActionView::Template.new(
         layout_content,
-        "inline:layout",
+        layout_file.exist? ? layout_file.to_s : 'inline:layout',
         ActionView::Template::Handlers::ERB.new,
         virtual_path: "layouts/#{layout}",
         format: :html,
-        locals: [:page_content, :importmap_json, :current_page]
+        locals: []
       )
-
-      # Mark page_content as HTML safe to prevent escaping
-      # ActionView will escape strings by default in ERB, so we mark it as safe
-      safe_page_content = page_content.respond_to?(:html_safe) ? page_content.html_safe : page_content
       
-      rendered = view.render(template: layout_template, locals: {
-        page_content: safe_page_content,
-        importmap_json: importmap_json_str,
-        current_page: current_page_path
-      })
-
-      # Annotate layout if enabled
-      # Note: We wrap the rendered content without removing existing annotations
-      # This preserves page annotations that are already in the content
+      # Render layout with page content available via yield
+      # In Rails/ActionView, yield in a layout template returns the rendered page content
+      # We achieve this by storing the page content in the view flow before rendering the layout
+      # The view flow's :layout key is what yield accesses
+      original_flow_content = view.view_flow.get(:layout)
+      view.view_flow.set(:layout, safe_page_content)
+      
+      rendered = view.render(template: layout_template)
+      
+      # Restore original flow content if it existed
+      if original_flow_content
+        view.view_flow.set(:layout, original_flow_content)
+      else
+        view.view_flow.set(:layout, nil)
+      end
+
       if @annotate_template_file_names && layout_file.exist?
         relative_layout_path = Pathname.new(layout_file).relative_path_from(@root)
         begin_comment = "<!-- BEGIN #{relative_layout_path} -->"
@@ -462,28 +271,108 @@ module StaticSiteBuilder
         rendered = "#{begin_comment}\n#{rendered}\n#{end_comment}"
       end
 
+      rendered
+    end
+
+    # Write final rendered output to file
+    def write_page_output(dist_dir, page_name, rendered)
       output_path = dist_dir.join(page_name)
       FileUtils.mkdir_p(output_path.dirname)
-      puts "  Debug: Writing #{rendered.length} chars to #{output_path}"
       File.write(output_path, rendered)
+    end
 
-      puts "  ✓ Created #{page_name}"
+
+
+    # Generate live reload WebSocket script if live reload is enabled
+    def live_reload_script
+      if ENV["LIVE_RELOAD"] == "true"
+        ws_port = ENV["WS_PORT"] || StaticSiteBuilder::DEFAULT_WS_PORT
+        <<~HTML
+          <script>
+            (function() {
+              function connect() {
+                var ws = new WebSocket('ws://localhost:#{ws_port}');
+                ws.onmessage = function(e) {
+                  if (e.data === 'reload') window.location.reload();
+                };
+                ws.onclose = function() { setTimeout(connect, 1000); };
+                ws.onerror = function() {};
+              }
+              connect();
+            })();
+          </script>
+        HTML
+      else
+        ""
+      end
+    end
+
+    def copy_assets(dist_dir)
+      puts "Copying assets..."
+
+      # Copy JavaScript files from app/javascript to dist/assets/javascripts
+      js_dir = @root.join("app", "javascript")
+      if js_dir.exist? && js_dir.directory?
+        dist_js = dist_dir.join("assets", "javascripts")
+        FileUtils.mkdir_p(dist_js)
+        # Copy all files and subdirectories recursively
+        Dir.glob(js_dir.join("*")).each do |item|
+          FileUtils.cp_r(item, dist_js, preserve: true)
+        end
+      end
+
+      # Handle CSS files
+      # Copy CSS files from app/assets/stylesheets to dist/assets/stylesheets
+      css_dir = @root.join("app", "assets", "stylesheets")
+      dist_css = dist_dir.join("assets", "stylesheets")
+      
+      if css_dir.exist? && css_dir.directory?
+        FileUtils.mkdir_p(dist_css)
+        Dir.glob(css_dir.join("*")).each do |item|
+          FileUtils.cp_r(item, dist_css, preserve: true)
+        end
+      end
     end
 
-    def compile_phlex_pages(dist_dir)
-      # Phlex compilation will be implemented when phlex-rails is available
+
+    def compile_erb_pages(dist_dir)
       pages_dir = @root.join("app", "views", "pages")
       return unless pages_dir.exist?
 
-      puts "Phlex compilation not yet implemented"
-      # TODO: Implement Phlex page compilation
+      # Find all ERB files, including nested directories
+      Dir.glob(pages_dir.join("**", "*.html.erb")).each do |erb_file|
+        relative_path = Pathname.new(erb_file).relative_path_from(pages_dir)
+        page_name = relative_path.to_s.gsub(/\.html\.erb$/, ".html")
+
+        compile_erb_page(erb_file, page_name, dist_dir)
+      end
+    end
+
+    def compile_erb_page(erb_file, page_name, dist_dir)
+      puts "Compiling page: #{page_name}..."
+
+      layout_content, layout_file = load_layout_content
+      view = setup_action_view_context
+      
+      # Render page template first - this sets up meta tags and content_for blocks
+      # Pass erb_file directly - render_page_template will use file-based rendering
+      # Page templates set their own @title, @description etc. using meta-tags gem
+      page_content = render_page_template(view, nil, page_name, erb_file)
+      
+      # Now render layout with page content available via yield
+      rendered = render_layout_template(view, layout_content, layout_file, page_content)
+      
+      write_page_output(dist_dir, page_name, rendered)
+      
+      puts "  ✓ Created #{page_name}"
     end
 
+
     def copy_static_files(dist_dir)
       public_dir = @root.join("public")
       return unless public_dir.exist? && public_dir.directory?
 
-      puts "Copying public files..."
+      puts "Copying static files from public/..."
       # Copy all files and subdirectories from public to dist
       Dir.glob(public_dir.join("*")).each do |item|
         FileUtils.cp_r(item, dist_dir, preserve: true)
@@ -503,26 +392,7 @@ module StaticSiteBuilder
     end
 
     def default_layout
-      live_reload_script = if ENV["LIVE_RELOAD"] == "true"
-        ws_port = ENV["WS_PORT"] || 3001
-        <<~HTML
-          <script>
-            (function() {
-              function connect() {
-                var ws = new WebSocket('ws://localhost:#{ws_port}');
-                ws.onmessage = function(e) {
-                  if (e.data === 'reload') window.location.reload();
-                };
-                ws.onclose = function() { setTimeout(connect, 1000); };
-                ws.onerror = function() {};
-              }
-              connect();
-            })();
-          </script>
-        HTML
-      else
-        ""
-      end
+      live_reload_script_content = live_reload_script
 
       <<~HTML
         <!DOCTYPE html>
@@ -530,86 +400,21 @@ module StaticSiteBuilder
         <head>
           <meta charset="UTF-8">
           <meta name="viewport" content="width=device-width, initial-scale=1.0">
-          <title><%= @title || 'Site' %></title>
+          <%# Set meta tags in your page templates using: %>
+          <%# <% set_meta_tags title: 'Page Title', description: 'Description' %> %>
+          <%= display_meta_tags %>
           <link rel="stylesheet" href="/assets/stylesheets/application.css">
         </head>
         <body>
-          <%= page_content %>
-          <% if defined?(@importmap_json) && @importmap_json %>
-            <script type="importmap"><%= @importmap_json %></script>
+          <%= yield %>
+          <% if content_for?(:javascript) %>
+            <%= yield(:javascript) %>
           <% end %>
-          <% if @js_modules && !@js_modules.empty? %>
-            <% @js_modules.each do |module_name| %>
-              <script type="module">import "<%= module_name %>";</script>
-            <% end %>
-          <% else %>
-            <script type="module">import "application";</script>
-          <% end %>
-          #{live_reload_script}
+          #{live_reload_script_content}
         </body>
         </html>
       HTML
     end
 
-    # Simple asset resolver for importmap
-    class AssetResolver
-      def initialize(root, dist_dir)
-        @root = root
-        @dist_dir = dist_dir
-      end
-
-      def javascript_path(path)
-        "/assets/javascripts/#{path}"
-      end
-
-      def asset_path(path)
-        "/assets/#{path}"
-      end
-    end
-
-    # Simple importmap implementation if importmap-rails is not available
-    class SimpleImportMap
-      def initialize(root: nil)
-        @pins = {}
-        @root = root || Pathname.new(Dir.pwd)
-      end
-
-      def pin(name, to: nil, preload: true)
-        # If 'to' is provided, use it as-is. Otherwise, default to name.js
-        to_path = to || "#{name}.js"
-        @pins[name] = { to: to_path, preload: preload }
-      end
-
-      def pin_all_from(directory, under: nil)
-        dir_path = Pathname.new(directory)
-        # Resolve to absolute path
-        full_dir_path = dir_path.absolute? ? dir_path : @root.join(dir_path)
-        return unless full_dir_path.exist?
-
-        # Calculate base path from app/javascript for proper resolution
-        app_js_path = @root.join("app", "javascript")
-
-        Dir.glob(full_dir_path.join("**", "*.js")).each do |file|
-          relative_path = Pathname.new(file).relative_path_from(full_dir_path)
-          name = relative_path.to_s.gsub(/\.js$/, "")
-          name = name.gsub(/_controller$/, "")
-          # If under is specified, prepend it to the name
-          name = under ? "#{under}/#{name}" : name
-          # Store full path from app/javascript, preserving directory structure
-          to_path = Pathname.new(file).relative_path_from(app_js_path).to_s
-          pin(name, to: to_path, preload: true)
-        end
-      end
-
-      def to_json(resolver:)
-        imports = {}
-        @pins.each do |name, config|
-          path = resolver.javascript_path(config[:to])
-          imports[name] = path
-        end
-
-        JSON.generate({ imports: imports })
-      end
-    end
   end
 end