regolith 0.1.19 → 0.1.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f4a42e2d4a1c0be079dff218128afc9451aeff7dae6c97f1c93ca5a43eb4ee9
-  data.tar.gz: 5783be43db0adbe9ac420f14190f4c8959130be1bcf9d94409549fb49bb301bd
+  metadata.gz: d590506b9d76a0cae7c0b4cc1355860e601c42740d8f4de852e41c001cee08e8
+  data.tar.gz: 412b231f3860a025d6f48c6f96aeb2dc5b60d9368d298e05849d490221f0092d
 SHA512:
-  metadata.gz: 8f82bd5a6ec97d8924eceb852ce49541808dc53483492968e1fbe9885cca0924d9a173f592e391afa95d6755dbe34d1d1eda89268bf9aadfcb5e2980dc2e200c
-  data.tar.gz: 462938815ddc6d7fbc4a7ea8c225e578538b90e824e13fc28a7dc4f153ba6e7379d72706b2223bef91782d63fbeea9c432f20b9f3f5eb9736d5828afaeb123b7
+  metadata.gz: f22e33c9f838f9a2c61af3808e8c7e0ba5f65e3729653e4674d8e3562dd184d6184f9b284fdcd657ad0f3ac6327521ccd2edbbea5e9a478b8e822f14edcb523d
+  data.tar.gz: a79ff4e21eba13f58cbed3d598dad134cf34df9ee9e3d7c99d0209397fec42b58ba180c636c7d8f2984902a49b8fd614335d819de156ea1e5bcd76128990122a

data/lib/regolith/cli.rb

@@ -1,62 +1,10 @@
 require 'fileutils'
 require 'yaml'
-require 'psych'
 require 'erb'
 require 'timeout'
 require 'rubygems'
-require 'net/http'
-require 'uri'
-require 'json'
-require 'ostruct'
-require 'set'
-require 'rbconfig'
-require 'shellwords'
 
 module Regolith
-  # 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
@@ -71,47 +19,11 @@ module Regolith
         create_new_app(@subcommand)
       when 'generate'
         generate_resource(@subcommand, @name)
-      when 'server', 'up'
-        start_server(parse_flags(@args[1..-1]))
-      when 'down'
-        stop_services
-      when 'restart'
-        restart_service(@subcommand)
-      when 'stop'
-        stop_service(@subcommand)
-      when 'ps', 'status'
-        show_status
-      when 'logs'
-        show_logs(@subcommand, parse_flags(@args[2..-1]))
-      when 'exec'
-        exec_command(@subcommand, @args[2..-1])
-      when 'shell'
-        shell_service(@subcommand)
+      when 'server'
+        start_server
       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'
-        db_command(@subcommand, @name, parse_flags(@args[3..-1]))
-      when 'test'
-        run_tests(@subcommand, parse_flags(@args[2..-1]))
-      when 'health'
-        health_check
-      when 'config'
-        show_config(parse_flags(@args[1..-1]))
-      when 'prune'
-        prune_system
-      when 'rebuild'
-        rebuild_service(@subcommand)
-      when 'doctor'
-        run_doctor
-      when 'inspect'
-        inspect_services(parse_flags(@args[1..-1]))
-      when 'version', '--version', '-v'
+      when 'version'
         puts "Regolith #{Regolith::VERSION}"
       else
         show_help
@@ -120,23 +32,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"
@@ -174,9 +69,7 @@ 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')
+      FileUtils.chmod(0o755, '.bin/regolith')
     end
 
     def generate_resource(resource_type, resource_name)
@@ -190,16 +83,9 @@ module Regolith
     end
 
     def generate_service(service_name)
-      # Validate service name
-      unless service_name =~ /\A[a-z][a-z0-9_]*\z/
-        puts "❌ Invalid service name. Use lowercase, digits, and underscores only."
-        puts "Examples: users, user_profiles, api_gateway"
-        exit 1
-      end
-
       puts "🔧 Creating service '#{service_name}'..."
       config = load_regolith_config
-      port = next_available_port
+      port = 3001 + (config['services']&.size || 0)
       service_dir = "services/#{service_name}_service"
 
       puts "  → Generating Rails API app..."
@@ -230,542 +116,154 @@ module Regolith
         exit 1
       end
 
-      customize_service(service_dir, service_name, port)
+      # Overwrite Gemfile before bundle install
+      puts "🔧 Overwriting Gemfile to remove sqlite3 and other defaults..."
 
