regolith 0.1.5 → 0.1.7

data/lib/regolith/cli.rb

@@ -1,10 +1,60 @@
 require 'fileutils'
 require 'yaml'
+require 'psych'
 require 'erb'
 require 'timeout'
 require 'rubygems'
+require 'net/http'
+require 'uri'
+require 'json'
+require 'ostruct'
+require 'set'
+require 'rbconfig'
+require 'shellwords'
 
 module Regolith
+  VERSION = "1.0.7"
+
+  class << self
+    def configuration
+      @configuration ||= OpenStruct.new(
+        timeout: 10,
+        default_port: 3001
+      )
+    end
+
+    def service_registry
+      @service_registry ||= begin
+        path = find_regolith_config
+        if path && File.exist?(path)
+          config = YAML.load_file(path) || {}
+          config['services'] || {}
+        else
+          {}
+        end
+      end
+    end
+
+    def reload_service_registry!
+      @service_registry = nil
+    end
+
+    private
+
+    def find_regolith_config
+      current_dir = Dir.pwd
+      loop do
+        config_path = File.join(current_dir, 'config', 'regolith.yml')
+        return config_path if File.exist?(config_path)
+        
+        parent = File.dirname(current_dir)
+        break if parent == current_dir
+        current_dir = parent
+      end
+      nil
+    end
+  end
+
   class CLI
     def initialize(args)
       @args = args
@@ -19,11 +69,47 @@ module Regolith
         create_new_app(@subcommand)
       when 'generate'
         generate_resource(@subcommand, @name)
-      when 'server'
-        start_server
+      when 'server', 'up'
+        start_server(parse_flags(@args[1..-1]))
+      when 'down'
+        stop_services
+      when 'restart'
+        restart_service(@subcommand)
+      when 'stop'
+        stop_service(@subcommand)
+      when 'ps', 'status'
+        show_status
+      when 'logs'
+        show_logs(@subcommand, parse_flags(@args[2..-1]))
+      when 'exec'
+        exec_command(@subcommand, @args[2..-1])
+      when 'shell'
+        shell_service(@subcommand)
       when 'console'
         open_console(@subcommand)
-      when 'version'
+      when 'rails'
+        rails_passthrough(@subcommand, @args[2..-1])
+      when 'routes'
+        show_routes(@subcommand)
+      when 'open'
+        open_service(@subcommand)
+      when 'db'
+        db_command(@subcommand, @name, parse_flags(@args[3..-1]))
+      when 'test'
+        run_tests(@subcommand, parse_flags(@args[2..-1]))
+      when 'health'
+        health_check
+      when 'config'
+        show_config(parse_flags(@args[1..-1]))
+      when 'prune'
+        prune_system
+      when 'rebuild'
+        rebuild_service(@subcommand)
+      when 'doctor'
+        run_doctor
+      when 'inspect'
+        inspect_services(parse_flags(@args[1..-1]))
+      when 'version', '--version', '-v'
         puts "Regolith #{Regolith::VERSION}"
       else
         show_help
@@ -32,6 +118,23 @@ module Regolith
 
     private
 
+    def parse_flags(args)
+      flags = {}
+      return flags unless args
+
+      args.each do |arg|
+        if arg.start_with?('--')
+          key, value = arg[2..-1].split('=', 2)
+          flags[key.to_sym] = value || true
+        elsif arg == '-f'
+          flags[:follow] = true
+        elsif arg == '--all'
+          flags[:all] = true
+        end
+      end
+      flags
+    end
+
     def create_new_app(app_name)
       unless app_name
         puts "❌ Error: App name required"
@@ -69,6 +172,8 @@ module Regolith
       File.write('docker-compose.yml', generate_docker_compose(app_name))
       File.write('Makefile', generate_makefile)
       File.write('.bin/regolith', generate_regolith_shim)
+      File.write('.gitignore', generate_gitignore)
+      File.write('README.md', generate_readme(app_name))
       FileUtils.chmod(0755, '.bin/regolith')
     end
 
@@ -83,9 +188,16 @@ module Regolith
     end
 
     def generate_service(service_name)
+      # Validate service name
+      unless service_name =~ /\A[a-z][a-z0-9_]*\z/
+        puts "❌ Invalid service name. Use lowercase, digits, and underscores only."
+        puts "Examples: users, user_profiles, api_gateway"
+        exit 1
+      end
+
       puts "🔧 Creating service '#{service_name}'..."
       config = load_regolith_config
-      port = 3001 + (config['services']&.size || 0)
+      port = next_available_port
       service_dir = "services/#{service_name}_service"
 
       puts "  → Generating Rails API app..."
@@ -116,17 +228,60 @@ module Regolith
         exit 1
       end
 
