regolith 0.1.15 → 0.1.19

data/lib/regolith/cli.rb

@@ -1,13 +1,62 @@
 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'
-require 'psych'
 
 module Regolith
+  # NOTE: VERSION is defined in lib/regolith/version.rb.
+  # Do not define Regolith::VERSION here to avoid constant redefinition warnings.
+
+  class << self
+    # Lightweight configuration with sane defaults
+    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
@@ -23,9 +72,9 @@ module Regolith
       when 'generate'
         generate_resource(@subcommand, @name)
       when 'server', 'up'
-        start_server
+        start_server(parse_flags(@args[1..-1]))
       when 'down'
-        stop_all_services
+        stop_services
       when 'restart'
         restart_service(@subcommand)
       when 'stop'
@@ -33,36 +82,36 @@ module Regolith
       when 'ps', 'status'
         show_status
       when 'logs'
-        show_logs(@subcommand, @args[2] == '-f' || @args[2] == '--follow')
+        show_logs(@subcommand, parse_flags(@args[2..-1]))
       when 'exec'
-        exec_in_service(@subcommand, @args[2..-1])
+        exec_command(@subcommand, @args[2..-1])
       when 'shell'
         shell_service(@subcommand)
-      when 'rails'
-        rails_passthrough(@subcommand, @args[2..-1])
       when 'console'
         open_console(@subcommand)
+      when 'rails'
+        rails_passthrough(@subcommand, @args[2..-1])
       when 'routes'
         show_routes(@subcommand)
       when 'open'
         open_service(@subcommand)
-      when 'db:create', 'db:migrate', 'db:seed', 'db:reset', 'db:setup', 'db:drop'
-        db_command(@command, @subcommand)
+      when 'db'
+        db_command(@subcommand, @name, parse_flags(@args[3..-1]))
       when 'test'
-        run_tests(@subcommand)
+        run_tests(@subcommand, parse_flags(@args[2..-1]))
       when 'health'
-        check_health
+        health_check
       when 'config'
-        show_config(@subcommand == '--json')
-      when 'inspect'
-        inspect_config(@subcommand == '--json')
-      when 'doctor'
-        run_diagnostics
+        show_config(parse_flags(@args[1..-1]))
       when 'prune'
-        prune_docker
+        prune_system
       when 'rebuild'
         rebuild_service(@subcommand)
-      when 'version'
+      when 'doctor'
+        run_doctor
+      when 'inspect'
+        inspect_services(parse_flags(@args[1..-1]))
+      when 'version', '--version', '-v'
         puts "Regolith #{Regolith::VERSION}"
       else
         show_help
@@ -71,6 +120,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"
@@ -108,6 +174,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
 
@@ -118,16 +186,17 @@ module Regolith
         exit 1
       end
 
-      # Validate service name
-      unless resource_name =~ /\A[a-z][a-z0-9_]*\z/
-        puts "❌ Invalid service name. Use lowercase letters, digits, and underscores."
-        exit 1
-      end
-
       generate_service(resource_name)
     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 = next_available_port
@@ -161,263 +230,213 @@ module Regolith
         exit 1
       end
 