-      config['services'][service_name] = {
-        'port' => port,
-        'root' => "./#{service_dir}"
-      }
+      major_minor = `ruby -e 'print RUBY_VERSION.split(".")[0..1].join(".")'`.strip
 
-      save_regolith_config(config)
-      update_docker_compose(config)
+      custom_gemfile = <<~GEMFILE
+        source "https://rubygems.org"
 
-      puts "✅ Created service '#{service_name}'"
-      puts "🚀 Service will run on port #{port}"
-      puts "→ Next: regolith generate service <another_service> or regolith server"
-    end
+        ruby "~> #{major_minor}.0"
 
-    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.include?(port)
-      port
-    end
+        gem "rails", "~> 7.2.2.1"
+        gem "pg", "~> 1.5"
+        gem "puma", ">= 5.0"
+        gem "rack-cors"
 
-    def customize_service(service_dir, service_name, port)
-      # Detect Ruby MAJOR.MINOR
-      major_minor = RUBY_VERSION.split(".")[0..1].join(".")
+        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
+
+        # Regolith vendored gem so the container can build without network access to your local gem
+        gem "regolith", path: "vendor/regolith"
+      GEMFILE
 
-      # Write Gemfile (no vendoring; pull from RubyGems)
-      custom_gemfile = generate_gemfile(major_minor)
       File.write("#{service_dir}/Gemfile", custom_gemfile)
 
+      # Vendor Regolith gem into service for Docker compatibility
+      vendor_dir = File.join(service_dir, "vendor")
+      FileUtils.mkdir_p(vendor_dir)
+      FileUtils.cp_r(File.expand_path("../..", __dir__), File.join(vendor_dir, "regolith"))
+      puts "📦 Vendored Regolith gem into #{File.join(service_dir, 'vendor', 'regolith')}"
+
       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"
+          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)
-    end
-
-    def generate_gemfile(ruby_version)
-      <<~GEMFILE
-        source "https://rubygems.org"
+      patch_bootsnap(service_dir)
 
-        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
+      config['services'][service_name] = {
+        'port' => port,
+        'root' => "./#{service_dir}"
+      }
+      save_regolith_config(config)
+      update_docker_compose(config)
 
-        gem "regolith"
-      GEMFILE
+      puts "✅ Created service '#{service_name}'"
+      puts "🚀 Service running on port #{port}"
+      puts "→ Next: regolith generate service <another_service> or regolith server"
     end
 
     def patch_rails_app(service_dir, service_name, port)
-      create_initializers(service_dir, service_name)
-      create_health_controller(service_dir)
-      add_health_route(service_dir)
-      File.write("#{service_dir}/Dockerfile", generate_dockerfile)
-      patch_application_rb(service_dir, service_name, port)
-    end
-
-    def create_initializers(service_dir, service_name)
       initializer_dir = "#{service_dir}/config/initializers"
       FileUtils.mkdir_p(initializer_dir)
-
       File.write("#{initializer_dir}/regolith.rb", generate_regolith_initializer(service_name))
-      File.write("#{initializer_dir}/cors.rb", generate_cors_initializer)
-    end
-
-    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
+      File.write("#{service_dir}/Dockerfile", generate_dockerfile)
 
-    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!(/(\n  end\n\z)/, "#{cors_config}\1")
-      File.write(app_rb_path, app_rb_content)
-    end
-
-    # Service management commands
-    def start_server(_flags = {})
-      unless File.exist?('docker-compose.yml')
-        puts "❌ Error: Not in a Regolith app directory"
-        exit 1
+      app_rb_content.gsub!(/class Application < Rails::Application.*?
+  end/m) do |match|
+        match.gsub(/(\n  end)$/, "#{cors_config}\1")
       end
 
-      puts "🚀 Starting Regolith services..."
-
-      config = load_regolith_config
-      show_service_info(config)
-
-      exec_compose('up', '--build')
-    end
-
-    def stop_services
-      puts "🛑 Stopping all services..."
-      exec_compose('down', '-v')
+      File.write(app_rb_path, app_rb_content)
     end
 