-      puts "🔧 Overwriting Gemfile to remove sqlite3 and other defaults..."
-      ruby_version = `ruby -e 'print RUBY_VERSION'`.strip
-      ruby_major_minor = ruby_version.split('.')[0..1].join('.')
+      customize_service(service_dir, service_name, port)
+      
+      config['services'][service_name] = {
+        'port' => port,
+        'root' => "./#{service_dir}"
+      }
+      
+      save_regolith_config(config)
+      update_docker_compose(config)
+
+      puts "✅ Created service '#{service_name}'"
+      puts "🚀 Service will run on port #{port}"
+      puts "→ Next: regolith generate service <another_service> or regolith server"
+    end
+
+    def next_available_port(start = Regolith.configuration.default_port)
+      used = load_regolith_config['services'].values.map { |s| s['port'] }.to_set
+      port = start
+      port += 1 while used.include?(port)
+      port
+    end
 
-      custom_gemfile = <<~GEMFILE
+    def customize_service(service_dir, service_name, port)
+      # Fix Ruby version detection
+      major_minor = RUBY_VERSION.split(".")[0..1].join(".")
+
+      custom_gemfile = generate_gemfile(major_minor)
+      File.write("#{service_dir}/Gemfile", custom_gemfile)
+
+      vendor_regolith_gem(service_dir)
+
+      puts "  → Running bundle install..."
+      Dir.chdir(service_dir) do
+        unless system("bundle install")
+          puts "❌ bundle install failed"
+          puts "→ You may be missing system libraries like libyaml-dev build-essential"
+          exit 1
+        end
+      end
+
+      patch_rails_app(service_dir, service_name, port)
+    end
+
+    def generate_gemfile(ruby_version)
+      <<~GEMFILE
         source "https://rubygems.org"
-        ruby "~> #{ruby_major_minor}.0"
+
+        ruby "~> #{ruby_version}.0"
+
         gem "rails", "~> 7.2.2.1"
         gem "pg", "~> 1.5"
         gem "puma", ">= 5.0"
         gem "rack-cors"
+        gem "bootsnap", require: false
 
         group :development, :test do
           gem "debug", platforms: %i[ mri mswin mswin64 mingw x64_mingw ], require: "debug/prelude"
@@ -136,131 +291,491 @@ module Regolith
 
         gem "regolith", path: "vendor/regolith"
       GEMFILE
+    end
 
-      File.write("#{service_dir}/Gemfile", custom_gemfile)
-
+    def vendor_regolith_gem(service_dir)
       vendor_dir = File.join(service_dir, "vendor")
-      regolith_vendor_dir = File.join(vendor_dir, "regolith")
       FileUtils.mkdir_p(vendor_dir)
-      source_dir = File.expand_path("../..", __dir__)
-      FileUtils.cp_r(source_dir, regolith_vendor_dir)
-      Dir.glob(File.join(regolith_vendor_dir, "regolith-*")).each { |nested_dir| FileUtils.rm_rf(nested_dir) }
+      
+      regolith_source = File.expand_path("../..", __dir__)
+      regolith_dest = File.join(vendor_dir, "regolith")
+      
+      FileUtils.cp_r(regolith_source, regolith_dest)
+      puts "📦 Vendored Regolith gem into #{regolith_dest}"
+    end
 
-      gemspec_path = File.join(regolith_vendor_dir, "regolith.gemspec")
-      File.write(gemspec_path, generate_regolith_gemspec) unless File.exist?(gemspec_path)
+    def patch_rails_app(service_dir, service_name, port)
+      create_initializers(service_dir, service_name)
+      create_health_controller(service_dir)
+      add_health_route(service_dir)
+      File.write("#{service_dir}/Dockerfile", generate_dockerfile)
+      patch_application_rb(service_dir, service_name, port)
+    end
 
-      puts "📦 Vendored Regolith gem into #{regolith_vendor_dir}"
+    def create_initializers(service_dir, service_name)
+      initializer_dir = "#{service_dir}/config/initializers"
+      FileUtils.mkdir_p(initializer_dir)
+      
+      File.write("#{initializer_dir}/regolith.rb", generate_regolith_initializer(service_name))
+      File.write("#{initializer_dir}/cors.rb", generate_cors_initializer)
+    end
 
-      puts "  → Running bundle install..."
-      Dir.chdir(service_dir) do
-        unless system("bundle install")
-          puts "❌ bundle install failed"
-          puts "→ You may be missing system libraries like libyaml-dev libsqlite3-dev build-essential pkg-config"
-          puts "→ Try: sudo apt install -y libyaml-dev libsqlite3-dev build-essential pkg-config"
-          exit 1
-        end
+    def create_health_controller(service_dir)
+      controller_dir = "#{service_dir}/app/controllers/regolith"
+      FileUtils.mkdir_p(controller_dir)
+      
+      File.write("#{controller_dir}/health_controller.rb", generate_health_controller)
+    end
+
+    def add_health_route(service_dir)
+      routes_path = File.join(service_dir, "config/routes.rb")
+      content = File.read(routes_path)
+      
+      # Try to inject before the final end, or append if no clear structure
+      if content.sub!(/end\s*\z/, "  get '/health', to: 'regolith/health#show'\nend\n")
+        File.write(routes_path, content)
+      else
+        # Fallback: append inside the draw block
+        File.open(routes_path, "a") { |f| f.puts "get '/health', to: 'regolith/health#show'" }
       end