-      # Generate custom Gemfile (clean up Rails-generated files first)
-      puts "🔧 Creating custom Gemfile..."
-      
-      # Remove Rails-generated Gemfile and lock file to avoid conflicts
-      FileUtils.rm_f("#{service_dir}/Gemfile")
-      FileUtils.rm_f("#{service_dir}/Gemfile.lock")
-      
-      generate_gemfile(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 libsqlite3-dev build-essential pkg-config"
-          puts "→ Try: sudo apt install -y libyaml-dev libsqlite3-dev build-essential pkg-config"
-          exit 1
-        end
-      end
-
-      patch_rails_app(service_dir, service_name, port)
+      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 server"
+      puts "→ Next: regolith generate service <another_service> or regolith server"
     end
 
-    def next_available_port(start = 3001)
-      config = load_regolith_config
-      used_ports = config['services']&.values&.map { |s| s['port'] }.to_set || Set.new
+    def next_available_port(start = (Regolith.configuration.respond_to?(:default_port) ? Regolith.configuration.default_port : 3001))
+      used = load_regolith_config['services'].values.map { |s| s['port'] }.to_set
       port = start
-      port += 1 while used_ports.include?(port)
+      port += 1 while used.include?(port)
       port
     end
 
-    def generate_gemfile(service_dir)
-      ruby_version = RUBY_VERSION.split('.')[0..1].join('.')
-    
-      custom_gemfile = <<~GEMFILE
+    def customize_service(service_dir, service_name, port)
+      # Detect Ruby MAJOR.MINOR
+      major_minor = RUBY_VERSION.split(".")[0..1].join(".")
+
+      # Write Gemfile (no vendoring; pull from RubyGems)
+      custom_gemfile = generate_gemfile(major_minor)
+      File.write("#{service_dir}/Gemfile", custom_gemfile)
+
+      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_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"
           gem "brakeman", require: false
           gem "rubocop-rails-omakase", require: false
         end
-    
-        gem "regolith", "~> 0.1.13"
-      GEMFILE
-    
-      File.write("#{service_dir}/Gemfile", custom_gemfile)
-    end
-
-
-    def vendor_regolith_gem(service_dir)
-      vendor_dir = File.join(service_dir, "vendor")
-      FileUtils.mkdir_p(vendor_dir)
-      
-      begin
-        # Try to find the regolith gem path
-        regolith_gem_path = if Gem.loaded_specs['regolith']
-          Gem.loaded_specs['regolith'].full_gem_path
-        else
-          # Fallback: search gem paths
-          Gem.path.each do |gem_path|
-            regolith_path = File.join(gem_path, 'gems', "regolith-#{Regolith::VERSION}")
-            return regolith_path if File.exist?(regolith_path)
-          end
-          nil
-        end
 
-        if regolith_gem_path && File.exist?(regolith_gem_path)
-          regolith_dest = File.join(vendor_dir, "regolith")
-          FileUtils.cp_r(regolith_gem_path, regolith_dest)
-          puts "📦 Vendored Regolith gem from #{regolith_gem_path}"
-        else
-          puts "⚠️  Could not find regolith gem path, using system gem instead"
-          # Update Gemfile to use system gem
-          gemfile_path = File.join(service_dir, "Gemfile")
-          gemfile_content = File.read(gemfile_path)
-          gemfile_content.gsub!('gem "regolith", path: "vendor/regolith"', 'gem "regolith", "~> 0.1.7"')
-          File.write(gemfile_path, gemfile_content)
-        end
-      rescue => e
-        puts "⚠️  Error vendoring regolith gem: #{e.message}"
-        puts "   Using system gem instead"
-        # Update Gemfile to use system gem
-        gemfile_path = File.join(service_dir, "Gemfile")
-        gemfile_content = File.read(gemfile_path)
-        gemfile_content.gsub!('gem "regolith", path: "vendor/regolith"', 'gem "regolith", "~> 0.1.7"')
-        File.write(gemfile_path, gemfile_content)
-      end
+        gem "regolith"
+      GEMFILE
     end
 
     def patch_rails_app(service_dir, service_name, port)
-      # Add health controller
-      add_health_controller(service_dir)
-      
-      # Add health route
+      create_initializers(service_dir, service_name)
+      create_health_controller(service_dir)
       add_health_route(service_dir)
-      
-      # Create initializer
+      File.write("#{service_dir}/Dockerfile", generate_dockerfile)
+      patch_application_rb(service_dir, service_name, port)
+    end
+
+    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))
-      
-      # Create Dockerfile
-      File.write("#{service_dir}/Dockerfile", generate_dockerfile)
+      File.write("#{initializer_dir}/cors.rb", generate_cors_initializer)
+    end
+
+    def create_health_controller(service_dir)
+      controller_dir = "#{service_dir}/app/controllers/regolith"
+      FileUtils.mkdir_p(controller_dir)
 
