regolith 0.1.9 → 0.1.11

data/lib/regolith/cli.rb

@@ -1,60 +1,13 @@
 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
-  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
@@ -70,9 +23,9 @@ module Regolith
       when 'generate'
         generate_resource(@subcommand, @name)
       when 'server', 'up'
-        start_server(parse_flags(@args[1..-1]))
+        start_server
       when 'down'
-        stop_services
+        stop_all_services
       when 'restart'
         restart_service(@subcommand)
       when 'stop'
@@ -80,36 +33,36 @@ module Regolith
       when 'ps', 'status'
         show_status
       when 'logs'
-        show_logs(@subcommand, parse_flags(@args[2..-1]))
+        show_logs(@subcommand, @args[2] == '-f' || @args[2] == '--follow')
       when 'exec'
-        exec_command(@subcommand, @args[2..-1])
+        exec_in_service(@subcommand, @args[2..-1])
       when 'shell'
         shell_service(@subcommand)
-      when 'console'
-        open_console(@subcommand)
       when 'rails'
         rails_passthrough(@subcommand, @args[2..-1])
+      when 'console'
+        open_console(@subcommand)
       when 'routes'
         show_routes(@subcommand)
       when 'open'
         open_service(@subcommand)
-      when 'db'
-        db_command(@subcommand, @name, parse_flags(@args[3..-1]))
+      when 'db:create', 'db:migrate', 'db:seed', 'db:reset', 'db:setup', 'db:drop'
+        db_command(@command, @subcommand)
       when 'test'
-        run_tests(@subcommand, parse_flags(@args[2..-1]))
+        run_tests(@subcommand)
       when 'health'
-        health_check
+        check_health
       when 'config'
-        show_config(parse_flags(@args[1..-1]))
+        show_config(@subcommand == '--json')
+      when 'inspect'
+        inspect_config(@subcommand == '--json')
+      when 'doctor'
+        run_diagnostics
       when 'prune'
-        prune_system
+        prune_docker
       when 'rebuild'
         rebuild_service(@subcommand)
-      when 'doctor'
-        run_doctor
-      when 'inspect'
-        inspect_services(parse_flags(@args[1..-1]))
-      when 'version', '--version', '-v'
+      when 'version'
         puts "Regolith #{Regolith::VERSION}"
       else
         show_help
@@ -118,23 +71,6 @@ 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"
@@ -172,8 +108,6 @@ 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
 
@@ -184,17 +118,16 @@ module Regolith
         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"
+      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)
       puts "🔧 Creating service '#{service_name}'..."
       config = load_regolith_config
       port = next_available_port
@@ -228,51 +161,46 @@ module Regolith
         exit 1
       end
 
-      customize_service(service_dir, service_name, port)
-      
+      # Generate custom Gemfile
+      puts "🔧 Creating custom Gemfile..."
+      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)
+
       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"
+      puts "→ Next: regolith server"
     end
 
-    def next_available_port(start = Regolith.configuration.default_port)
-      used = load_regolith_config['services'].values.map { |s| s['port'] }.to_set
+    def next_available_port(start = 3001)
+      config = load_regolith_config
+      used_ports = config['services']&.values&.map { |s| s['port'] }.to_set || Set.new
       port = start
-      port += 1 while used.include?(port)
+      port += 1 while used_ports.include?(port)
       port
     end
 
-    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(service_dir)
+      ruby_version = RUBY_VERSION.split('.')[0..1].join('.')
 
-    def generate_gemfile(ruby_version)
-      <<~GEMFILE
+      custom_gemfile = <<~GEMFILE
         source "https://rubygems.org"
 
         ruby "~> #{ruby_version}.0"
@@ -281,7 +209,6 @@ module Regolith
         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"
@@ -289,164 +216,201 @@ module Regolith
           gem "rubocop-rails-omakase", require: false
         end
 
-        gem "regolith"
+        gem "regolith", path: "vendor/regolith"
       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)
       
-      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}"
+      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
     end
 
     def patch_rails_app(service_dir, service_name, port)
-      create_initializers(service_dir, service_name)
-      create_health_controller(service_dir)
+      # Add health controller
+      add_health_controller(service_dir)
+      
+      # Add health route
       add_health_route(service_dir)