+    end
 
-      patch_rails_app(service_dir, service_name, port)
+    def patch_application_rb(service_dir, service_name, port)
+      app_rb_path = "#{service_dir}/config/application.rb"
+      app_rb_content = File.read(app_rb_path)
 
-      config['services'][service_name] = {
-        'port' => port,
-        'root' => "./#{service_dir}"
-      }
-      save_regolith_config(config)
-      update_docker_compose(config)
+      cors_config = <<~RUBY
 
-      puts "✅ Created service '#{service_name}'"
-      puts "🚀 Service running on port #{port}"
-      puts "→ Next: regolith generate service <another_service> or regolith server"
+        # Regolith configuration
+        config.regolith_service_name = '#{service_name}'
+        config.regolith_service_port = #{port}
+      RUBY
+
+      app_rb_content.gsub!(/(\n  end\n\z)/, "#{cors_config}\1")
+      File.write(app_rb_path, app_rb_content)
     end
 
-    def patch_rails_app(service_dir, service_name, port)
-  initializer_dir = "#{service_dir}/config/initializers"
-  FileUtils.mkdir_p(initializer_dir)
-  File.write("#{initializer_dir}/regolith.rb", generate_regolith_initializer(service_name))
-  File.write("#{service_dir}/Dockerfile", generate_dockerfile)
+    # Service management commands
+    def start_server(flags = {})
+      unless File.exist?('docker-compose.yml')
+        puts "❌ Error: Not in a Regolith app directory"
+        exit 1
+      end
 
-  app_rb_path = "#{service_dir}/config/application.rb"
-  app_rb_content = File.read(app_rb_path)
+      puts "🚀 Starting Regolith services..."
+      
+      config = load_regolith_config
+      show_service_info(config)
+
+      exec_compose('up', '--build')
+    end
 
-  # Ensure Regolith config block is inserted safely
-  insert_block = <<~RUBY
+    def stop_services
+      puts "🛑 Stopping all services..."
+      exec_compose('down', '-v')
+    end
 
-    # Regolith configuration
-    config.middleware.insert_before 0, Rack::Cors do
-      allow do
-        origins '*'
-        resource '*', headers: :any, methods: [:get, :post, :put, :patch, :delete, :options, :head]
+    def restart_service(service_name = nil)
+      if service_name
+        ensure_service_exists!(service_name)
+        puts "🔄 Restarting service '#{service_name}'..."
+        exec_compose('restart', service_name)
+      else
+        puts "🔄 Restarting all services..."
+        exec_compose('restart')
       end
     end
 
-    config.regolith_service_name = '#{service_name}'
-    config.regolith_service_port = #{port}
-  RUBY
+    def stop_service(service_name = nil)
+      if service_name
+        ensure_service_exists!(service_name)
+        puts "⏹  Stopping service '#{service_name}'..."
+        exec_compose('stop', service_name)
+      else
+        puts "⏹  Stopping all services..."
+        exec_compose('stop')
+      end
+    end
 
-  app_rb_lines = app_rb_content.lines
-  target_index = app_rb_lines.index { |line| line =~ /^\s*class Application < Rails::Application/ }
+    def show_status
+      puts "📊 Service Status:"
+      puts
+      
+      # Try different format options for maximum compatibility
+      success = system_compose('ps', '--format', 'table') ||
+                system_compose('ps', '--format', 'json') ||
+                system_compose('ps')
+      
+      # Show summary counts and health check for exit code
+      if success
+        config = load_regolith_config
+        service_count = config['services'].size
+        ports = config['services'].values.map { |s| s['port'] }.sort
+        
+        puts
+        puts "📋 Summary: #{service_count} services configured"
+        puts "🚪 Ports: #{ports.join(', ')}" if ports.any?
+        
+        # Check health for proper exit code
+        healthy_services = 0
+        config['services'].each do |name, service_config|
+          port = service_config['port']
+          status = check_service_health(port)
+          healthy_services += 1 if status[:healthy]
+        end
+        
+        if healthy_services < service_count
+          puts "⚠️  #{service_count - healthy_services} services unhealthy"
+          exit 1
+        end
+      end
+    end
 
-  if target_index
-    insertion_point = app_rb_lines.index { |line| line.strip == 'end' && app_rb_lines.index(line) > target_index }
-    if insertion_point
-      app_rb_lines.insert(insertion_point, insert_block)
-      File.write(app_rb_path, app_rb_lines.join)
+    def show_logs(service_name = nil, flags = {})
+      args = ['logs']
+      args << '--follow' if flags[:follow] || flags[:f]
+      args << service_name if service_name
+      
+      exec_compose(*args)
     end