-      # Patch application.rb
+      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
+
+    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)
 
       cors_config = <<~RUBY
 
         # Regolith configuration
-        config.middleware.insert_before 0, Rack::Cors do
-          allow do
-            origins '*'
-            resource '*', headers: :any, methods: [:get, :post, :put, :patch, :delete, :options, :head]
-          end
-        end
-
         config.regolith_service_name = '#{service_name}'
         config.regolith_service_port = #{port}
       RUBY
 
-      app_rb_content.gsub!(/class Application < Rails::Application.*?
-  end/m) do |match|
-        match.gsub(/(\n  end)$/, "#{cors_config}\1")
-      end
-
+      app_rb_content.gsub!(/(\n  end\n\z)/, "#{cors_config}\1")
       File.write(app_rb_path, app_rb_content)
     end
 
-    def add_health_controller(service_dir)
-      controller_dir = File.join(service_dir, "app", "controllers", "regolith")
-      FileUtils.mkdir_p(controller_dir)
-      
-      health_controller = <<~RUBY
-        module Regolith
-          class HealthController < ActionController::API
-            def show
-              render json: {
-                ok: true,
-                service: Rails.application.config.regolith_service_name,
-                version: Regolith::VERSION,
-                time: Time.now.iso8601
-              }
-            end
-          end
-        end
-      RUBY
-      
-      File.write(File.join(controller_dir, "health_controller.rb"), health_controller)
-    end
-
-    def add_health_route(service_dir)
-      routes_path = File.join(service_dir, "config", "routes.rb")
-      content = File.read(routes_path)
-      
-      if content.sub!(/end\s*\z/, "  get '/health', to: 'regolith/health#show'\nend\n")
-        File.write(routes_path, content)
-      else
-        # Fallback: append to file
-        File.open(routes_path, "a") { |f| f.puts "\nget '/health', to: 'regolith/health#show'\n" }
-      end
-    end
-
-    def start_server
-      unless find_regolith_config
+    # Service management commands
+    def start_server(_flags = {})
+      unless File.exist?('docker-compose.yml')
         puts "❌ Error: Not in a Regolith app directory"
         exit 1
       end
 
       puts "🚀 Starting Regolith services..."
-      config = load_regolith_config
-
-      config['services'].each do |name, service|
-        puts "🚀 #{name}_service will run at http://localhost:#{service['port']}"
-      end
 
-      puts "🧭 Service registry loaded from config/regolith.yml"
-      puts ""
+      config = load_regolith_config
+      show_service_info(config)
 
-      exec_compose("up", "--build")
+      exec_compose('up', '--build')
     end
 
-    def stop_all_services
-      exec_compose("down")
+    def stop_services
+      puts "🛑 Stopping all services..."
+      exec_compose('down', '-v')
     end
 
-    def restart_service(service_name)
+    def restart_service(service_name = nil)
       if service_name
-        exec_compose("restart", service_name)
+        ensure_service_exists!(service_name)
+        puts "🔄 Restarting service '#{service_name}'..."
+        exec_compose('restart', service_name)
       else
-        exec_compose("restart")
+        puts "🔄 Restarting all services..."
+        exec_compose('restart')
       end
     end
 
-    def stop_service(service_name)
-      unless service_name
-        puts "❌ Error: Service name required"
-        puts "Usage: regolith stop <service_name>"
-        exit 1
+    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
-      exec_compose("stop", service_name)
     end
 
     def show_status
-      config = load_regolith_config
-      
-      # Try different format options for docker compose ps
+      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')
-      
-      if success && config['services'].any?
-        puts ""
-        puts "📋 Summary: #{config['services'].size} service#{'s' if config['services'].size != 1} configured"
+
+      # 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 "🚪 Ports: #{ports.join(', ')}"
+
+        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
-      
-      exit($?.exitstatus) unless success
     end
 