-      File.write("#{service_dir}/Dockerfile", generate_dockerfile)
-      patch_application_rb(service_dir, service_name, port)
-    end
-
-    def create_initializers(service_dir, service_name)
+      
+      # Create initializer
       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
-
-    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
+      # Create Dockerfile
+      File.write("#{service_dir}/Dockerfile", generate_dockerfile)
 
-    def patch_application_rb(service_dir, service_name, port)
+      # Patch application.rb
       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!(/(\n  end\n\z)/, "#{cors_config}\1")
+      app_rb_content.gsub!(/class Application < Rails::Application.*?
+  end/m) do |match|
+        match.gsub(/(\n  end)$/, "#{cors_config}\1")
+      end
+
       File.write(app_rb_path, app_rb_content)
     end
 
-    # Service management commands
-    def start_server(flags = {})
-      unless File.exist?('docker-compose.yml')
+    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
         puts "❌ Error: Not in a Regolith app directory"
         exit 1
       end
 
       puts "🚀 Starting Regolith services..."
-      
       config = load_regolith_config
-      show_service_info(config)
 
-      exec_compose('up', '--build')
+      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 ""
+
+      exec_compose("up", "--build")
     end
 
-    def stop_services
-      puts "🛑 Stopping all services..."
-      exec_compose('down', '-v')
+    def stop_all_services
+      exec_compose("down")
     end
 
-    def restart_service(service_name = nil)
+    def restart_service(service_name)
       if service_name
-        ensure_service_exists!(service_name)
-        puts "🔄 Restarting service '#{service_name}'..."
-        exec_compose('restart', service_name)
+        exec_compose("restart", service_name)
       else
-        puts "🔄 Restarting all services..."
-        exec_compose('restart')
+        exec_compose("restart")
       end
     end
 
-    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')
+    def stop_service(service_name)
+      unless service_name
+        puts "❌ Error: Service name required"
+        puts "Usage: regolith stop <service_name>"
+        exit 1
       end
+      exec_compose("stop", service_name)
     end
 
     def show_status
-      puts "📊 Service Status:"
-      puts
+      config = load_regolith_config
       
-      # Try different format options for maximum compatibility
+      # Try different format options for docker compose ps
       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
+      if success && config['services'].any?
+        puts ""
+        puts "📋 Summary: #{config['services'].size} service#{'s' if config['services'].size != 1} configured"
         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
+        puts "🚪 Ports: #{ports.join(', ')}"
       end
+      
+      exit($?.exitstatus) unless success
     end
 
-    def show_logs(service_name = nil, flags = {})
+    def show_logs(service_name, follow = false)
       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_command(service_name, command_args)
-      ensure_service_exists!(service_name)
-      
-      if command_args.empty?
-        command_args = ['bash']
+    def exec_in_service(service_name, command)
+      unless service_name
+        puts "❌ Error: Service name required"
+        puts "Usage: regolith exec <service_name> <command>"
+        exit 1
       end
       
-      exec_compose('exec', service_name, *command_args)
+      command = ['bash'] if command.empty?
+      exec_compose('exec', service_name, *command)
     end
 
     def shell_service(service_name)
@@ -455,24 +419,25 @@ 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)
-      ensure_service_exists!(service_name)
-      
-      if rails_args.empty?
-        puts "❌ Error: Rails command required"
-        puts "Usage: regolith rails <service> <command>"
+      unless service_name
+        puts "❌ Error: Service name required"
+        puts "Usage: regolith rails <service_name> <rails_command>"
         exit 1
       end
-      
-      exec_compose('exec', service_name, 'bash', '-lc', 
-                  "bundle exec rails #{Shellwords.join(rails_args)}")
+
+      config = load_regolith_config
+      unless config['services'][service_name]
+        puts "❌ Error: Service '#{service_name}' not found"
+        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
 
     def open_console(service_name)
@@ -482,11 +447,25 @@ module Regolith
         exit 1
       end
 
-      ensure_service_exists!(service_name)
+      config = load_regolith_config
+      unless config['services'][service_name]
+        puts "❌ Error: Service '#{service_name}' not found"
+        exit 1
+      end
+
       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"
@@ -494,296 +473,232 @@ module Regolith
         exit 1
       end
 
-      ensure_service_exists!(service_name)
       config = load_regolith_config