-  end
 
-  # Clean up boot.rb again just in case
-  boot_path = "#{service_dir}/config/boot.rb"
-  if File.exist?(boot_path)
-    clean_boot_rb = <<~RUBY
-      ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
-      require "bundler/setup" # Set up gems listed in the Gemfile.
-    RUBY
-    File.write(boot_path, clean_boot_rb)
-  end
-end
+    def exec_command(service_name, command_args)
+      ensure_service_exists!(service_name)
+      
+      if command_args.empty?
+        command_args = ['bash']
+      end
+      
+      exec_compose('exec', service_name, *command_args)
+    end
 
+    def shell_service(service_name)
+      unless service_name
+        puts "❌ Error: Service name required"
+        puts "Usage: regolith shell <service_name>"
+        exit 1
+      end
 
-    def start_server
-      unless File.exist?('docker-compose.yml')
-        puts "❌ Error: Not in a Regolith app directory"
+      ensure_service_exists!(service_name)
+      puts "🐚 Opening shell for #{service_name}_service..."
+      exec_compose('exec', service_name, 'bash')
+    end
+
+    # Rails integration commands
+    def rails_passthrough(service_name, rails_args)
+      ensure_service_exists!(service_name)
+      
+      if rails_args.empty?
+        puts "❌ Error: Rails command required"
+        puts "Usage: regolith rails <service> <command>"
         exit 1
       end
+      
+      exec_compose('exec', service_name, 'bash', '-lc', 
+                  "bundle exec rails #{Shellwords.join(rails_args)}")
+    end
 
-      puts "🚀 Starting Regolith services..."
-      config = load_regolith_config
+    def open_console(service_name)
+      unless service_name
+        puts "❌ Error: Service name required"
+        puts "Usage: regolith console <service_name>"
+        exit 1
+      end
 
-      config['services'].each do |name, service|
-        puts "🚀 #{name}_service running at http://localhost:#{service['port']}"
+      ensure_service_exists!(service_name)
+      puts "🧪 Opening Rails console for #{service_name}_service..."
+      exec_compose('exec', service_name, 'rails', 'console')
+    end
+
+    def open_service(service_name)
+      unless service_name
+        puts "❌ Error: Service name required"
+        puts "Usage: regolith open <service_name>"
+        exit 1
+      end
+
+      ensure_service_exists!(service_name)
+      config = load_regolith_config
+      port = config['services'][service_name]['port']
+      url = "http://localhost:#{port}"
+      
+      puts "🌐 Opening #{url}..."
+      
+      # Cross-platform open command
+      case RbConfig::CONFIG['host_os']
+      when /mswin|mingw|cygwin/
+        system(%{start "" "#{url}"})
+      when /darwin/
+        system("open #{url}")
+      else
+        system("xdg-open #{url}") || puts("Visit: #{url}")
       end
+    end
 
-      puts "🏭 Service registry loaded from config/regolith.yml"
-      puts ""
+    # Database commands
+    def db_command(action, target, flags = {})
+      case action
+      when 'create', 'migrate', 'seed', 'reset', 'setup', 'drop'
+        each_target_service(target, flags) do |service|
+          puts "🗄  Running db:#{action} for #{service}..."
+          success = system_compose('exec', service, 'bash', '-lc', "bundle exec rails db:#{action}")
+          
+          unless success
+            puts "❌ db:#{action} failed for #{service} (exit code: #{$?.exitstatus})"
+            exit 1 unless flags[:continue_on_failure]
+          end
+        end
+      else
+        puts "❌ Unknown db action: #{action}"
+        puts "Available: create, migrate, seed, reset, setup, drop"
+        exit 1
+      end
+    end
 
-      exec("docker-compose up --build")
+    # Testing commands
+    def run_tests(target = nil, flags = {})
+      each_target_service(target, flags) do |service|
+        puts "🧪 Running tests for #{service}..."
+        success = system_compose('exec', service, 'bash', '-lc', 'bundle exec rails test')
+        
+        unless success
+          puts "❌ Tests failed for #{service} (exit code: #{$?.exitstatus})"
+          exit 1 unless flags[:continue_on_failure]
+        end
+      end
+      
+      puts "✅ All tests passed!" if flags[:all]
     end
 
-    def open_console(service_name)
+    def show_routes(service_name)
       unless service_name
         puts "❌ Error: Service name required"
-        puts "Usage: regolith console <service_name>"
+        puts "Usage: regolith routes <service_name>"
         exit 1
       end
 