-    def restart_service(service_name = nil)
-      if service_name
-        ensure_service_exists!(service_name)
-        puts "🔄 Restarting service '#{service_name}'..."
-        exec_compose('restart', service_name)
-      else
-        puts "🔄 Restarting all services..."
-        exec_compose('restart')
-      end
-    end
+    # ---- Bootsnap Patch: make it optional & non-fatal ----
+    def patch_bootsnap(service_dir)
+      boot_path = File.join(service_dir, "config", "boot.rb")
+      return unless File.exist?(boot_path)
 
-    def stop_service(service_name = nil)
-      if service_name
-        ensure_service_exists!(service_name)
-        puts "⏹  Stopping service '#{service_name}'..."
-        exec_compose('stop', service_name)
-      else
-        puts "⏹  Stopping all services..."
-        exec_compose('stop')
-      end
-    end
+      content = File.read(boot_path)
 
-    def show_status
-      puts "📊 Service Status:"
-      puts
-
-      # Try different format options for maximum compatibility
-      success = system_compose('ps', '--format', 'table') ||
-                system_compose('ps', '--format', 'json') ||
-                system_compose('ps')
-
-      # Show summary counts and health check for exit code
-      if success
-        config = load_regolith_config
-        service_count = config['services'].size
-        ports = config['services'].values.map { |s| s['port'] }.sort
-
-        puts
-        puts "📋 Summary: #{service_count} services configured"
-        puts "🚪 Ports: #{ports.join(', ')}" if ports.any?
-
-        # Check health for proper exit code
-        healthy_services = 0
-        config['services'].each do |name, service_config|
-          port = service_config['port']
-          status = check_service_health(port)
-          healthy_services += 1 if status[:healthy]
+      # Remove any unconditional bootsnap require and replace with guarded load
+      content.gsub!(/^\s*require\s+["']bootsnap\/setup["']\s*$/, <<~RUBY.strip)
+        begin
+          require "bootsnap/setup"
+        rescue LoadError
+          warn "[regolith] bootsnap not found; continuing without it"
         end
+      RUBY
 
-        if healthy_services < service_count
-          puts "⚠️  #{service_count - healthy_services} services unhealthy"
-          exit 1
-        end
-      end
-    end
-
-    def show_logs(service_name = nil, flags = {})
-      args = ['logs']
-      args << '--follow' if flags[:follow] || flags[:f]
-      args << service_name if service_name
-
-      exec_compose(*args)
-    end
-
-    def exec_command(service_name, command_args)
-      ensure_service_exists!(service_name)
-
-      if command_args.empty?
-        command_args = ['bash']
-      end
-
-      exec_compose('exec', service_name, *command_args)
-    end
-
-    def shell_service(service_name)
-      unless service_name
-        puts "❌ Error: Service name required"
-        puts "Usage: regolith shell <service_name>"
-        exit 1
-      end
-
-      ensure_service_exists!(service_name)
-      puts "🐚 Opening shell for #{service_name}_service..."
-      exec_compose('exec', service_name, 'bash')
-    end
-
-    # Rails integration commands
-    def rails_passthrough(service_name, rails_args)
-      ensure_service_exists!(service_name)
-
-      if rails_args.empty?
-        puts "❌ Error: Rails command required"
-        puts "Usage: regolith rails <service> <command>"
-        exit 1
-      end
-
-      exec_compose('exec', service_name, 'bash', '-lc',
-                   "bundle exec rails #{Shellwords.join(rails_args)}")
-    end
-
-    def open_console(service_name)
-      unless service_name
-        puts "❌ Error: Service name required"
-        puts "Usage: regolith console <service_name>"
-        exit 1
-      end
-
-      ensure_service_exists!(service_name)
-      puts "🧪 Opening Rails console for #{service_name}_service..."
-      exec_compose('exec', service_name, 'rails', 'console')
+      File.write(boot_path, content)
     end
+    # ------------------------------------------------------
 
-    def open_service(service_name)
-      unless service_name
-        puts "❌ Error: Service name required"
-        puts "Usage: regolith open <service_name>"
+    def start_server
+      unless File.exist?('docker-compose.yml')
+        puts "❌ Error: Not in a Regolith app directory"
         exit 1
       end
 
-      ensure_service_exists!(service_name)
+      puts "🚀 Starting Regolith services..."
       config = load_regolith_config
-      port = config['services'][service_name]['port']
-      url = "http://localhost:#{port}"
-
-      puts "🌐 Opening #{url}..."
 
-      # Cross-platform open command
-      case RbConfig::CONFIG['host_os']
-      when /mswin|mingw|cygwin/
-        system(%{start "" "#{url}"})
-      when /darwin/
-        system("open #{url}")
-      else
-        system("xdg-open #{url}") || puts("Visit: #{url}")
-      end
-    end
-
-    # Database commands
-    def db_command(action, target, flags = {})
-      case action
-      when 'create', 'migrate', 'seed', 'reset', 'setup', 'drop'
-        each_target_service(target, flags) do |service|
-          puts "🗄  Running db:#{action} for #{service}..."
-          success = system_compose('exec', service, 'bash', '-lc', "bundle exec rails db:#{action}")
-
-          unless success
-            puts "❌ db:#{action} failed for #{service} (exit code: #{$?.exitstatus})"
-            exit 1 unless flags[:continue_on_failure]
-          end
-        end
-      else
-        puts "❌ Unknown db action: #{action}"
-        puts "Available: create, migrate, seed, reset, setup, drop"
-        exit 1
+      config['services'].each do |name, service|
+        puts "🚀 #{name}_service running at http://localhost:#{service['port']}"
       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')
+      puts "🧭 Service registry loaded from config/regolith.yml"
+      puts ""
 
-        unless success
-          puts "❌ Tests failed for #{service} (exit code: #{$?.exitstatus})"
-          exit 1 unless flags[:continue_on_failure]
-        end
-      end
-
-      puts "✅ All tests passed!" if flags[:all]
+      exec("docker-compose up --build")
     end
 
-    def show_routes(service_name)
+    def open_console(service_name)
       unless service_name
         puts "❌ Error: Service name required"
-        puts "Usage: regolith routes <service_name>"
+        puts "Usage: regolith console <service_name>"
         exit 1
       end
 
-      ensure_service_exists!(service_name)
-      puts "🛤  Routes for #{service_name}:"
-      system_compose('exec', service_name, 'bash', '-lc', 'bundle exec rails routes')
-    end
-
-    # Health and monitoring
-    def health_check
-      puts "🔍 Health Check Results:"
-      puts
-
-      config = load_regolith_config
-
-      config['services'].each do |name, service_config|
-        port = service_config['port']
-        status = check_service_health(port)
-
-        status_icon = status[:healthy] ? '✅' : '❌'
-        puts "#{status_icon} #{name} (port #{port}) - #{status[:message]}"
-
-        # Show additional health data if available
-        if status[:data] && status[:data]['version']
-          puts "   Version: #{status[:data]['version']}"
-        end
-        if status[:data] && status[:data]['time']
-          puts "   Last seen: #{Time.at(status[:data]['time']).strftime('%H:%M:%S')}"
-        end
-      end
-    end
-
-    def check_service_health(port)
-      begin
-        uri = URI("http://localhost:#{port}/health")
-        response = Net::HTTP.get_response(uri)
-
-        if response.code.to_i == 200
-          # Try to parse structured health data
-          health_data = JSON.parse(response.body) rescue {}
-          {
-            healthy: true,
-            message: 'healthy',
-            data: health_data
-          }
-        else
-          { healthy: false, message: "HTTP #{response.code}" }
-        end
-      rescue
-        { healthy: false, message: 'unreachable' }
-      end
-    end
-
-    # Configuration
-    def show_config(flags = {})
-      config = load_regolith_config
-
-      if flags[:json]
-        puts JSON.pretty_generate(config)
-      else
-        puts "📋 Current Configuration:"
-        puts
-        puts YAML.dump(config)
-      end
-    end
-
-    # Maintenance commands
-    def prune_system
-      puts "🧹 Pruning Docker system..."
-      exec_compose('down', '-v')
-      system('docker', 'system', 'prune', '-f')
-      puts "✅ System pruned"
-    end
-
-    def rebuild_service(service_name = nil)
-      if service_name
-        ensure_service_exists!(service_name)
-        puts "🔨 Rebuilding service '#{service_name}'..."
-        exec_compose('build', '--no-cache', service_name)
-      else
-        puts "🔨 Rebuilding all services..."
-        exec_compose('build', '--no-cache')
-      end
-    end
-
-    # System diagnostics
-    def run_doctor
-      puts "🩺 Regolith System Doctor"
-      puts "=" * 40
-
-      checks = [
-        { name: "Docker", check: -> { system('docker --version > /dev/null 2>&1') } },
-        { name: "Docker Compose", check: -> { docker_compose_available? } },
-        { name: "Ruby", check: -> { system('ruby --version > /dev/null 2>&1') } },
-        { name: "Rails", check: -> { system('rails --version > /dev/null 2>&1') } },
-        { name: "PostgreSQL Client", check: -> { system('psql --version > /dev/null 2>&1') } }
-      ]
-
-      checks.each do |check|
-        status = check[:check].call ? "✅" : "❌"
-        puts "#{status} #{check[:name]}"
-      end
-
-      puts
-      check_regolith_config
-    end
-
-    def check_regolith_config
-      puts "📋 Checking Regolith configuration..."
-
-      if File.exist?('config/regolith.yml')
-        config = load_regolith_config
-
-        if config['services'].empty?
-          puts "⚠️  No services configured"
-        else
-          puts "✅ Configuration valid (#{config['services'].size} services)"
-        end
-      else
-        puts "❌ No regolith.yml found - not in a Regolith project?"
-      end
-    end
-
-    def inspect_services(flags = {})
-      puts "🔍 Regolith Services Inspection"
-      puts "=" * 40
-
       config = load_regolith_config
-
-      if config['services'].empty?
-        puts "No services configured yet."
-        return
-      end
-
-      if flags[:json]
-        # JSON output for automation
-        inspection_data = {
-          services: config['services'].map do |name, service_config|
-            {
-              name: name,
-              port: service_config['port'],
-              endpoint: "http://localhost:#{service_config['port']}",
-              root: service_config['root']
-            }
-          end,
-          config: config
-        }
-        puts JSON.pretty_generate(inspection_data)
-      else
-        # Human-readable output
-        puts "\n📊 Service Endpoints:"
-        config['services'].each do |name, service_config|
-          port = service_config['port']
-          puts "  #{name}: http://localhost:#{port}"
-        end
-
-        puts "\n📋 Full Configuration:"
-        puts YAML.dump(config)
-      end
-    end
-
-    # Helper methods
-    def docker_compose_available?
-      system('docker compose version > /dev/null 2>&1') ||
-        system('docker-compose version > /dev/null 2>&1')
-    end
-
-    def docker_compose_command
-      if system('docker compose version > /dev/null 2>&1')
-        %w[docker compose]
-      elsif system('docker-compose version > /dev/null 2>&1')
-        %w[docker-compose]
-      else
-        puts "❌ Docker Compose not found"
+      unless config['services'][service_name]
+        puts "❌ Error: Service '#{service_name}' not found"
         exit 1
       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)
-      end
-    end
-
-    def ensure_service_exists!(service_name)
-      config = load_regolith_config
-      unless config['services'].key?(service_name)
-        puts "❌ Service '#{service_name}' not found"
-        puts "Available services: #{config['services'].keys.join(', ')}"
-        exit 1
-      end
-    end
-
-    def show_service_info(config)
-      config['services'].each do |name, service|
-        puts "🚀 #{name}_service: http://localhost:#{service['port']}"
-      end
-
-      puts "🧭 Service registry: config/regolith.yml"
-      puts
+      puts "🧪 Opening Rails console for #{service_name}_service..."
+      exec("docker-compose exec #{service_name} rails console")
     end
 
     def load_regolith_config
-      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) || {}
+      return({ 'services' => {} }) unless File.exist?('config/regolith.yml')
+      config = YAML.load_file('config/regolith.yml') || {}
       config['services'] ||= {}
       config
     end