-      port = config['services'][service_name]['port']
-      url = "http://localhost:#{port}"
-      
+      service = config['services'][service_name]
+      unless service
+        puts "❌ Error: Service '#{service_name}' not found"
+        exit 1
+      end
+
+      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}")
+        system("open", url)
+      when /linux|bsd/
+        system("xdg-open", url)
       else
-        system("xdg-open #{url}") || puts("Visit: #{url}")
+        puts "Please open #{url} in your browser"
       end
     end
 
-    # 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
+    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)
         end
+      elsif service_or_flag
+        run_single_db_command(service_or_flag, db_action)
       else
-        puts "❌ Unknown db action: #{action}"
-        puts "Available: create, migrate, seed, reset, setup, drop"
+        puts "❌ Error: Service name or --all flag required"
+        puts "Usage: regolith db:#{db_action} <service_name|--all>"
         exit 1
       end
     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')
-        
-        unless success
-          puts "❌ Tests failed for #{service} (exit code: #{$?.exitstatus})"
-          exit 1 unless flags[:continue_on_failure]
-        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
-      
-      puts "✅ All tests passed!" if flags[:all]
+
+      success = system_compose('exec', service_name, 'rails', "db:#{action}")
+      unless success
+        puts "❌ db:#{action} failed for #{service_name} (exit code: #{$?.exitstatus})"
+        return false
+      end
+      true
     end
 
-    def show_routes(service_name)
-      unless service_name
-        puts "❌ Error: Service name required"
-        puts "Usage: regolith routes <service_name>"
+    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>"
         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
-      
+    def run_single_test(service_name)
       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
+      unless config['services'][service_name]
+        puts "❌ Error: Service '#{service_name}' not found"
+        return false
       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' }
+      success = system_compose('exec', service_name, 'rails', 'test')
+      unless success
+        puts "❌ Tests failed for #{service_name} (exit code: #{$?.exitstatus})"
+        return false
       end
+      true
     end
 
-    # Configuration
-    def show_config(flags = {})
+    def check_health
       config = load_regolith_config
+      puts "🔍 Health Check Results:"
       
-      if flags[:json]
-        puts JSON.pretty_generate(config)
-      else
-        puts "📋 Current Configuration:"
-        puts
-        puts YAML.dump(config)
+      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']
+        else
+          puts "❌ #{service_name} (port #{service['port']}) - unreachable"
+          all_healthy = false
+        end
       end
+      
+      exit(1) unless all_healthy
     end
 
-    # Maintenance commands
-    def prune_system
-      puts "🧹 Pruning Docker system..."
-      exec_compose('down', '-v')
-      system('docker', 'system', 'prune', '-f')
-      puts "✅ System pruned"
+    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 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)
+    def show_config(json_format = false)
+      config = load_regolith_config
+      if json_format
+        puts JSON.pretty_generate(config)
       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]}"
+        puts YAML.dump(config)
       end
-      
-      puts
-      check_regolith_config
     end
 
-    def check_regolith_config
-      puts "📋 Checking Regolith configuration..."
+    def inspect_config(json_format = false)
+      config = load_regolith_config
       
-      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)"
+      if json_format
+        inspection = {
+          endpoints: {},
+          configuration: config
+        }
+        config['services'].each do |name, service|
+          inspection[:endpoints][name] = "http://localhost:#{service['port']}"
         end
+        puts JSON.pretty_generate(inspection)
       else
-        puts "❌ No regolith.yml found - not in a Regolith project?"
+        puts "📊 Service Endpoints:"
+        config['services'].each do |name, service|
+          puts "  #{name}: http://localhost:#{service['port']}"
+        end
+        puts ""
+        puts "📋 Full Configuration:"
+        puts YAML.dump(config)
       end
     end
 
-    def inspect_services(flags = {})
-      puts "🔍 Regolith Services Inspection"
-      puts "=" * 40
-      
-      config = load_regolith_config
+    def run_diagnostics
+      puts "🔍 Regolith System Diagnostics"
+      puts ""
       
-      if config['services'].empty?
-        puts "No services configured yet."
-        return
+      # Check Docker
+      if system("docker --version > /dev/null 2>&1")
+        puts "✅ Docker is available"
+      else
+        puts "❌ Docker is not available"
       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)