+      ensure_service_exists!(service_name)
+      puts "🛤  Routes for #{service_name}:"
+      system_compose('exec', service_name, 'bash', '-lc', 'bundle exec rails routes')
+    end
+
+    # Health and monitoring
+    def health_check
+      puts "🔍 Health Check Results:"
+      puts
+      
+      config = load_regolith_config
+      
+      config['services'].each do |name, service_config|
+        port = service_config['port']
+        status = check_service_health(port)
+        
+        status_icon = status[:healthy] ? '✅' : '❌'
+        puts "#{status_icon} #{name} (port #{port}) - #{status[:message]}"
+        
+        # Show additional health data if available
+        if status[:data] && status[:data]['version']
+          puts "   Version: #{status[:data]['version']}"
+        end
+        if status[:data] && status[:data]['time']
+          puts "   Last seen: #{Time.at(status[:data]['time']).strftime('%H:%M:%S')}"
+        end
+      end
+    end
+
+    def check_service_health(port)
+      begin
+        uri = URI("http://localhost:#{port}/health")
+        response = Net::HTTP.get_response(uri)
+        
+        if response.code.to_i == 200
+          # Try to parse structured health data
+          health_data = JSON.parse(response.body) rescue {}
+          { 
+            healthy: true, 
+            message: 'healthy',
+            data: health_data
+          }
+        else
+          { healthy: false, message: "HTTP #{response.code}" }
+        end
+      rescue => e
+        { healthy: false, message: 'unreachable' }
+      end
+    end
+
+    # Configuration
+    def show_config(flags = {})
       config = load_regolith_config
-      unless config['services'][service_name]
-        puts "❌ Error: Service '#{service_name}' not found"
+      
+      if flags[:json]
+        puts JSON.pretty_generate(config)
+      else
+        puts "📋 Current Configuration:"
+        puts
+        puts YAML.dump(config)
+      end
+    end
+
+    # Maintenance commands
+    def prune_system
+      puts "🧹 Pruning Docker system..."
+      exec_compose('down', '-v')
+      system('docker', 'system', 'prune', '-f')
+      puts "✅ System pruned"
+    end
+
+    def rebuild_service(service_name = nil)
+      if service_name
+        ensure_service_exists!(service_name)
+        puts "🔨 Rebuilding service '#{service_name}'..."
+        exec_compose('build', '--no-cache', service_name)
+      else
+        puts "🔨 Rebuilding all services..."
+        exec_compose('build', '--no-cache')
+      end
+    end
+
+    # System diagnostics
+    def run_doctor
+      puts "🩺 Regolith System Doctor"
+      puts "=" * 40
+      
+      checks = [
+        { name: "Docker", check: -> { system('docker --version > /dev/null 2>&1') } },
+        { name: "Docker Compose", check: -> { docker_compose_available? } },
+        { name: "Ruby", check: -> { system('ruby --version > /dev/null 2>&1') } },
+        { name: "Rails", check: -> { system('rails --version > /dev/null 2>&1') } },
+        { name: "PostgreSQL Client", check: -> { system('psql --version > /dev/null 2>&1') } }
+      ]
+      
+      checks.each do |check|
+        status = check[:check].call ? "✅" : "❌"
+        puts "#{status} #{check[:name]}"
+      end
+      
+      puts
+      check_regolith_config
+    end
+
+    def check_regolith_config
+      puts "📋 Checking Regolith configuration..."
+      
+      if File.exist?('config/regolith.yml')
+        config = load_regolith_config
+        
+        if config['services'].empty?
+          puts "⚠️  No services configured"
+        else
+          puts "✅ Configuration valid (#{config['services'].size} services)"
+        end
+      else
+        puts "❌ No regolith.yml found - not in a Regolith project?"
+      end
+    end
+
+    def inspect_services(flags = {})
+      puts "🔍 Regolith Services Inspection"
+      puts "=" * 40
+      
+      config = load_regolith_config
+      
+      if config['services'].empty?
+        puts "No services configured yet."
+        return
+      end
+      
+      if flags[:json]
+        # JSON output for automation
+        inspection_data = {
+          services: config['services'].map do |name, service_config|
+            {
+              name: name,
+              port: service_config['port'],
+              endpoint: "http://localhost:#{service_config['port']}",
+              root: service_config['root']
+            }
+          end,
+          config: config
+        }
+        puts JSON.pretty_generate(inspection_data)
+      else
+        # Human-readable output
+        puts "\n📊 Service Endpoints:"
+        config['services'].each do |name, service_config|
+          port = service_config['port']
+          puts "  #{name}: http://localhost:#{port}"
+        end
+        
+        puts "\n📋 Full Configuration:"
+        puts YAML.dump(config)
+      end
+    end
+
+    # Helper methods
+    def docker_compose_available?
+      system('docker compose version > /dev/null 2>&1') ||
+        system('docker-compose version > /dev/null 2>&1')
+    end
+
+    def docker_compose_command
+      if system('docker compose version > /dev/null 2>&1')
+        %w[docker compose]
+      elsif system('docker-compose version > /dev/null 2>&1')
+        %w[docker-compose]
+      else
+        puts "❌ Docker Compose not found"
         exit 1
       end