-    def show_logs(service_name, follow = false)
+    def show_logs(service_name = nil, flags = {})
       args = ['logs']
+      args << '--follow' if flags[:follow] || flags[:f]
       args << service_name if service_name
-      args << '-f' if follow
+
       exec_compose(*args)
     end
 
-    def exec_in_service(service_name, command)
-      unless service_name
-        puts "❌ Error: Service name required"
-        puts "Usage: regolith exec <service_name> <command>"
-        exit 1
+    def exec_command(service_name, command_args)
+      ensure_service_exists!(service_name)
+
+      if command_args.empty?
+        command_args = ['bash']
       end
-      
-      command = ['bash'] if command.empty?
-      exec_compose('exec', service_name, *command)
+
+      exec_compose('exec', service_name, *command_args)
     end
 
     def shell_service(service_name)
@@ -426,23 +445,22 @@ module Regolith
         puts "Usage: regolith shell <service_name>"
         exit 1
       end
+
+      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)
-      unless service_name
-        puts "❌ Error: Service name required"
-        puts "Usage: regolith rails <service_name> <rails_command>"
-        exit 1
-      end
+      ensure_service_exists!(service_name)
 
-      config = load_regolith_config
-      unless config['services'][service_name]
-        puts "❌ Error: Service '#{service_name}' not found"
+      if rails_args.empty?
+        puts "❌ Error: Rails command required"
+        puts "Usage: regolith rails <service> <command>"
         exit 1
       end
 
-      rails_args = ['--help'] if rails_args.empty?
       exec_compose('exec', service_name, 'bash', '-lc',
                    "bundle exec rails #{Shellwords.join(rails_args)}")
     end
@@ -454,25 +472,11 @@ module Regolith
         exit 1
       end
 
-      config = load_regolith_config
-      unless config['services'][service_name]
-        puts "❌ Error: Service '#{service_name}' not found"
-        exit 1
-      end
-
+      ensure_service_exists!(service_name)
       puts "🧪 Opening Rails console for #{service_name}_service..."
       exec_compose('exec', service_name, 'rails', 'console')
     end
 
-    def show_routes(service_name)
-      unless service_name
-        puts "❌ Error: Service name required"
-        puts "Usage: regolith routes <service_name>"
-        exit 1
-      end
-      rails_passthrough(service_name, ['routes'])
-    end
-
     def open_service(service_name)
       unless service_name
         puts "❌ Error: Service name required"
@@ -480,232 +484,296 @@ module Regolith
         exit 1
       end
 
+      ensure_service_exists!(service_name)
       config = load_regolith_config
-      service = config['services'][service_name]
-      unless service
-        puts "❌ Error: Service '#{service_name}' not found"
-        exit 1
-      end
+      port = config['services'][service_name]['port']
+      url = "http://localhost:#{port}"
 
-      url = "http://localhost:#{service['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)
-      when /linux|bsd/
-        system("xdg-open", url)
+        system("open #{url}")
       else
-        puts "Please open #{url} in your browser"
+        system("xdg-open #{url}") || puts("Visit: #{url}")
       end
     end
 
-    def db_command(command, service_or_flag)
-      db_action = command.split(':').last
-      
-      if service_or_flag == '--all'
-        config = load_regolith_config
-        config['services'].each do |service_name, _|
-          puts "🗄️ Running db:#{db_action} for #{service_name}..."
-          run_single_db_command(service_name, db_action)
+    # 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
-      elsif service_or_flag
-        run_single_db_command(service_or_flag, db_action)
       else
-        puts "❌ Error: Service name or --all flag required"
-        puts "Usage: regolith db:#{db_action} <service_name|--all>"
+        puts "❌ Unknown db action: #{action}"
+        puts "Available: create, migrate, seed, reset, setup, drop"
         exit 1
       end
     end
 