@@ -773,7 +271,6 @@ module Regolith
     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)
@@ -781,91 +278,57 @@ 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|
-      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
+      template = <<~YAML
+        version: '3.8'
+
+        services:
+          db:
+            image: postgres:14
+            environment:
+              POSTGRES_DB: #{app_name}_development
+              POSTGRES_USER: postgres
+              POSTGRES_PASSWORD: password
+            ports:
+              - "5432:5432"
+            volumes:
+              - postgres_data:/var/lib/postgresql/data
+
+        <% services.each do |name, service| %>
+          <%= name %>:
+            build: <%= service['root'] %>
+            ports:
+              - "<%= service['port'] %>:3000"
+            depends_on:
+              - db
+            environment:
+              DATABASE_URL: postgres://postgres:password@db:5432/<%= app_name %>_development
+              REGOLITH_SERVICE_NAME: <%= name %>
+              REGOLITH_SERVICE_PORT: <%= service['port'] %>
+            volumes:
+              - <%= service['root'] %>:/app
+            command: bash -c "rm -f tmp/pids/server.pid && bundle install && rails server -b 0.0.0.0"
+        <% end %>
+
+        volumes:
+          postgres_data:
+      YAML
+
+      ERB.new(template).result(binding)
     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
-        COPY Gemfile Gemfile.lock* ./
+        RUN apt-get update -qq && apt-get install -y nodejs postgresql-client libyaml-dev libsqlite3-dev build-essential pkg-config
 