+    end
 
-      puts "🧪 Opening Rails console for #{service_name}_service..."
-      exec("docker-compose exec #{service_name} rails console")
+    def exec_compose(*args)
+      cmd = docker_compose_command + args
+      exec(*cmd)
+    end
+
+    def system_compose(*args)
+      cmd = docker_compose_command + args
+      system(*cmd)
+    end
+
+    def each_target_service(target, flags = {})
+      services = if target == '--all' || target.nil? || flags[:all]
+                  load_regolith_config['services'].keys
+                else
+                  [target]
+                end
+      
+      services.each do |service|
+        ensure_service_exists!(service)
+        yield(service)
+      end
+    end
+
+    def ensure_service_exists!(service_name)
+      config = load_regolith_config
+      unless config['services'].key?(service_name)
+        puts "❌ Service '#{service_name}' not found"
+        puts "Available services: #{config['services'].keys.join(', ')}"
+        exit 1
+      end
+    end
+
+    def show_service_info(config)
+      config['services'].each do |name, service|
+        puts "🚀 #{name}_service: http://localhost:#{service['port']}"
+      end
+      
+      puts "🧭 Service registry: config/regolith.yml"
+      puts
     end
 
     def load_regolith_config
-      return { 'services' => {} } unless File.exist?('config/regolith.yml')
-      config = YAML.load_file('config/regolith.yml') || {}
+      config_path = Regolith.send(:find_regolith_config)
+      return { 'services' => {} } unless config_path && File.exist?(config_path)
+      
+      # Use safe YAML loading
+      config = Psych.safe_load(File.read(config_path), permitted_classes: [], aliases: false) || {}
       config['services'] ||= {}
       config
     end
@@ -268,6 +783,7 @@ end
     def save_regolith_config(config)
       FileUtils.mkdir_p('config')
       File.write('config/regolith.yml', YAML.dump(config))
+      Regolith.reload_service_registry!
     end
 
     def update_docker_compose(config)
@@ -275,56 +791,96 @@ end
       File.write('docker-compose.yml', docker_compose)
     end
 
+    # File generators
     def generate_docker_compose(app_name, services = {})
-      template = <<~YAML
-        version: '3.8'
-
-        services:
-          db:
-            image: postgres:14
-            environment:
-              POSTGRES_DB: #{app_name}_development
-              POSTGRES_USER: postgres
-              POSTGRES_PASSWORD: password
-            ports:
-              - "5432:5432"
-            volumes:
-              - postgres_data:/var/lib/postgresql/data
-
-        <% services.each do |name, service| %>
-          <%= name %>:
-            build: <%= service['root'] %>
-            ports:
-              - "<%= service['port'] %>:3000"
-            depends_on:
-              - db
-            environment:
-              DATABASE_URL: postgres://postgres:password@db:5432/<%= app_name %>_development
-              REGOLITH_SERVICE_NAME: <%= name %>
-              REGOLITH_SERVICE_PORT: <%= service['port'] %>
-            volumes:
-              - <%= service['root'] %>:/app
-            command: bash -c "rm -f tmp/pids/server.pid && bundle install && rails server -b 0.0.0.0"
-        <% end %>
-
-        volumes:
-          postgres_data:
-      YAML
-
-      ERB.new(template).result(binding)
+      compose_services = {
+        'db' => {
+          'image' => 'postgres:14',
+          'environment' => {
+            'POSTGRES_DB' => "#{app_name}_development",
+            'POSTGRES_USER' => 'postgres',
+            'POSTGRES_PASSWORD' => 'password'
+          },
+          'ports' => ['5432:5432'],
+          'volumes' => ['postgres_data:/var/lib/postgresql/data'],
+          'networks' => ['regolith'],
+          'healthcheck' => {
+            'test' => ['CMD-SHELL', 'pg_isready -U postgres'],
+            'interval' => '10s',
+            'timeout' => '5s',
+            'retries' => 5
+          }
+        }
+      }
+
+      services.each do |name, service|
+        compose_services[name] = {
+          'build' => {
+            'context' => service['root'],
+            'args' => {
+              'BUILD_ENV' => 'development'
+            }
+          },
+          'ports' => ["#{service['port']}:3000"],
+          'networks' => ['regolith'],
+          'depends_on' => {
+            'db' => {
+              'condition' => 'service_healthy'
+            }
+          },
+          'environment' => {
+            'DATABASE_URL' => "postgres://postgres:password@db:5432/#{app_name}_development",
+            'REGOLITH_SERVICE_NAME' => name,
+            'REGOLITH_SERVICE_PORT' => service['port']
+          },
+          'volumes' => ["#{service['root']}:/app"],
+          'command' => 'bash -c "rm -f tmp/pids/server.pid && bundle install && rails db:prepare && rails server -b 0.0.0.0"',
+          'healthcheck' => {
+            'test' => ['CMD-SHELL', 'curl -f http://localhost:3000/health || exit 1'],
+            'interval' => '30s',
+            'timeout' => '10s',
+            'retries' => 3,
+            'start_period' => '40s'
+          }
+        }
+      end
+
+      {
+        'version' => '3.8',
+        'networks' => {
+          'regolith' => {}
+        },
+        'services' => compose_services,
+        'volumes' => {
+          'postgres_data' => nil
+        }
+      }.to_yaml
     end
 
     def generate_dockerfile
       <<~DOCKERFILE