-    def run_single_db_command(service_name, action)
-      config = load_regolith_config
-      unless config['services'][service_name]
-        puts "❌ Error: Service '#{service_name}' not found"
-        return false
-      end
+    # 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')
 
-      success = system_compose('exec', service_name, 'rails', "db:#{action}")
-      unless success
-        puts "❌ db:#{action} failed for #{service_name} (exit code: #{$?.exitstatus})"
-        return false
+        unless success
+          puts "❌ Tests failed for #{service} (exit code: #{$?.exitstatus})"
+          exit 1 unless flags[:continue_on_failure]
+        end
       end
-      true
+
+      puts "✅ All tests passed!" if flags[:all]
     end
 
-    def run_tests(service_or_flag)
-      if service_or_flag == '--all'
-        config = load_regolith_config
-        all_passed = true
-        config['services'].each do |service_name, _|
-          puts "🧪 Running tests for #{service_name}..."
-          unless run_single_test(service_name)
-            all_passed = false
-          end
-        end
-        exit(1) unless all_passed
-      elsif service_or_flag
-        exit(1) unless run_single_test(service_or_flag)
-      else
-        puts "❌ Error: Service name or --all flag required"
-        puts "Usage: regolith test <service_name|--all>"
+    def show_routes(service_name)
+      unless service_name
+        puts "❌ Error: Service name required"
+        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
 
-    def run_single_test(service_name)
+    # Health and monitoring
+    def health_check
+      puts "🔍 Health Check Results:"
+      puts
+
       config = load_regolith_config
-      unless config['services'][service_name]
-        puts "❌ Error: Service '#{service_name}' not found"
-        return false
-      end
 
-      success = system_compose('exec', service_name, 'rails', 'test')
-      unless success
-        puts "❌ Tests failed for #{service_name} (exit code: #{$?.exitstatus})"
-        return false
+      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
-      true
     end
 
-    def check_health
-      config = load_regolith_config
-      puts "🔍 Health Check Results:"
-      
-      all_healthy = true
-      config['services'].each do |service_name, service|
-        health_data = check_service_health(service_name, service['port'])
-        if health_data
-          puts "✅ #{service_name} (port #{service['port']}) - healthy"
-          puts "   Version: #{health_data['version']}" if health_data['version']
-          puts "   Last seen: #{Time.parse(health_data['time']).strftime('%H:%M:%S')}" if health_data['time']
+    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
-          puts "❌ #{service_name} (port #{service['port']}) - unreachable"
-          all_healthy = false
+          { healthy: false, message: "HTTP #{response.code}" }
         end
+      rescue
+        { healthy: false, message: 'unreachable' }
       end
-      
-      exit(1) unless all_healthy
-    end
-
-    def check_service_health(service_name, port)
-      require_relative 'service_client'
-      response = Regolith::ServiceClient.health(service_name)
-      Regolith::ServiceClient.parsed_body(response) if response.code.to_i == 200
-    rescue => e
-      nil
     end
 
-    def show_config(json_format = false)
+    # Configuration
+    def show_config(flags = {})
       config = load_regolith_config
-      if json_format
+
+      if flags[:json]
         puts JSON.pretty_generate(config)
       else
+        puts "📋 Current Configuration:"
+        puts
         puts YAML.dump(config)
       end
     end
 
-    def inspect_config(json_format = false)
+    # 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 json_format
-        inspection = {
-          endpoints: {},
-          configuration: 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
         }
-        config['services'].each do |name, service|
-          inspection[:endpoints][name] = "http://localhost:#{service['port']}"
-        end
-        puts JSON.pretty_generate(inspection)
+        puts JSON.pretty_generate(inspection_data)
       else
