static-site-builder 0.1.3 → 1.0.0

data/lib/generator.rb

@@ -6,68 +6,44 @@ require "erb"
 require "json"
 
 module StaticSiteBuilder
-  # Generator for creating new static site projects
+  # Generates new static site projects.
   #
-  # @example Generate a site with default options
-  #   generator = StaticSiteBuilder::Generator.new("my-site")
-  #   generator.generate
+  # Creates a complete project structure including Gemfile, build
+  # configuration files, example pages, and development server setup.
   #
-  # @example Generate a site with custom stack
-  #   generator = StaticSiteBuilder::Generator.new("my-site", {
-  #     template_engine: "phlex",
-  #     js_bundler: "esbuild",
-  #     css_framework: "shadcn",
-  #     js_framework: "react"
-  #   })
+  # @example Generate a site
+  #   generator = StaticSiteBuilder::Generator.new("my-site")
   #   generator.generate
   class Generator
-    # Available template engines
-    TEMPLATE_ENGINES = %w[erb phlex].freeze
-
-    # Available JavaScript bundlers
-    JS_BUNDLERS = %w[importmap esbuild webpack vite none].freeze
-
-    # Available CSS frameworks
-    CSS_FRAMEWORKS = %w[tailwindcss shadcn plain].freeze
 
-    # Available JavaScript frameworks
-    JS_FRAMEWORKS = %w[stimulus react vue alpine vanilla].freeze
+    # Reference StaticSiteBuilder constants for consistency
+    DEFAULT_PORT = StaticSiteBuilder::DEFAULT_PORT
+    DEFAULT_WS_PORT = StaticSiteBuilder::DEFAULT_WS_PORT
 
-    # Initialize a new generator
+    # Initializes a new generator instance.
     #
-    # @param app_name [String] Name of the application/site to generate
-    # @param options [Hash] Configuration options
-    # @option options [String] :template_engine ("erb") Template engine to use (erb or phlex)
-    # @option options [String] :js_bundler ("importmap") JavaScript bundler (importmap, esbuild, webpack, vite, none)
-    # @option options [String] :css_framework ("tailwindcss") CSS framework (tailwindcss, shadcn, plain)
-    # @option options [String] :js_framework ("stimulus") JavaScript framework (stimulus, react, vue, alpine, vanilla)
+    # @param app_name [String] The name of the site to generate (will be used as directory name)
     def initialize(app_name, options = {})
       @app_name = app_name
       @app_path = Pathname.new(app_name)
-      @options = {
-        template_engine: options[:template_engine] || "erb",
-        js_bundler: options[:js_bundler] || "importmap",
-        css_framework: options[:css_framework] || "tailwindcss",
-        js_framework: options[:js_framework] || "stimulus"
-      }
+      @options = {}
     end
 
-    # Generate the static site project
+    # Generates the complete static site project.
     #
-    # Creates all necessary files and directory structure for the project.
-    # Outputs instructions for next steps after generation.
+    # Creates the directory structure, configuration files, example pages, build
+    # scripts, and all necessary dependencies. Provides next steps after successful generation.
     #
     # @return [void]
     def generate
       puts "Generating static site: #{@app_name}"
-      puts "Stack: #{@options[:template_engine]} + #{@options[:js_bundler]} + #{@options[:css_framework]} + #{@options[:js_framework]}"
 
       create_directory_structure
       create_gemfile
-      create_package_json
       create_config_files
       create_app_structure
       create_build_files
+      create_sitemap_config
       create_example_pages
       create_readme
       create_gitignore
@@ -76,10 +52,9 @@ module StaticSiteBuilder
       puts "\nNext steps:"
       puts "  cd #{@app_name}"
       puts "  bundle install"
-      puts "  npm install" if needs_npm?
-      puts "  rake dev:server    # Start development server with auto-rebuild"
+      puts "  bundle exec rake dev:server    # Start development server with live reload"
       puts "  # or"
-      puts "  rake build:all     # Build for production"
+      puts "  bundle exec rake build:all     # Build for deployment"
     end
 
     private