-        FROM ruby:3.1
+        FROM ruby:3.1-slim
+
+        # Install system dependencies
+        RUN apt-get update -qq && \\
+            apt-get install -y nodejs postgresql-client libyaml-dev build-essential pkg-config curl && \\
+            apt-get clean && \\
+            rm -rf /var/lib/apt/lists/*
 
         WORKDIR /app
 
-        RUN apt-get update -qq && apt-get install -y nodejs postgresql-client libyaml-dev libsqlite3-dev build-essential pkg-config
+        # Copy Gemfile and install gems
+        COPY Gemfile Gemfile.lock* ./
 
-        COPY . .
+        # Conditional bundler config for dev vs prod
+        ARG BUILD_ENV=development
+        RUN if [ "$BUILD_ENV" = "production" ]; then \\
+              bundle config set --local deployment 'true' && \\
+              bundle config set --local without 'development test'; \\
+            fi && bundle install
 
-        RUN bundle install
+        # Copy application code
+        COPY . .
 
         EXPOSE 3000
 
@@ -334,14 +890,18 @@ end
 
     def generate_regolith_initializer(service_name)
       <<~RUBY
+        require 'ostruct'
+        
         # Regolith service configuration
         Rails.application.configure do
           config.regolith = OpenStruct.new(
             service_name: '#{service_name}',
-            service_registry: Rails.root.join('../../config/regolith.yml')
+            service_registry: Rails.root.join('../../config/regolith.yml'),
+            version: Regolith::VERSION
           )
         end
 
+        # Load service registry if available
         if File.exist?(Rails.application.config.regolith.service_registry)
           REGOLITH_SERVICES = YAML.load_file(Rails.application.config.regolith.service_registry)['services'] || {}
         else
@@ -350,22 +910,184 @@ end
       RUBY
     end
 
+    def generate_cors_initializer
+      <<~RUBY
+        # CORS configuration for microservices
+        Rails.application.config.middleware.insert_before 0, Rack::Cors do
+          allow do
+            origins '*' # Configure appropriately for production
+            resource '*',
+              headers: :any,
+              methods: %i[get post put patch delete options head],
+              expose: %w[Authorization Content-Type],
+              max_age: 600
+          end
+        end
+      RUBY
+    end
+
+    def generate_health_controller
+      <<~RUBY
+        module Regolith
+          class HealthController < ActionController::API
+            def show
+              render json: { 
+                ok: true, 
+                service: Rails.application.config.regolith_service_name,
+                time: Time.now.to_i,
+                version: Rails.application.config.regolith.version
+              }
+            end
+          end
+        end
+      RUBY
+    end
+
+    def generate_gitignore
+      <<~GITIGNORE
+        # Regolith
+        /services/*/log/*
+        /services/*/tmp/*
+        /services/*/.env*
+        .DS_Store
+        
+        # Docker
+        docker-compose.override.yml
+        
+        # Logs
+        *.log
+        
+        # Runtime data
+        pids
+        *.pid
+        *.seed
+        
+        # Environment variables
+        .env*
+        !.env.example
+      GITIGNORE
+    end
+
+    def generate_readme(app_name)
+      <<~MARKDOWN
+        # #{app_name.capitalize}
+
+        A Regolith microservices application built with Rails and Docker.
+
+        ## Getting Started
+
+        ```bash
+        # Start all services
+        regolith server
+
+        # Generate a new service
+        regolith generate service users
+
+        # Open service in browser
+        regolith open users
+
+        # View service logs
+        regolith logs users -f
+
+        # Run database migrations
+        regolith db:migrate --all
+
+        # Health check
+        regolith health
+        ```
+
+        ## Services
+
+        #{services_documentation}
+
+        ## Development
+
+        ```bash
+        # Open Rails console for a service
+        regolith console users
+
+        # Run Rails commands
+        regolith rails users db:migrate
+        regolith rails users routes
+
+        # Run tests
+        regolith test --all
+
+        # Execute commands in service
+        regolith exec users bash
+        ```
+
+        ## Architecture
+
+        - **Rails 7** API-only applications
+        - **PostgreSQL** for persistence  
+        - **Docker Compose** for orchestration
+        - **Service registry** for inter-service communication
+
+        Built with [Regolith](https://regolith.bio) - Rails for distributed systems.
+      MARKDOWN
+    end
+
+    def services_documentation
+      config = load_regolith_config
+      return "No services yet. Run `regolith generate service <name>` to create one." if config['services'].empty?
+
+      config['services'].map do |name, service|
+        "- **#{name}** - http://localhost:#{service['port']}"
+      end.join("\n")
+    end
+
     def generate_makefile
       <<~MAKEFILE
-        .PHONY: server console build clean
+        .PHONY: server up down restart logs console test health doctor
 
-        server:
+        # Start services
+        server up:
         	regolith server
 
+        # Stop services  
+        down:
+        	regolith down
+
+        # Restart services
+        restart:
+        	regolith restart
+
+        # View logs
+        logs:
+        	regolith logs -f
+
+        # Open console (usage: make console SERVICE=users)
         console:
-        	regolith console
+        	@if [ -z "$(SERVICE)" ]; then echo "Usage: make console SERVICE=service_name"; exit 1; fi
+        	regolith console $(SERVICE)
+
+        # Run tests
+        test:
+        	regolith test --all
 
-        build:
-        	docker-compose build
+        # Health check
+        health:
+        	regolith health
 
+        # System diagnostics
+        doctor:
+        	regolith doctor
+
+        # Database operations
+        db-migrate:
+        	regolith db:migrate --all
+
+        db-setup:
+        	regolith db:setup --all
+
+        # Cleanup
         clean:
-        	docker-compose down -v
-        	docker system prune -f
+        	regolith prune
+
+        # Shortcuts
+        dev: up
+        stop: down
       MAKEFILE
     end
 
@@ -376,53 +1098,64 @@ end
       RUBY
     end
 
-    def generate_regolith_gemspec
-      <<~GEMSPEC
-        # -*- encoding: utf-8 -*-
-        lib = File.expand_path('../lib', __FILE__)
-        $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-        require 'regolith/version'
-
-        Gem::Specification.new do |gem|
-          gem.name          = "regolith"
-          gem.version       = Regolith::VERSION
-          gem.authors       = ["Regolith Team"]
-          gem.email         = ["team@regolith.dev"]
-          gem.description   = %q{Microservices framework for Ruby}
-          gem.summary       = %q{Build microservices with Ruby and Rails}
-          gem.homepage      = "https://github.com/regolith/regolith"
-
-          gem.files         = Dir['lib/**/*'] + ['README.md']
-          gem.executables   = ['regolith']
-          gem.test_files    = []
-          gem.require_paths = ["lib"]
-
-          gem.add_dependency "rails", ">= 7.0"
-          gem.add_dependency "rack-cors"
-        end
-      GEMSPEC
-    end
-
     def show_help
       puts <<~HELP
-        Regolith #{Regolith::VERSION} - Microservices framework
+        Regolith #{Regolith::VERSION} - Rails for Distributed Systems
 
         USAGE:
             regolith <command> [options]
 
-        COMMANDS:
+        PROJECT COMMANDS:
             new <app_name>              Create a new Regolith application
             generate service <name>     Generate a new microservice
-            server                      Start all services with Docker Compose
-            console <service_name>      Open Rails console for a service
-            version                     Show version information
+
+        SERVICE MANAGEMENT:
+            server, up                  Start all services with Docker Compose
+            down                        Stop and remove all services
+            restart [service]           Restart one or all services
+            stop [service]              Stop one or all services
+            ps, status                  Show running containers
+            logs [service] [-f]         View service logs
+            exec <service> [cmd]        Execute command in service container
+            shell <service>             Open shell in service container
+            rebuild [service]           Rebuild service images
+
+        RAILS INTEGRATION:
+            console <service>           Open Rails console for service
+            rails <service> <cmd>       Run Rails command in service
+            routes <service>            Show routes for service
+            open <service>              Open service in browser
+
+        DATABASE OPERATIONS:
+            db:migrate [service|--all]      Run migrations
+            db:create [service|--all]       Create databases
+            db:seed [service|--all]         Seed databases
+            db:reset [service|--all]        Reset databases
+            db:setup [service|--all]        Setup databases
+            db:drop [service|--all]         Drop databases
+
+        TESTING & HEALTH:
+            test [service|--all]        Run tests
+            health                      Health check all services
+
+        UTILITIES:
+            config [--json]             Show current configuration
+            inspect [--json]            Show services and resolved endpoints
+            prune                       Clean up Docker system
+            doctor                      Run system diagnostics
+            version                     Show version
 
         EXAMPLES:
-            regolith new observatory
-            regolith generate service telescope
-            regolith generate service records
+            regolith new marketplace
+            regolith generate service products
             regolith server
-            regolith console telescope
+            regolith rails products db:migrate
+            regolith routes products
+            regolith open products
+            regolith shell products
+            regolith inspect --json
+            regolith config --json | jq '.services'
+            regolith test --all
 
         Get started:
             regolith new myapp