+      # 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"
       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)
+        puts "❌ Docker Compose is not available"
       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]
+      
+      # Check Rails
+      if system("rails --version > /dev/null 2>&1")
+        puts "✅ Rails is available"
       else
-        puts "❌ Docker Compose not found"
-        exit 1
+        puts "❌ Rails is not available"
       end
-    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)
+      # 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
     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
+    def prune_docker
+      puts "🧹 Cleaning up Docker resources..."
+      system("docker system prune -f")
     end
 
-    def show_service_info(config)
-      config['services'].each do |name, service|
-        puts "🚀 #{name}_service: http://localhost:#{service['port']}"
+    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")
       end
-      
-      puts "🧭 Service registry: config/regolith.yml"
-      puts
     end
 
     def load_regolith_config
-      config_path = Regolith.send(:find_regolith_config)
-      return { 'services' => {} } unless config_path && File.exist?(config_path)
+      config_path = find_regolith_config
+      return { 'services' => {} } unless 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)
@@ -791,95 +706,82 @@ module Regolith
       File.write('docker-compose.yml', docker_compose)
     end
 
-    # File generators
     def generate_docker_compose(app_name, services = {})
-      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
+      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)
     end
 
     def generate_dockerfile
       <<~DOCKERFILE
-        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/*
+        FROM ruby:3.1
 
         WORKDIR /app
 
-        # Copy Gemfile and install gems
+        RUN apt-get update -qq && apt-get install -y nodejs postgresql-client libyaml-dev libsqlite3-dev build-essential pkg-config curl
+
         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
@@ -891,7 +793,7 @@ module Regolith
     def generate_regolith_initializer(service_name)
       <<~RUBY
         require 'ostruct'
-        
+
         # Regolith service configuration
         Rails.application.configure do
           config.regolith = OpenStruct.new(
@@ -901,7 +803,6 @@ 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
@@ -910,184 +811,22 @@ 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 up down restart logs console test health doctor
-
-        # Start services
-        server up:
-        	regolith server
-
-        # Stop services  
-        down:
-        	regolith down
+        .PHONY: server console build clean
 
-        # Restart services
-        restart:
-        	regolith restart
+        server:
+        \tregolith server
 
-        # View logs
-        logs:
-        	regolith logs -f
-
-        # Open console (usage: make console SERVICE=users)
         console:
-        	@if [ -z "$(SERVICE)" ]; then echo "Usage: make console SERVICE=service_name"; exit 1; fi
-        	regolith console $(SERVICE)
-
-        # Run tests
-        test:
-        	regolith test --all
-
-        # Health check
-        health:
-        	regolith health
+        \tregolith console
 
-        # System diagnostics
-        doctor:
-        	regolith doctor
+        build:
+        \tdocker-compose build
 
-        # Database operations
-        db-migrate:
-        	regolith db:migrate --all
-
-        db-setup:
-        	regolith db:setup --all
-
-        # Cleanup
         clean:
-        	regolith prune
-
-        # Shortcuts
-        dev: up
-        stop: down
+        \tdocker-compose down -v
+        \tdocker system prune -f
       MAKEFILE
     end
 
@@ -1098,64 +837,82 @@ 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 for Distributed Systems
+        Regolith #{Regolith::VERSION} - Rails Microservices Framework
 
         USAGE:
             regolith <command> [options]
 
-        PROJECT COMMANDS:
+        PROJECT MANAGEMENT:
             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 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
+            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
 
         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 in browser
+            open <service>              Open service URL 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
+            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
 
         TESTING & HEALTH:
             test [service|--all]        Run tests
-            health                      Health check all services
+            health                      Check service health
 
         UTILITIES:
-            config [--json]             Show current configuration
-            inspect [--json]            Show services and resolved endpoints
-            prune                       Clean up Docker system
+            config [--json]             Show configuration
+            inspect [--json]            Show endpoints and config
             doctor                      Run system diagnostics
-            version                     Show version
+            prune                       Clean up Docker resources
+            rebuild [service]           Rebuild service images
+            version                     Show version information
 
         EXAMPLES:
             regolith new marketplace
             regolith generate service products
             regolith server
             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
+            regolith health
 
         Get started:
             regolith new myapp