-        puts "📊 Service Endpoints:"
-        config['services'].each do |name, service|
-          puts "  #{name}: http://localhost:#{service['port']}"
+        # 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 ""
-        puts "📋 Full Configuration:"
+
+        puts "\n📋 Full Configuration:"
         puts YAML.dump(config)
       end
     end
 
-    def run_diagnostics
-      puts "🔍 Regolith System Diagnostics"
-      puts ""
-      
-      # Check Docker
-      if system("docker --version > /dev/null 2>&1")
-        puts "✅ Docker is available"
-      else
-        puts "❌ Docker is not available"
-      end
-      
-      # Check Docker Compose
-      if system("docker compose version > /dev/null 2>&1") || 
-         system("docker-compose --version > /dev/null 2>&1")
-        puts "✅ Docker Compose is available"
+    # 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 is not available"
+        puts "❌ Docker Compose not found"
+        exit 1
       end
-      
-      # Check Rails
-      if system("rails --version > /dev/null 2>&1")
-        puts "✅ Rails is available"
-      else
-        puts "❌ Rails is not available"
-      end
-      
-      # Check Ruby version
-      puts "✅ Ruby #{RUBY_VERSION}"
-      
-      # Check Regolith config
-      if find_regolith_config
-        puts "✅ Regolith configuration found"
-        config = load_regolith_config
-        puts "   #{config['services'].size} service(s) configured"
-      else
-        puts "⚠️  No Regolith configuration found (not in a Regolith app directory)"
+    end
+
+    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 prune_docker
-      puts "🧹 Cleaning up Docker resources..."
-      system("docker system prune -f")
+    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 rebuild_service(service_name)
-      if service_name
-        puts "🔨 Rebuilding #{service_name}..."
-        exec_compose("build", "--no-cache", service_name)
-      else
-        puts "🔨 Rebuilding all services..."
-        exec_compose("build", "--no-cache")
+    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
-      config_path = find_regolith_config
-      return { 'services' => {} } unless config_path
-      
+      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
 
-    def find_regolith_config
-      current_dir = Dir.pwd
-      while current_dir != '/'
-        config_path = File.join(current_dir, 'config', 'regolith.yml')
-        return config_path if File.exist?(config_path)
-        current_dir = File.dirname(current_dir)
-      end
-      nil
-    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)
@@ -713,82 +781,89 @@ module Regolith
       File.write('docker-compose.yml', docker_compose)
     end
 
+    # File generators
     def generate_docker_compose(app_name, services = {})
-      template = <<~YAML
-        version: '3.8'
-
-        networks:
-          regolith:
-
-        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: 30s
-              timeout: 10s
-              retries: 3
-
-        <% services.each do |name, service| %>
-          <%= name %>:
-            build: 
-              context: <%= service['root'] %>
-              args:
-                BUILD_ENV: development
-            ports:
-              - "<%= service['port'] %>:3000"
-            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
-            networks:
-              - regolith
-            command: bash -c "rm -f tmp/pids/server.pid && bundle install && rails db:prepare && rails server -b 0.0.0.0"
-            healthcheck:
-              test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
-              interval: 30s
-              timeout: 10s
-              retries: 3
-        <% 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|
+      db_name = "#{app_name}_#{name}_development" # ← per-service DB
+    
+      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/#{db_name}",
+          '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
 
-        WORKDIR /app
+        # 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/*
 
-        RUN apt-get update -qq && apt-get install -y nodejs postgresql-client libyaml-dev libsqlite3-dev build-essential pkg-config curl
+        WORKDIR /app
 
+        # Copy Gemfile and install gems
         COPY Gemfile Gemfile.lock* ./
 
+        # 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
 
+        # Copy application code
         COPY . .
 
         EXPOSE 3000
@@ -810,6 +885,7 @@ module Regolith
           )
         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
@@ -818,22 +894,184 @@ module Regolith
       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:
         \tregolith server
 