-        # 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 . .
 
+        RUN bundle install
+
         EXPOSE 3000
 
         CMD ["rails", "server", "-b", "0.0.0.0"]
@@ -875,17 +338,15 @@ module Regolith
     def generate_regolith_initializer(service_name)
       <<~RUBY
         require 'ostruct'
-
+        
         # Regolith service configuration
         Rails.application.configure do
           config.regolith = OpenStruct.new(
             service_name: '#{service_name}',
-            service_registry: Rails.root.join('../../config/regolith.yml'),
-            version: Regolith::VERSION
+            service_registry: Rails.root.join('../../config/regolith.yml')
           )
         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
@@ -894,184 +355,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
+        .PHONY: server console build clean
 
-        # Start services
-        server up:
-        \tregolith server
+        server:
+        	regolith 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:
-        \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
+        	regolith console
 
-        # System diagnostics
-        doctor:
-        \tregolith doctor
+        build:
+        	docker-compose build
 
-        # Database operations
-        db-migrate:
-        \tregolith db:migrate --all
-
-        db-setup:
-        \tregolith db:setup --all
-
-        # Cleanup
         clean:
-        \tregolith prune
-
-        # Shortcuts
-        dev: up
-        stop: down
+        	docker-compose down -v
+        	docker system prune -f
       MAKEFILE
     end
 