@@ -88,6 +63,7 @@ module StaticSiteBuilder
       dirs = [
         "app/views/layouts",
         "app/views/pages",
+        "app/helpers",
         "app/javascript",
         "app/assets/stylesheets",
         "config",
@@ -102,292 +78,75 @@ module StaticSiteBuilder
 
     def create_gemfile
       gems = [
-        "rake",
-        "static-site-builder",
-        "webrick"  # Required for dev server (removed from stdlib in Ruby 3.0+)
+        'rake',
+        'actionview',
+        'base64', # Required for Ruby 3.4+ (removed from default gems)
+        'webrick', # Required for dev server (removed from stdlib in Ruby 3.0+)
+        'sitemap_generator' # For generating sitemaps from actual pages
       ]
-      gems << "importmap-rails" if @options[:js_bundler] == "importmap"
-      gems << "phlex-rails" if @options[:template_engine] == "phlex"
-      if @options[:edit_rails]
-        gems << "rails"
-        gems << "edit_rails"
-      end
 
       content = <<~RUBY
         # frozen_string_literal: true
 
-        source "https://rubygems.org"
+        source 'https://rubygems.org'
 
-        #{gems.map { |g| %(gem "#{g}") }.join("\n")}
+        #{gems.map { |g| %(gem '#{g}') }.join("\n")}
       RUBY
 
-      write_file("Gemfile", content)
+      write_file('Gemfile', content)
     end
 
-    def create_package_json
-      return unless needs_npm?
-
-      deps = {}
-      dev_deps = {}
-
-      case @options[:js_bundler]
-      when "esbuild"
-        dev_deps["esbuild"] = "^0.19.0"
-      when "webpack"
-        dev_deps["webpack"] = "^5.0.0"
-        dev_deps["webpack-cli"] = "^5.0.0"
-      when "vite"
-        dev_deps["vite"] = "^5.0.0"
-        dev_deps["vite-plugin-ruby"] = "^3.0.0"
-      end
-
-      case @options[:css_framework]
-      when "tailwindcss", "shadcn"
-        dev_deps["tailwindcss"] = "^3.4.0"
-        dev_deps["autoprefixer"] = "^10.4.0"
-        dev_deps["postcss"] = "^8.4.0"
-      end
-
-      case @options[:js_framework]
-      when "react"
-        deps["react"] = "^18.0.0"
-        deps["react-dom"] = "^18.0.0"
-      when "vue"
-        deps["vue"] = "^3.0.0"
-      when "alpine"
-        deps["alpinejs"] = "^3.0.0"
-      when "stimulus"
-        deps["@hotwired/stimulus"] = "^3.2.0"
-      end
-
-      scripts = {}
-      scripts["build"] = build_script
-      scripts["build:css"] = css_build_script if needs_css_build?
-      scripts["watch:css"] = css_watch_script if needs_css_build?
-
-      content = {
-        name: @app_name,
-        version: "1.0.0",
-        description: "Static site generated with static-site-generator",
-        scripts: scripts,
-        dependencies: deps,
-        devDependencies: dev_deps
-      }
-
-      write_file("package.json", JSON.pretty_generate(content))
-    end
 
     def create_config_files
-      create_importmap_config if @options[:js_bundler] == "importmap"
-      create_tailwind_config if @options[:css_framework] == "tailwindcss" || @options[:css_framework] == "shadcn"
-      create_esbuild_config if @options[:js_bundler] == "esbuild"
-      create_webpack_config if @options[:js_bundler] == "webpack"
-      create_vite_config if @options[:js_bundler] == "vite"
-      create_rails_config if @options[:edit_rails]
-    end
-
-    def create_importmap_config
-      content = <<~RUBY
-        # frozen_string_literal: true
-
-        pin "application", preload: true
-        #{stimulus_pin if @options[:js_framework] == "stimulus"}
-      RUBY
-
-      write_file("config/importmap.rb", content)
-    end
-
-    def stimulus_pin
-      <<~RUBY
-        pin "@hotwired/stimulus", to: "stimulus.min.js", preload: true
-        pin_all_from "app/javascript/controllers", under: "controllers"
-      RUBY
-    end
-
-
-    # Detect which package manager is available
-    def detect_package_manager
-      # Check in order: yarn, pnpm, bun, npm
-      return "yarn" if system("which yarn > /dev/null 2>&1")
-      return "pnpm" if system("which pnpm > /dev/null 2>&1")
-      return "bun" if system("which bun > /dev/null 2>&1")
-      return "npm" if system("which npm > /dev/null 2>&1")
-      nil
-    end
-
-    def create_tailwind_config
-      content = <<~JS
-        /** @type {import('tailwindcss').Config} */
-        module.exports = {
-          content: [
-            "./app/views/**/*.{html,erb,phlex}",
-            "./app/javascript/**/*.js",
-          ],
-          theme: {
-            extend: {},
-          },
-          plugins: [],
-        }
-      JS
-
-      write_file("tailwind.config.js", content)
-
-      # Create PostCSS config
-      postcss_content = <<~JS
-        module.exports = {
-          plugins: {
-            tailwindcss: {},
-            autoprefixer: {},
-          },
-        }
-      JS
-
-      write_file("postcss.config.js", postcss_content)
-    end
-
-    def create_esbuild_config
-      content = <<~JS
-        require('esbuild').build({
-          entryPoints: ['app/javascript/application.js'],
-          bundle: true,
-          outdir: 'dist/assets/javascripts',
-          format: 'esm',
-          minify: true,
-        }).catch(() => process.exit(1))
-      JS
-
-      write_file("esbuild.config.js", content)
-    end
-
-    def create_webpack_config
-      content = <<~JS
-        const path = require('path');
-
-        module.exports = {
-          entry: './app/javascript/application.js',
-          output: {
-            filename: 'application.js',
-            path: path.resolve(__dirname, 'dist/assets/javascripts'),
-          },
-          mode: 'production',
-        };
-      JS
-
-      write_file("webpack.config.js", content)
-    end
-
-    def create_vite_config
-      content = <<~JS
-        import { defineConfig } from 'vite';
-        import RubyPlugin from 'vite-plugin-ruby';
-
-        export default defineConfig({
-          plugins: [RubyPlugin()],
-        });
-      JS
-
-      write_file("vite.config.js", content)
     end
 
-    def create_rails_config
-      create_boot_config
-      create_routes_config
-      create_application_config
-      create_environment_file
-      create_environment_configs
-    end
 
-    def create_boot_config
+    def create_sitemap_config
       content = <<~RUBY
         # frozen_string_literal: true
 
-        ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
-
-        require "bundler/setup" # Set up gems listed in the Gemfile.
-      RUBY
-
-      write_file("config/boot.rb", content)
-    end
-
-    def create_routes_config
-      content = <<~RUBY
-        # frozen_string_literal: true
-
-        Rails.application.routes.draw do
-          mount EditRails::Engine => "/edit_rails", as: "edit_rails"
-        end
-      RUBY
-
-      write_file("config/routes.rb", content)
-    end
-
-    def create_application_config
-      content = <<~RUBY
-        # frozen_string_literal: true
-
-        require_relative "boot"
-
-        require "rails/all"
-
-        Bundler.require(*Rails.groups)
-
-        module StaticSite
-          class Application < Rails::Application
-            config.load_defaults Rails::VERSION::STRING.to_f
-
-            # Configuration for the application's routes
-            config.api_only = false
-
-            # Don't generate system test files
-            config.generators.system_tests = nil
-
-            # Serve static files from public directory
-            config.public_file_server.enabled = true
+        require 'sitemap_generator'
+        require 'pathname'
+
+        # Configure sitemap generator
+        # Update default_host to your actual domain
+        SitemapGenerator::Sitemap.default_host = 'https://example.com'
+        SitemapGenerator::Sitemap.sitemaps_path = 'sitemaps'
+        SitemapGenerator::Sitemap.public_path = 'dist'
+
+        # Generate sitemap from templates in app/views (excluding layouts and partials)
+        SitemapGenerator::Sitemap.create do
+          views_dir = Pathname.new('app/views')
+          if views_dir.exist?
+            Dir.glob(views_dir.join('**', '*.html.erb')).each do |erb_file|
+              relative_path = Pathname.new(erb_file).relative_path_from(views_dir)
+              file_name = Pathname.new(erb_file).basename.to_s
+
+              if file_name.start_with?('_') == false && relative_path.to_s.start_with?('layouts/') == false
+                page_name = relative_path.to_s.gsub(/\.html\.erb$/, '')
+
+                # Convert page name to URL path
+                # Handle index pages: 'index' -> '/', 'blog/index' -> '/blog/'
+                path = if page_name == 'index'
+                  '/'
+                elsif page_name.end_with?('/index')
+                  "/\#{page_name[0..-7]}/"
+                else
+                  "/\#{page_name}"
+                end
 
-            # Don't require database
-            config.active_record.maintain_test_schema = false
+                add path, lastmod: File.mtime(erb_file), changefreq: 'weekly', priority: 0.5
+              end
+            end
           end
         end
       RUBY
 
-      write_file("config/application.rb", content)
-    end
-
-    def create_environment_file
-      content = <<~RUBY
-        # frozen_string_literal: true
-
-        # Load the Rails application.
-        require_relative "application"
-
-        # Initialize the Rails application.
-        Rails.application.initialize!
-      RUBY
-
-      write_file("config/environment.rb", content)
+      write_file('config/sitemap.rb', content)
     end
 
-    def create_environment_configs
-      # Create development environment config
-      dev_content = <<~RUBY
-        # frozen_string_literal: true
 
-        require "active_support/core_ext/integer/time"
-
-        Rails.application.configure do
-          config.cache_classes = false
-          config.eager_load = false
-          config.consider_all_requests_local = true
-          config.server_timing = true
-          config.public_file_server.enabled = true
-          config.public_file_server.headers = {
-            "Cache-Control" => "public, max-age=#{1.hour.to_i}"
-          }
-        end
-      RUBY
 
-      write_file("config/environments/development.rb", dev_content)
-    end
 
     def create_app_structure
       create_layout
@@ -396,11 +155,7 @@ module StaticSiteBuilder
     end
 
     def create_layout
-      if @options[:template_engine] == "phlex"
-        create_phlex_layout
-      else
-        create_erb_layout
-      end
+      create_erb_layout
     end
 
     def create_erb_layout
@@ -410,519 +165,677 @@ module StaticSiteBuilder
         <head>
           <meta charset="UTF-8">
           <meta name="viewport" content="width=device-width, initial-scale=1.0">
-          <title><%= frontmatter['title'] || 'Site' %></title>
           <link rel="stylesheet" href="/assets/stylesheets/application.css">
         </head>
         <body>
           <main>
-            <%= page_content %>
+            <%= yield %>
           </main>
 
-          #{importmap_script if @options[:js_bundler] == "importmap"}
-          #{js_script}
+          <% if content_for?(:javascript) %>
+            <%= yield(:javascript) %>
+          <% end %>
+
+          <% if ENV['LIVE_RELOAD'] == 'true' %>
+            <script>
+              (function() {
+                function connect() {
+                  var port = '<%= ENV['WS_PORT'] || #{DEFAULT_WS_PORT} %>';
+                  var ws = new WebSocket('ws://localhost:' + port);
+                  ws.onmessage = function(e) {
+                    if (e.data === 'reload') window.location.reload();
+                  };
+                  ws.onclose = function() { setTimeout(connect, 500); };
+                  ws.onerror = function() {};
+                }
+                connect();
+              })();
+            </script>
+          <% end %>
         </body>
         </html>
       ERB
 
-      write_file("app/views/layouts/application.html.erb", content)
+      write_file('app/views/layouts/application.html.erb', content)
     end
 
-    def create_phlex_layout
+    def create_javascript_entry
+      content = <<~JS
+        // Your JavaScript code here
+        console.log("Application loaded")
+      JS
+
+      write_file('app/javascript/application.js', content)
+    end
+
+    def create_css_entry
+      write_file('app/assets/stylesheets/application.css', <<~CSS)
+        /* Your custom CSS here */
+        body {
+          font-family: system-ui, sans-serif;
+        }
+      CSS
+    end
+
+    def create_build_files
+      create_rakefile
+      create_site_builder
+    end
+
+    def create_rakefile 
       content = <<~RUBY
         # frozen_string_literal: true
-
-        class ApplicationLayout < Phlex::HTML
-          def initialize(title: "Site", **options)
-            @title = title
-            @options = options
+        # encoding: utf-8
+
+        # Set default external encoding to UTF-8
+        Encoding.default_external = Encoding::UTF_8
+
+        require_relative 'lib/site_builder'
+        require 'fileutils'
+        require 'pathname'
+        require 'json'
+
+        namespace :build do
+          desc 'Build everything (assets + HTML + CSS + sitemap)'
+          task :all do
+            Rake::Task['build:clean'].invoke
+            Rake::Task['build:assets'].invoke
+            Rake::Task['build:html'].invoke
+            Rake::Task['build:css'].invoke
+            Rake::Task['build:sitemap'].invoke
+
+            puts "\\n✓ Build complete!"
           end
 
-          def template
-            html do
-              head do
-                meta charset: "UTF-8"
-                meta name: "viewport", content: "width=device-width, initial-scale=1.0"
-                title { @title }
-                link rel: "stylesheet", href: "/assets/stylesheets/application.css"
+          desc 'Build JavaScript assets'
+          task :assets do
+            package_json_path = Pathname.new(Dir.pwd).join('package.json')
+            if package_json_path.exist?
+              package_json = JSON.parse(File.read(package_json_path))
+              build_script = package_json.dig('scripts', 'build')
+
+              if build_script && !build_script.include?('build:css') && build_script != "echo 'No JS bundling needed'"
+                sh 'npm run build'
               end
-              body do
-                main { yield }
-                #{importmap_script if @options[:js_bundler] == "importmap"}
-                #{js_script}
+            else
+              js_dir = Pathname.new(Dir.pwd).join('app', 'javascript')
+              if js_dir.exist?
+                dist_js = Pathname.new(Dir.pwd).join('dist', 'assets', 'javascripts')
+                FileUtils.mkdir_p(dist_js)
+                Dir.glob(js_dir.join('**', '*')).each do |item|
+                  if File.file?(item)
+                    dest = dist_js.join(Pathname.new(item).relative_path_from(js_dir))
+                    FileUtils.mkdir_p(dest.dirname)
+                    FileUtils.cp(item, dest)
+                  end
+                end
               end
             end
           end
-        end
-      RUBY
 
-      write_file("app/views/layouts/application.rb", content)
-    end
+          desc 'Compile all pages to static HTML'
+          task :html => [:assets] do
+            builder = SiteBuilder::Builder.new(root: Dir.pwd)
+            builder.build
+          end
 
-    def importmap_script
-      <<~ERB
-        <script type="importmap">
-        <%= importmap_json %>
-        </script>
-      ERB
-    end
+          desc 'Build CSS (runs after HTML so dist directory exists)'
+          task :css do
+            package_json_path = Pathname.new(Dir.pwd).join('package.json')
+            dist_css = Pathname.new(Dir.pwd).join('dist', 'assets', 'stylesheets')
 
-    def js_script
-      case @options[:js_bundler]
-      when "importmap"
-        <<~ERB
-          <% 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 %>
-        ERB
-      when "esbuild", "webpack", "vite"
-        '<script type="module" src="/assets/javascripts/application.js"></script>'
-      else
-        '<script src="/assets/javascripts/application.js"></script>'
-      end
-    end
+            if package_json_path.exist?
+              package_json = JSON.parse(File.read(package_json_path))
+              if package_json.dig('scripts', 'build:css')
+                sh 'npm run build:css'
+              end
+            elsif File.exist?('tailwind.config.js')
+              if system('which tailwindcss > /dev/null 2>&1')
+                FileUtils.mkdir_p(dist_css)
+                sh 'tailwindcss -i ./app/assets/stylesheets/application.css -o ./dist/assets/stylesheets/application.css --minify'
+              end
+            else
+              css_dir = Pathname.new(Dir.pwd).join('app', 'assets', 'stylesheets')
+              if css_dir.exist?
+                FileUtils.mkdir_p(dist_css)
+                Dir.glob(css_dir.join('**', '*')).each do |item|
+                  if File.file?(item)
+                    dest = dist_css.join(Pathname.new(item).relative_path_from(css_dir))
+                    FileUtils.mkdir_p(dest.dirname)
+                    FileUtils.cp(item, dest)
+                  end
+                end
+              end
+            end
+          end
 
-    def create_javascript_entry
-      case @options[:js_framework]
-      when "stimulus"
-        create_stimulus_entry
-      when "react"
-        create_react_entry
-      when "vue"
-        create_vue_entry
-      when "alpine"
-        create_alpine_entry
-      else
-        create_vanilla_entry
-      end
-    end
+          desc 'Clean dist directory'
+          task :clean do
+            dist_dir = Pathname.new(Dir.pwd).join('dist')
+            FileUtils.rm_rf(dist_dir) if dist_dir.exist?
+            puts "Cleaned \#{dist_dir}"
+          end
 
-    def create_stimulus_entry
-      # Create controllers directory
-      FileUtils.mkdir_p(@app_path.join("app/javascript/controllers"))
+          desc 'Generate sitemap from actual pages'
+          task :sitemap do
+            require './config/sitemap'
+          end
+        end
 
-      # Main entry - starts Application and registers controllers (standard Stimulus pattern)
-      content = <<~JS
-        import { Application } from "@hotwired/stimulus"
+        namespace :dev do
+          desc 'Start development server with auto-rebuild and live reload'
+          task :server do
+            require 'webrick'
+
+            port = ENV['PORT'] || #{DEFAULT_PORT}
+            ws_port = ENV['WS_PORT'] || #{DEFAULT_WS_PORT}
+            dist_dir = Pathname.new(Dir.pwd).join('dist')
+            reload_file = Pathname.new(Dir.pwd).join('.reload')
+
+            ws_server = SiteBuilder::WebSocketServer.new(port: ws_port.to_i, reload_file: reload_file)
+            ws_server.start
+
+            ENV['LIVE_RELOAD'] = 'true'
+            ENV['WS_PORT'] = ws_port.to_s
+
+            Rake::Task['build:html'].invoke
+            Rake::Task['build:css'].invoke
+
+            puts "\\n🚀 Starting development server at http://localhost:\#{port}"
+            puts "📡 WebSocket server at ws://localhost:\#{ws_port}"
+            puts "📝 Watching for changes... (Ctrl+C to stop)"
+            puts "🔄 Live reload enabled - pages will auto-refresh on changes\\n"
+
+            watcher_code = %q{
+              watched = ['app', 'config']
+              exts = ['.erb', '.rb', '.js', '.css']
+              mtimes = {}
+              last_build = Time.now
+
+              loop do
+                changed = false
+
+                watched.each do |dir|
+                  Dir.glob(File.join(dir, '**', '*')).each do |f|
+                    if File.file?(f) && exts.any? { |e| f.end_with?(e) }
+                      mtime = File.mtime(f)
+                      if mtimes[f] != mtime
+                        mtimes[f] = mtime
+                        changed = true
+                      end
+                    end
+                  end
+                end
 
-        window.Stimulus = Application.start()
+                if changed && (Time.now - last_build) > 1
+                  system('rake build:html > /dev/null 2>&1 && rake build:css > /dev/null 2>&1')
+                  last_build = Time.now
+                end
 
-        // Register your controllers here
-        // import HelloController from "./controllers/hello_controller"
-        // Stimulus.register("hello", HelloController)
-      JS
+                sleep 0.5
+              end
+            }
 
-      write_file("app/javascript/application.js", content)
-    end
+            watcher_pid = spawn('ruby', '-e', watcher_code, err: File::NULL, out: File::NULL)
+
+            server = WEBrick::HTTPServer.new(
+              Port: port,
+              BindAddress: '127.0.0.1'
+            )
+
+            server.mount('/assets', WEBrick::HTTPServlet::FileHandler, File.join(dist_dir.to_s, 'assets'))
+            server.mount('/images', WEBrick::HTTPServlet::FileHandler, File.join(dist_dir.to_s, 'images'))
+
+            server.mount_proc('/') do |req, res|
+              path = req.path
+
+              if path == '/'
+                index_path = File.join(dist_dir.to_s, 'index.html')
+                if File.exist?(index_path)
+                  res.status = 200
+                  res['Content-Type'] = 'text/html'
+                  res.body = File.read(index_path)
+                else
+                  res.status = 404
+                  res['Content-Type'] = 'text/plain'
+                  res.body = "Not Found\\n"
+                end
+              else
+                clean_path = path.start_with?('/') ? path[1..] : path
+                served = false
+
+                if !path.include?('.') && !path.end_with?('/')
+                  html_path = File.join(dist_dir.to_s, "\#{clean_path}.html")
+                  if File.exist?(html_path)
+                    res.status = 200
+                    res['Content-Type'] = 'text/html'
+                    res.body = File.read(html_path)
+                    served = true
+                  end
+                end
 
-    def create_react_entry
-      content = <<~JS
-        import React from 'react'
-        import { createRoot } from 'react-dom/client'
-
-        // Import your React components
-        // import App from './components/App'
-
-        document.addEventListener('DOMContentLoaded', () => {
-          const container = document.getElementById('app')
-          if (container) {
-            const root = createRoot(container)
-            root.render(<App />)
-          }
-        })
-      JS
+                if served == false
+                  file_path = File.join(dist_dir.to_s, clean_path)
+
+                  if File.directory?(file_path)
+                    nested_index = File.join(file_path, 'index.html')
+                    if File.exist?(nested_index)
+                      res.status = 200
+                      res['Content-Type'] = 'text/html'
+                      res.body = File.read(nested_index)
+                      served = true
+                    end
+                  elsif File.exist?(file_path) && File.file?(file_path)
+                    res.status = 200
+                    res['Content-Type'] = WEBrick::HTTPUtils.mime_type(file_path, WEBrick::HTTPUtils::DefaultMimeTypes)
+                    res.body = File.read(file_path)
+                    served = true
+                  end
+                end
 
-      write_file("app/javascript/application.js", content)
-    end
+                if served == false
+                  res.status = 404
+                  res['Content-Type'] = 'text/plain'
+                  res.body = "Not Found\\n"
+                end
+              end
+            end
 
-    def create_vue_entry
-      content = <<~JS
-        import { createApp } from 'vue'
+            trap('INT') do
+              puts "\\n\\nShutting down..."
+              Process.kill('TERM', watcher_pid) if watcher_pid
+              ws_server.stop
+              server.shutdown
+            end
 
-        // Import your Vue components
-        // import App from './components/App.vue'
+            server.start
+          end
+        end
 
-        document.addEventListener('DOMContentLoaded', () => {
-          const app = createApp(App)
-          app.mount('#app')
-        })
-      JS
+        task default: 'build:all'
+      RUBY
 
-      write_file("app/javascript/application.js", content)
+      write_file('Rakefile', content)
     end
 
-    def create_alpine_entry
-      content = <<~JS
-        import Alpine from 'alpinejs'
 
-        window.Alpine = Alpine
-        Alpine.start()
-      JS
 
-      write_file("app/javascript/application.js", content)
-    end
+    def create_site_builder
+      content = <<~RUBY
+        # frozen_string_literal: true
 
-    def create_vanilla_entry
-      content = <<~JS
-        // Your vanilla JavaScript code here
-        console.log("Application loaded")
-      JS
+        require 'action_view'
+        require 'action_view/helpers'
+        require 'fileutils'
+        require 'pathname'
+        require 'socket'
+        require 'base64'
+        require 'digest/sha1'
+        require 'json'
+
+        module SiteBuilder
+          DIST_DIR = 'dist'
+          DEFAULT_PORT = 3000
+          DEFAULT_WS_PORT = 3001
+
+          class Builder
+            def initialize(root: Dir.pwd)
+              @root = Pathname.new(root)
+              @dist_dir = @root.join(DIST_DIR)
+              @views_dir = @root.join('app', 'views')
+            end
 
-      write_file("app/javascript/application.js", content)
-    end
+            def build
+              copy_javascript
+              copy_stylesheets
+              compile_views
+              copy_public
+              write_reload_file
+            end
 
-    def create_css_entry
-      case @options[:css_framework]
-      when "tailwindcss"
-        write_file("app/assets/stylesheets/application.css", <<~CSS)
-          @tailwind base;
-          @tailwind components;
-          @tailwind utilities;
-
-          @layer base {
-            html {
-              scroll-behavior: smooth;
-            }
-          }
+            private
 
-          @layer utilities {
-            section[id] {
-              scroll-margin-top: 5rem;
-            }
-          }
-        CSS
-      when "shadcn"
-        write_file("app/assets/stylesheets/application.css", <<~CSS)
-          @tailwind base;
-          @tailwind components;
-          @tailwind utilities;
-
-          @layer base {
-            :root {
-              --background: 0 0% 100%;
-              --foreground: 222.2 84% 4.9%;
-            }
-          }
-        CSS
-      else
-        write_file("app/assets/stylesheets/application.css", <<~CSS)
-          /* Your custom CSS here */
-          body {
-            font-family: system-ui, sans-serif;
-          }
-        CSS
-      end
-    end
+            def compile_views
+              FileUtils.mkdir_p(@dist_dir)
 
-    def create_build_files
-      create_rakefile
-      create_site_builder
-    end
+              if @views_dir.exist?
+                view = build_action_view
+                layout_virtual = 'layouts/application'
 
-    def webrick_server_code
-      <<~'RUBY'
-        require "webrick"
-        require "fileutils"
-        require "static_site_builder/websocket_server"
-        require "json"
-
-        port = ENV["PORT"] || 3000
-        ws_port = ENV["WS_PORT"] || 3001
-        dist_dir = Pathname.new(Dir.pwd).join("dist")
-        reload_file = Pathname.new(Dir.pwd).join(".reload")
-
-        # Start WebSocket server for live reload (before first build)
-        ws_server = StaticSiteBuilder::WebSocketServer.new(port: ws_port, reload_file: reload_file)
-        ws_server.start
-
-        # Build once before starting (with live reload enabled)
-        ENV["LIVE_RELOAD"] = "true"
-        ENV["WS_PORT"] = ws_port.to_s
-        Rake::Task["build:all"].invoke
-
-        # Check if we need to run Tailwind CSS watch (after initial build)
-        tailwind_pid = nil
-        package_json_path = Pathname.new(Dir.pwd).join("package.json")
-        if package_json_path.exist?
-          package_json = JSON.parse(File.read(package_json_path))
-          if package_json.dig("scripts", "watch:css")
-            puts "🎨 Starting Tailwind CSS watch mode..."
-            tailwind_pid = spawn("npm", "run", "watch:css", :err => File::NULL, :out => File::NULL)
-            # Touch the source file to trigger Tailwind watch to process CSS immediately
-            css_source = Pathname.new(Dir.pwd).join("app", "assets", "stylesheets", "application.css")
-            if css_source.exist?
-              FileUtils.touch(css_source)
-            end
-            # Give Tailwind a moment to process CSS
-            sleep 1.5
-          end
-        end
+                Dir.glob(@views_dir.join('**', '*.html.erb')).each do |erb_file|
+                  relative = Pathname.new(erb_file).relative_path_from(@views_dir).to_s
+                  file_name = Pathname.new(erb_file).basename.to_s
 
-        puts "\n🚀 Starting development server at http://localhost:#{port}"
-        puts "📡 WebSocket server at ws://localhost:#{ws_port}"
-        puts "📝 Watching for changes... (Ctrl+C to stop)"
-        puts "🔄 Live reload enabled - pages will auto-refresh on changes\n"
-
-        # Simple file watcher - rebuild HTML when non-CSS files change
-        # CSS changes are handled by Tailwind watch, so we skip rebuild for CSS files
-        # When HTML rebuilds, it cleans dist, so we need to rebuild CSS immediately after
-        watcher_code = %q{watched = ['app', 'config']; exts = ['.erb', '.rb', '.js']; mtimes = {}; loop do; changed = false; watched.each do |dir|; Dir.glob(File.join(dir, '**', '*')).each do |f|; next unless File.file?(f) && exts.any? { |e| f.end_with?(e) }; next if f.end_with?('.css'); mtime = File.mtime(f); if mtimes[f] != mtime; mtimes[f] = mtime; changed = true; end; end; end; if changed; system('rake build:html > /dev/null 2>&1 && rake build:css > /dev/null 2>&1'); end; sleep 0.5; end}
-        watcher_pid = spawn("ruby", "-e", watcher_code, :err => File::NULL)
-
-        # Start web server
-        server = WEBrick::HTTPServer.new(
-          Port: port,
-          DocumentRoot: dist_dir.to_s,
-          BindAddress: "127.0.0.1"
-        )
-
-        trap("INT") do
-          puts "\n\nShutting down..."
-          Process.kill("TERM", watcher_pid) if watcher_pid
-          Process.kill("TERM", tailwind_pid) if tailwind_pid
-          ws_server.stop
-          server.shutdown
-        end
+                  is_partial = file_name.start_with?('_')
+                  is_layout = relative.start_with?('layouts/')
 
-        server.start
-      RUBY
-    end
+                  if is_partial == false && is_layout == false
+                    virtual_path = relative.gsub(/\.html\.erb$/, '')
+                    output_rel = relative.gsub(/\.html\.erb$/, '.html')
+                    output_path = @dist_dir.join(output_rel)
 
-    def rails_server_code
-      <<~'RUBY'
-        require "fileutils"
-        require "pathname"
+                    rendered = view.render(template: virtual_path, layout: layout_virtual)
 
-        # Load Rails environment
-        require_relative "config/environment"
+                    FileUtils.mkdir_p(output_path.dirname)
+                    File.write(output_path, rendered)
+                  end
+                end
+              end
+            end
 
-        port = ENV["PORT"] || 3000
+            def build_action_view
+              view_paths = ActionView::PathSet.new([@views_dir.to_s])
+              lookup_context = ActionView::LookupContext.new(view_paths)
+              view_class = ActionView::Base.with_empty_template_cache
 
-        # Build once before starting
-        ENV["LIVE_RELOAD"] = "true"
-        Rake::Task["build:all"].invoke
+              load_and_include_helpers(view_class)
 
-        puts "\n🚀 Starting Rails development server at http://localhost:#{port}"
-        puts "📝 EditRails available at http://localhost:#{port}/edit_rails"
-        puts "📝 Watching for changes... (Ctrl+C to stop)\n"
+              view = view_class.new(lookup_context, {}, nil)
+              view
+            end
 
-        # Start Rails server
-        exec "rails server -p #{port} -b 127.0.0.1"
-      RUBY
-    end
+            def load_and_include_helpers(view_class)
+              helpers_dir = @root.join('app', 'helpers')
+              if helpers_dir.exist? && helpers_dir.directory?
+                Dir.glob(helpers_dir.join('**', '*_helper.rb')).each do |helper_file|
+                  load helper_file
 
-    def create_rakefile
-      needs_npm = needs_npm?
-      has_edit_rails = @options[:edit_rails]
-      server_code = has_edit_rails ? rails_server_code : webrick_server_code
+                  relative = Pathname.new(helper_file).relative_path_from(helpers_dir).to_s
+                  module_name = helper_module_name(relative)
 
-      if needs_npm
-        content = <<~RUBY
-          # frozen_string_literal: true
+                  if Object.const_defined?(module_name)
+                    view_class.include(Object.const_get(module_name))
+                  end
+                end
+              end
+            end
 
-          require_relative "lib/site_builder"
-          require "fileutils"
-          require "pathname"
+            def helper_module_name(relative_path)
+              without_ext = relative_path.gsub(/\.rb$/, '')
+              parts = without_ext.split('/')
+              parts.map { |p| camelize(p) }.join('::')
+            end
 
-          namespace :build do
-            desc "Build everything (HTML + CSS)"
-            task :all => [:html, :css] do
-              puts "\\n✓ Build complete!"
+            def camelize(value)
+              value.split('_').map { |part| part[0] ? part[0].upcase + part[1..] : '' }.join
             end
 
-            desc "Build JavaScript assets"
-            task :assets do
-              if File.exist?("package.json")
-                package_json = JSON.parse(File.read("package.json"))
-                build_script = package_json.dig("scripts", "build")
-                # Only run if build script exists and doesn't include CSS (CSS handled separately)
-                if build_script && !build_script.include?("build:css")
-                  sh "npm run build"
+            def copy_javascript
+              package_json_path = @root.join('package.json')
+              should_copy = true
+
+              if package_json_path.exist?
+                begin
+                  package_json = JSON.parse(File.read(package_json_path))
+                  should_copy = package_json.dig('scripts', 'build').nil?
+                rescue JSON::ParserError
+                  should_copy = true
                 end
               end
-            end
 
-            desc "Compile all pages to static HTML"
-            task :html => [:assets] do
-              load "lib/site_builder.rb"
+              if should_copy
+                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_tree_skip_existing(js_dir, dist_js)
+                end
+              end
             end
 
-            desc "Build CSS (runs after HTML so dist directory exists)"
-            task :css do
-              if File.exist?("package.json")
-                package_json = JSON.parse(File.read("package.json"))
-                if package_json.dig("scripts", "build:css")
-                  sh "npm run build:css"
+            def copy_stylesheets
+              package_json_path = @root.join('package.json')
+              should_copy = true
+
+              if package_json_path.exist?
+                begin
+                  package_json = JSON.parse(File.read(package_json_path))
+                  should_copy = package_json.dig('scripts', 'build:css').nil?
+                rescue JSON::ParserError
+                  should_copy = true
+                end
+              end
+
+              if should_copy
+                css_dir = @root.join('app', 'assets', 'stylesheets')
+                if css_dir.exist? && css_dir.directory?
+                  dist_css = @dist_dir.join('assets', 'stylesheets')
+                  FileUtils.mkdir_p(dist_css)
+                  copy_tree_skip_existing(css_dir, dist_css)
                 end
-              elsif File.exist?("tailwind.config.js")
-                # Build CSS even if no package.json (standalone Tailwind)
-                if system("which tailwindcss > /dev/null 2>&1")
-                  FileUtils.mkdir_p("dist/assets/stylesheets")
-                  sh "tailwindcss -i ./app/assets/stylesheets/application.css -o ./dist/assets/stylesheets/application.css --minify"
+              end
+            end
+
+            def copy_public
+              public_dir = @root.join('public')
+              if public_dir.exist? && public_dir.directory?
+                Dir.glob(public_dir.join('**', '*')).each do |item|
+                  if File.file?(item)
+                    dest = @dist_dir.join(Pathname.new(item).relative_path_from(public_dir))
+                    FileUtils.mkdir_p(dest.dirname)
+                    FileUtils.cp(item, dest)
+                  end
                 end
               end
             end
 
-            desc "Clean dist directory"
-            task :clean do
-              dist_dir = Pathname.new(Dir.pwd).join("dist")
-              FileUtils.rm_rf(dist_dir) if dist_dir.exist?
-              puts "Cleaned \#{dist_dir}"
+            def write_reload_file
+              reload_file = @root.join('.reload')
+              File.write(reload_file, Time.now.to_f.to_s)
             end
 
-            desc "Build for production/release (cleans dist directory first)"
-            task :production do
-              ENV["PRODUCTION"] = "true"
-              Rake::Task["build:all"].invoke
+            def copy_tree_skip_existing(source_dir, dest_dir)
+              Dir.glob(source_dir.join('**', '*')).each do |item|
+                if File.file?(item)
+                  relative = Pathname.new(item).relative_path_from(source_dir)
+                  dest = dest_dir.join(relative)
+
+                  if dest.exist? == false
+                    FileUtils.mkdir_p(dest.dirname)
+                    FileUtils.cp(item, dest)
+                  end
+                end
+              end
             end
           end
 
-          namespace :dev do
-            desc "Start development server with auto-rebuild and live reload"
-            task :server do
-              #{server_code}
+          class WebSocketServer
+            ACCEPT_RETRY_INTERVAL = 0.1
+            WATCH_POLL_INTERVAL = 0.3
+            CLIENT_KEEPALIVE_INTERVAL = 1
+
+            def initialize(port: DEFAULT_WS_PORT, reload_file: nil)
+              @port = port
+              @reload_file = reload_file || Pathname.new(Dir.pwd).join('.reload')
+              @clients = []
+              @running = false
+              @server = nil
             end
-          end
 
-          task default: "build:all"
-        RUBY
-      else
-        content = <<~RUBY
-          # frozen_string_literal: true
+            def start
+              @running = true
+              @server = TCPServer.new('127.0.0.1', @port)
 
-          require_relative "lib/site_builder"
-          require "fileutils"
-          require "pathname"
+              if @reload_file.exist?
+                @last_mtime = @reload_file.mtime
+              else
+                File.write(@reload_file, Time.now.to_f.to_s)
+                @last_mtime = @reload_file.mtime
+              end
 
-          namespace :build do
-            desc "Build everything (HTML)"
-            task :all => [:html] do
-              puts "\\n✓ Build complete!"
-            end
+              @accept_thread = Thread.new do
+                while @running
+                  begin
+                    client = @server.accept
+                    Thread.new { handle_client(client) }
+                  rescue IOError, Errno::EBADF, Errno::ECONNABORTED
+                    sleep ACCEPT_RETRY_INTERVAL
+                    if @running == false
+                      break
+                    end
+                  end
+                end
+              end
 
-            desc "Compile all pages to static HTML"
-            task :html do
-              load "lib/site_builder.rb"
+              @watch_thread = Thread.new do
+                while @running
+                  begin
+                    sleep WATCH_POLL_INTERVAL
+                    if @reload_file.exist? && @reload_file.mtime > @last_mtime
+                      @last_mtime = @reload_file.mtime
+                      broadcast('reload')
+                    end
+                  rescue Errno::ENOENT, Errno::EACCES, SystemCallError
+                    sleep WATCH_POLL_INTERVAL
+                    if @running == false
+                      break
+                    end
+                  end
+                end
+              end
             end
 
-            desc "Clean dist directory"
-            task :clean do
-              dist_dir = Pathname.new(Dir.pwd).join("dist")
-              FileUtils.rm_rf(dist_dir) if dist_dir.exist?
-              puts "Cleaned \#{dist_dir}"
-            end
+            def stop
+              @running = false
 
-            desc "Build for production/release (cleans dist directory first)"
-            task :production do
-              ENV["PRODUCTION"] = "true"
-              Rake::Task["build:all"].invoke
-            end
-          end
+              @clients.each do |client|
+                safe_close(client)
+              end
 
-          namespace :dev do
-            desc "Start development server with auto-rebuild and live reload"
-            task :server do
-              #{server_code}
+              if @server
+                safe_close(@server)
+              end
+
+              safe_kill_thread(@accept_thread)
+              safe_kill_thread(@watch_thread)
             end
-          end
 
-          task default: "build:all"
-        RUBY
-      end
+            private
 
-      write_file("Rakefile", content)
-    end
+            def safe_close(io)
+              if io && io.closed? == false
+                begin
+                  io.close
+                rescue IOError, Errno::EPIPE, Errno::ECONNRESET, Errno::EBADF
+                end
+              end
+            end
 
-    def create_site_builder
-      # Generated sites use the static-site-builder gem
-      # This file just configures it for the chosen stack
-      phlex_require = @options[:template_engine] == "phlex" ? 'require "phlex-rails"' : ""
-      importmap_require = @options[:js_bundler] == "importmap" ? 'require "importmap-rails"' : ""
-      importmap_config_line = @options[:js_bundler] == "importmap" ? importmap_config : ""
+            def safe_kill_thread(thread)
+              if thread && thread.alive?
+                begin
+                  thread.kill
+                rescue ThreadError
+                end
+              end
+            end
 
-      content = <<~RUBY
-        # frozen_string_literal: true
+            def handle_client(client)
+              begin
+                _request = client.gets
+                headers = {}
+                line = nil
+
+                while (line = client.gets)
+                  stripped = line.chomp
+                  if stripped == ''
+                    break
+                  end
+
+                  key, value = stripped.split(': ', 2)
+                  if key && value
+                    headers[key] = value
+                  end
+                end
 
-        require "static_site_builder"
-        #{phlex_require}
-        #{importmap_require}
+                if headers['Upgrade']&.downcase == 'websocket'
+                  key = headers['Sec-WebSocket-Key']
+                  accept = Base64.strict_encode64(Digest::SHA1.digest(key + '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'))
+
+                  client.print "HTTP/1.1 101 Switching Protocols\r\n"
+                  client.print "Upgrade: websocket\r\n"
+                  client.print "Connection: Upgrade\r\n"
+                  client.print "Sec-WebSocket-Accept: \#{accept}\r\n\r\n"
+
+                  @clients << client
+
+                  loop do
+                    sleep CLIENT_KEEPALIVE_INTERVAL
+                    if @running == false || client.closed?
+                      break
+                    end
+                  end
+                else
+                  safe_close(client)
+                end
+              rescue IOError, Errno::EPIPE, Errno::ECONNRESET, Errno::ECONNABORTED
+                @clients.delete(client)
+                safe_close(client)
+              end
+            end
 
-        # Configure the builder for your stack
-        builder = StaticSiteBuilder::Builder.new(
-          root: Dir.pwd,
-          template_engine: "#{@options[:template_engine]}",
-          js_bundler: "#{@options[:js_bundler]}",
-          #{importmap_config_line}
-        )
+            def broadcast(message)
+              frame = create_frame(message)
+              @clients.dup.each do |client|
+                begin
+                  if client.closed? == false
+                    client.write(frame)
+                  end
+                rescue IOError, Errno::EPIPE, Errno::ECONNRESET, Errno::ECONNABORTED
+                  @clients.delete(client)
+                end
+              end
+            end
 
-        # Build the site
-        builder.build
-      RUBY
+            def create_frame(message)
+              data = message.dup.force_encoding('BINARY')
+              length = data.bytesize
 
-      write_file("lib/site_builder.rb", content)
-    end
+              if length < 126
+                [0x81, length].pack('C*') + data
+              elsif length < 65_536
+                [0x81, 126, length].pack('CCn') + data
+              else
+                [0x81, 127, length >> 32, length & 0xFFFFFFFF].pack('CCNN') + data
+              end
+            end
+          end
+        end
 
-    def importmap_config
-      <<~RUBY
-        importmap_config: "config/importmap.rb",
+        # This file provides the build and live reload code for the generated project.
       RUBY
+
+      write_file('lib/site_builder.rb', content)
     end
 
     def create_example_pages
-      if @options[:template_engine] == "phlex"
-        create_phlex_example
-      else
-        create_erb_example
-      end
+      create_erb_example
     end
 
     def create_erb_example
       content = <<~ERB
-        ---
-        title: Home Page
-        js: application
-        ---
+        <% content_for(:javascript) do %>
+          <script src="/assets/javascripts/application.js"></script>
+        <% end %>
 
         <h1>Welcome</h1>
         <p>This is your generated static site.</p>
       ERB
 
-      write_file("app/views/pages/index.html.erb", content)
+      write_file('app/views/index.html.erb', content)
     end
 
-    def create_phlex_example
-      content = <<~RUBY
-        # frozen_string_literal: true
-
-        class IndexPage < Phlex::HTML
-          def template
-            h1 { "Welcome" }
-            p { "This is your generated static site." }
-          end
-        end
-      RUBY
-
-      write_file("app/views/pages/index.rb", content)
-    end
 
     def create_readme
       content = <<~MD
         # #{@app_name}
 
-        Generated static site using:
-        - Template: #{@options[:template_engine]}
-        - JS Bundler: #{@options[:js_bundler]}
-        - CSS: #{@options[:css_framework]}
-        - JS Framework: #{@options[:js_framework]}
+        Generated static site using ERB templates.
 
         ## Setup
 
         ```bash
         bundle install
-        #{'npm install' if needs_npm?}
         ```
 
         ## Development
@@ -943,69 +856,32 @@ module StaticSiteBuilder
 
         ## Build
 
-        Build for production:
+        Build for deployment:
 
         ```bash
-        rake build:all     # Build everything (assets + HTML)
-        rake build:html    # Build HTML only
+        rake build:all     # Clean dist and build everything (assets + HTML + CSS + sitemap)
+        rake build:html    # Build HTML only (still runs build:assets)
+        rake build:css     # Build CSS only
+        rake build:sitemap # Build sitemap only
         ```
 
         Output goes to `dist/` directory.
-      MD
 
-      write_file("README.md", content)
-    end
-
-    def build_script
-      js_build = case @options[:js_bundler]
-      when "esbuild"
-        "node esbuild.config.js"
-      when "webpack"
-        "webpack --mode production"
-      when "vite"
-        "vite build"
-      else
-        nil
-      end
+        ## JavaScript Bundling
 
-      css_build = if needs_css_build?
-        "npm run build:css"
-      else
-        nil
-      end
+        If you add a `package.json` with a `scripts.build`, `rake build:assets` will run `npm run build`.
+        If you do not use a bundler, it will copy files from `app/javascript/` into `dist/assets/javascripts/`.
 
-      builds = [js_build, css_build].compact
-      if builds.empty?
-        "echo 'No bundling needed'"
-      else
-        builds.join(" && ")
-      end
-    end
+        ## CSS
 
-    def css_build_script
-      if @options[:css_framework] == "tailwindcss" || @options[:css_framework] == "shadcn"
-        "tailwindcss -i ./app/assets/stylesheets/application.css -o ./dist/assets/stylesheets/application.css --minify"
-      end
-    end
+        If you add a `package.json` with a `scripts.build:css`, `rake build:css` will run `npm run build:css`.
+        If you do not use a CSS build step, it will copy files from `app/assets/stylesheets/` into `dist/assets/stylesheets/`.
+      MD
 
-    def css_watch_script
-      if @options[:css_framework] == "tailwindcss" || @options[:css_framework] == "shadcn"
-        "tailwindcss -i ./app/assets/stylesheets/application.css -o ./dist/assets/stylesheets/application.css --watch"
-      end
+      write_file('README.md', content)
     end
 
-    def needs_npm?
-      @options[:js_bundler] != "none" ||
-        @options[:css_framework] == "tailwindcss" ||
-        @options[:css_framework] == "shadcn" ||
-        @options[:js_framework] == "react" ||
-        @options[:js_framework] == "vue" ||
-        @options[:js_framework] == "alpine"
-    end
 
-    def needs_css_build?
-      @options[:css_framework] == "tailwindcss" || @options[:css_framework] == "shadcn"
-    end
 
     def create_gitignore
       content = <<~GITIGNORE