+        # Stop services
+        down:
+        \tregolith down
+
+        # Restart services
+        restart:
+        \tregolith restart
+
+        # View logs
+        logs:
+        \tregolith logs -f
+
+        # Open console (usage: make console SERVICE=users)
         console:
-        \tregolith console
+        \t@if [ -z "$(SERVICE)" ]; then echo "Usage: make console SERVICE=service_name"; exit 1; fi
+        \tregolith console $(SERVICE)
+
+        # Run tests
+        test:
+        \tregolith test --all
+
+        # Health check
+        health:
+        \tregolith health
 
-        build:
-        \tdocker-compose build
+        # System diagnostics
+        doctor:
+        \tregolith doctor
 
+        # Database operations
+        db-migrate:
+        \tregolith db:migrate --all
+
+        db-setup:
+        \tregolith db:setup --all
+
+        # Cleanup
         clean:
-        \tdocker-compose down -v
-        \tdocker system prune -f
+        \tregolith prune
+
+        # Shortcuts
+        dev: up
+        stop: down
       MAKEFILE
     end
 
@@ -844,82 +1082,64 @@ module Regolith
       RUBY
     end
 
-    def exec_compose(*args)
-      if system("docker compose version > /dev/null 2>&1")
-        exec("docker", "compose", *args)
-      elsif system("docker-compose --version > /dev/null 2>&1")
-        exec("docker-compose", *args)
-      else
-        puts "❌ Error: Neither 'docker compose' nor 'docker-compose' is available"
-        exit 1
-      end
-    end
-
-    def system_compose(*args)
-      if system("docker compose version > /dev/null 2>&1")
-        system("docker", "compose", *args)
-      elsif system("docker-compose --version > /dev/null 2>&1")
-        system("docker-compose", *args)
-      else
-        puts "❌ Error: Neither 'docker compose' nor 'docker-compose' is available"
-        false
-      end
-    end
-
     def show_help
       puts <<~HELP
-        Regolith #{Regolith::VERSION} - Rails Microservices Framework
+        Regolith #{Regolith::VERSION} - Rails for Distributed Systems
 
         USAGE:
             regolith <command> [options]
 
-        PROJECT MANAGEMENT:
+        PROJECT COMMANDS:
             new <app_name>              Create a new Regolith application
             generate service <name>     Generate a new microservice
 
         SERVICE MANAGEMENT:
             server, up                  Start all services with Docker Compose
-            down                        Stop all services
-            restart [service]           Restart all services or specific service  
-            stop <service>              Stop a specific service
-            ps, status                  Show service status
-            logs [service] [-f]         Show logs (optionally follow)
-            exec <service> <command>    Execute command in service container
-            shell <service>             Open bash shell in service
+            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:
-            rails <service> <command>   Run Rails command in service
             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 URL in browser
+            open <service>              Open service in browser
 
         DATABASE OPERATIONS:
-            db:create [service|--all]   Create databases
-            db:migrate [service|--all]  Run migrations
-            db:seed [service|--all]     Seed databases
-            db:reset [service|--all]    Reset databases
-            db:setup [service|--all]    Setup databases
-            db:drop [service|--all]     Drop databases
+            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                      Check service health
+            health                      Health check all services
 
         UTILITIES:
-            config [--json]             Show configuration
-            inspect [--json]            Show endpoints and config
+            config [--json]             Show current configuration
+            inspect [--json]            Show services and resolved endpoints
+            prune                       Clean up Docker system
             doctor                      Run system diagnostics
-            prune                       Clean up Docker resources
-            rebuild [service]           Rebuild service images
-            version                     Show version information
+            version                     Show version
 
         EXAMPLES:
             regolith new marketplace
             regolith generate service products
             regolith server
             regolith rails products db:migrate
+            regolith routes products
             regolith open products
-            regolith health
+            regolith shell products
+            regolith inspect --json
+            regolith config --json | jq '.services'
+            regolith test --all
 
         Get started:
             regolith new myapp