@@ -1084,62 +383,24 @@ module Regolith
 
     def show_help
       puts <<~HELP
-        Regolith #{Regolith::VERSION} - Rails for Distributed Systems
+        Regolith #{Regolith::VERSION} - Microservices framework
 
         USAGE:
             regolith <command> [options]
 
-        PROJECT COMMANDS:
+        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 and remove all services
-            restart [service]           Restart one or all services
-            stop [service]              Stop one or all services
-            ps, status                  Show running containers
-            logs [service] [-f]         View service logs
-            exec <service> [cmd]        Execute command in service container
-            shell <service>             Open shell in service container
-            rebuild [service]           Rebuild service images
-
-        RAILS INTEGRATION:
-            console <service>           Open Rails console for service
-            rails <service> <cmd>       Run Rails command in service
-            routes <service>            Show routes for service
-            open <service>              Open service in browser
-
-        DATABASE OPERATIONS:
-            db:migrate [service|--all]      Run migrations
-            db:create [service|--all]       Create databases
-            db:seed [service|--all]         Seed databases
-            db:reset [service|--all]        Reset databases
-            db:setup [service|--all]        Setup databases
-            db:drop [service|--all]         Drop databases
-
-        TESTING & HEALTH:
-            test [service|--all]        Run tests
-            health                      Health check all services
-
-        UTILITIES:
-            config [--json]             Show current configuration
-            inspect [--json]            Show services and resolved endpoints
-            prune                       Clean up Docker system
-            doctor                      Run system diagnostics
-            version                     Show version
+            server                      Start all services with Docker Compose
+            console <service_name>      Open Rails console for a service
+            version                     Show version information
 
         EXAMPLES:
-            regolith new marketplace
-            regolith generate service products
+            regolith new observatory
+            regolith generate service telescope
+            regolith generate service records
             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 console telescope
 
         Get started:
             regolith new myapp
@@ -1149,4 +410,4 @@ module Regolith
       HELP
     end
   end
-end
+end

data/lib/regolith/version.rb

@@ -1,4 +1,4 @@
 # lib/regolith/version.rb
 module Regolith
-  VERSION = "0.1.19"
+  VERSION = "0.1.21"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: regolith
 version: !ruby/object:Gem::Version
-  version: 0.1.19
+  version: 0.1.21
 platform: ruby
 authors:
 - Regolith Team
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-08-09 00:00:00.000000000 Z
+date: 2025-08-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport