regolith 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ab1bb3625f09d797596ad621a52eea0c1db33939cf262c4030807a4b37301172
+  data.tar.gz: 699de873f98dd3416e38feaa9a3af4377ad8810c7db1329122a55bc0898792f5
+SHA512:
+  metadata.gz: bc39ef600c9cc6e1890ac561076ed67c36d07ae03700f715b1c1b94056b520b4a8bb076802c99bad1613f8c987c31d797c48db7943dcc7471bfde8407d5ac4b7
+  data.tar.gz: 4469ecbd5381b6b6019b8ecc5e1051a6da78b19526e9641872b17d95bae2bc866dfe953735359a95501ae3dc272bb02e33ffc8c9f5977fcb638f52787eb5d0fc

data/CHANGELOG.md

@@ -0,0 +1,22 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [0.1.0] - 2025-07-30
+
+### Added
+- Initial Regolith framework release
+- CLI for creating and managing microservices
+- Cross-service ActiveRecord-style associations
+- Docker Compose orchestration
+- Rails API service generation
+- Service discovery and registry
+- Working observatory example application
+
+### Features
+- `regolith new <app>` - Create new distributed applications
+- `regolith generate service <name>` - Generate Rails API services
+- `regolith server` - Start all services with Docker
+- `regolith console <service>` - Open Rails console for any service
+- Zero-configuration service discovery
+- Hot reload development environment

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Regolith Framework
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,210 @@
+# Regolith
+
+**Rails for Distributed Systems**
+
+Regolith brings the elegance and developer experience of Rails to microservices architecture. Write cross-service associations like `user.orders.create!` and let Regolith handle the distributed complexity.
+
+[![Gem Version](https://badge.fury.io/rb/regolith.svg)](https://badge.fury.io/rb/regolith)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## ✨ Features
+
+- **Zero-config service discovery** - Services find each other automatically
+- **ActiveRecord-style cross-service associations** - `user.orders.create!` works across services
+- **Docker orchestration built-in** - One command starts your entire stack
+- **Rails API scaffolding** - Generate production-ready services in seconds
+- **Hot reload development** - Code changes reflect immediately in running containers
+- **Rails console access** - Debug any service with `regolith console users`
+
+## 🚀 Quick Start
+
+### Installation
+
+```bash
+gem install regolith
+Create your first distributed app
+bash# Create new app
+regolith new my-app
+cd my-app
+
+# Generate microservices
+regolith generate service users
+regolith generate service orders
+
+# Start everything
+regolith server
+Your services are now running:
+
+👥 users_service at http://localhost:3001
+📦 orders_service at http://localhost:3002
+🗄️ PostgreSQL at localhost:5432
+
+🌟 Cross-Service Magic
+Define relationships that span services:
+ruby# users_service/app/models/user.rb
+class User < Regolith::RegolithRecord
+  service :users
+  has_many :orders, service: :orders
+end
+
+# orders_service/app/models/order.rb
+class Order < Regolith::RegolithRecord
+  service :orders
+  belongs_to :user, service: :users
+end
+Use them naturally:
+ruby# In users_service Rails console
+user = User.create!(name: "Alice", email: "alice@example.com")
+user.orders.create!(product: "iPhone", amount: 999)
+
+# In orders_service Rails console  
+order = Order.find(1)
+order.user.name # "Alice" - fetched from users_service!
+📁 Project Structure
+my-app/
+├── docker-compose.yml          # Orchestration config
+├── config/
+│   └── regolith.yml           # Service registry
+├── services/
+│   ├── users_service/         # Rails API app
+│   └── orders_service/        # Rails API app
+└── Makefile                   # Convenience commands
+🛠️ CLI Commands
+CommandPurposeregolith new <app>Create new Regolith applicationregolith generate service <name>Generate new microserviceregolith serverStart all services with Docker Composeregolith console <service>Open Rails console for serviceregolith versionShow version information
+🏗️ How It Works
+Service Discovery
+Services are registered in config/regolith.yml:
+yamlname: my-app
+services:
+  users:
+    port: 3001
+    root: ./services/users_service
+  orders:
+    port: 3002
+    root: ./services/orders_service
+Inter-Service Communication
+The Regolith::RegolithRecord class extends ActiveModel with HTTP-based service calls:
+rubyclass User < Regolith::RegolithRecord
+  service :users
+  has_many :orders, service: :orders
+end
+When you call user.orders.create!(), Regolith:
+
+Identifies the target service (:orders)
+Makes HTTP POST to orders_service/orders
+Includes the foreign key (user_id)
+Returns the created object
+
+Docker Integration
+Each service gets its own container with:
+
+Hot reload via volume mounts
+Shared PostgreSQL database
+Inter-service networking
+Environment-based configuration
+
+🧪 Development Workflow
+bash# Start all services
+regolith server
+
+# Open Rails console for any service
+regolith console users
+
+# Test cross-service relationships
+User.first.orders.create!(product: "Laptop", amount: 1200)
+
+# Check logs
+docker-compose logs -f users
+
+# Add new service
+regolith generate service analytics
+📦 Example: E-commerce Platform
+bash# Create the platform
+regolith new ecommerce
+cd ecommerce
+
+# Generate services
+regolith generate service users
+regolith generate service products  
+regolith generate service orders
+regolith generate service payments
+
+# Start everything
+regolith server
+ruby# Define cross-service relationships
+class User < Regolith::RegolithRecord
+  service :users
+  has_many :orders, service: :orders
+end
+
+class Order < Regolith::RegolithRecord
+  service :orders
+  belongs_to :user, service: :users
+  belongs_to :product, service: :products
+  has_one :payment, service: :payments
+end
+
+# Use like Rails
+user = User.create!(name: "Bob", email: "bob@shop.com")
+product = Product.create!(name: "MacBook", price: 2000)
+order = user.orders.create!(product: product)
+order.create_payment!(amount: 2000, method: "credit_card")
+🔧 Configuration
+Custom Service Configuration
+ruby# config/initializers/regolith.rb
+Regolith.configure do |config|
+  config.timeout = 30
+  config.retry_attempts = 3
+end
+Environment Variables
+VariablePurposeREGOLITH_SERVICE_NAMECurrent service identifierREGOLITH_SERVICE_PORTService port mappingDATABASE_URLShared database connection
+Production Deployment
+For production, replace Docker Compose with:
+
+Container orchestration: Kubernetes, ECS, or similar
+Service mesh: Istio, Linkerd for advanced networking
+Service discovery: Consul, etcd for dynamic registration
+Load balancing: nginx, HAProxy for traffic distribution
+Monitoring: Prometheus, Grafana for observability
+
+📚 Examples
+Working Observatory App
+The repository includes a complete example in observatory/:
+
+telescope_service - User management
+records_service - Observation tracking
+Full cross-service associations
+Docker orchestration
+
+More Examples
+
+E-commerce Platform - Multi-service shopping platform
+Social Network - Users, posts, and comments across services
+Blog Platform - Authors, articles, and analytics services
+
+🤝 Contributing
+We love contributions! See CONTRIBUTING.md for guidelines.
+
+Fork the repository
+Create feature branch (git checkout -b feature/amazing-feature)
+Commit changes (git commit -m 'Add amazing feature')
+Push to branch (git push origin feature/amazing-feature)
+Open Pull Request
+
+🐛 Issues & Support
+
+Bug reports: GitHub Issues
+Feature requests: GitHub Discussions
+Documentation: GitHub Wiki
+
+📄 License
+MIT License - see LICENSE for details.
+🙏 Acknowledgments
+
+Inspired by the elegance of Ruby on Rails
+Built for the modern microservices era
+Designed to make distributed systems feel human
+
+
+Regolith: Because microservices shouldn't be micro-management.
+Built with ❤️ for developers who want to focus on features, not infrastructure.

data/bin/regolith

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/regolith'
+
+Regolith::CLI.new(ARGV).run

data/lib/regolith/cli.rb

@@ -0,0 +1,435 @@
+require 'fileutils'
+require 'yaml'
+require 'erb'
+require 'timeout'
+require 'rubygems'
+
+module Regolith
+  class CLI
+    def initialize(args)
+      @args = args
+      @command = args[0]
+      @subcommand = args[1]
+      @name = args[2]
+    end
+
+    def run
+      case @command
+      when 'new'
+        create_new_app(@subcommand)
+      when 'generate'
+        generate_resource(@subcommand, @name)
+      when 'server'
+        start_server
+      when 'console'
+        open_console(@subcommand)
+      when 'version'
+        puts "Regolith #{Regolith::VERSION}"
+      else
+        show_help
+      end
+    end
+
+    private
+
+    def create_new_app(app_name)
+      unless app_name
+        puts "❌ Error: App name required"
+        puts "Usage: regolith new <app_name>"
+        exit 1
+      end
+
+      puts "🏗  Creating Regolith app '#{app_name}'..."
+
+      FileUtils.mkdir_p(app_name)
+      Dir.chdir(app_name) do
+        create_app_structure(app_name)
+      end
+
+      puts "✅ Created Regolith app '#{app_name}'"
+      puts "→ Next: cd #{app_name} && regolith generate service <service_name>"
+    end
+
+    def create_app_structure(app_name)
+      FileUtils.mkdir_p(['config', 'services', '.bin'])
+
+      regolith_config = {
+        'name' => app_name,
+        'version' => '0.1.0',
+        'services' => {},
+        'infrastructure' => {
+          'database' => {
+            'type' => 'postgresql',
+            'port' => 5432
+          }
+        }
+      }
+
+      File.write('config/regolith.yml', YAML.dump(regolith_config))
+      File.write('docker-compose.yml', generate_docker_compose(app_name))
+      File.write('Makefile', generate_makefile)
+      File.write('.bin/regolith', generate_regolith_shim)
+      FileUtils.chmod(0755, '.bin/regolith')
+    end
+
+    def generate_resource(resource_type, resource_name)
+      unless resource_type == 'service' && resource_name
+        puts "❌ Error: Invalid generate command"
+        puts "Usage: regolith generate service <service_name>"
+        exit 1
+      end
+
+      generate_service(resource_name)
+    end
+
+    def generate_service(service_name)
+      puts "🔧 Creating service '#{service_name}'..."
+      config = load_regolith_config
+      port = 3001 + (config['services']&.size || 0)
+      service_dir = "services/#{service_name}_service"
+
+      puts "  → Generating Rails API app..."
+
+      cmd = [
+        "rails", "new", service_dir,
+        "--api",
+        "--skip-active-storage",
+        "--skip-action-mailbox",
+        "--skip-action-cable",
+        "--skip-bundle",
+        "--quiet"
+      ]
+
+      puts "Running: #{cmd.join(' ')}"
+
+      begin
+        Timeout.timeout(180) do
+          success = system(*cmd)
+          unless success
+            puts "❌ rails new failed with exit code #{$?.exitstatus}"
+            exit 1
+          end
+        end
+      rescue Timeout::Error
+        puts "⏱️ rails new timed out after 3 minutes"
+        puts "Try running manually: #{cmd.join(' ')}"
+        exit 1
+      end
+
+      puts "🔧 Overwriting Gemfile to remove sqlite3 and other defaults..."
+      ruby_version = `ruby -e 'print RUBY_VERSION'`.strip
+      ruby_major_minor = ruby_version.split('.')[0..1].join('.')
+
+      custom_gemfile = <<~GEMFILE
+        source "https://rubygems.org"
+        ruby "~> #{ruby_major_minor}.0"
+        gem "rails", "~> 7.2.2.1"
+        gem "pg", "~> 1.5"
+        gem "puma", ">= 5.0"
+        gem "rack-cors"
+
+        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", path: "vendor/regolith"
+      GEMFILE
+
+      File.write("#{service_dir}/Gemfile", custom_gemfile)
+
+      vendor_dir = File.join(service_dir, "vendor")
+      regolith_vendor_dir = File.join(vendor_dir, "regolith")
+      FileUtils.mkdir_p(vendor_dir)
+      source_dir = File.expand_path("../..", __dir__)
+      FileUtils.cp_r(source_dir, regolith_vendor_dir)
+      Dir.glob(File.join(regolith_vendor_dir, "regolith-*")).each { |nested_dir| FileUtils.rm_rf(nested_dir) }
+
+      gemspec_path = File.join(regolith_vendor_dir, "regolith.gemspec")
+      File.write(gemspec_path, generate_regolith_gemspec) unless File.exist?(gemspec_path)
+
+      puts "📦 Vendored Regolith gem into #{regolith_vendor_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 running on port #{port}"
+      puts "→ Next: regolith generate service <another_service> or regolith server"
+    end
+
+    def patch_rails_app(service_dir, service_name, port)
+  initializer_dir = "#{service_dir}/config/initializers"
+  FileUtils.mkdir_p(initializer_dir)
+  File.write("#{initializer_dir}/regolith.rb", generate_regolith_initializer(service_name))
+  File.write("#{service_dir}/Dockerfile", generate_dockerfile)
+
+  app_rb_path = "#{service_dir}/config/application.rb"
+  app_rb_content = File.read(app_rb_path)
+
+  # Ensure Regolith config block is inserted safely
+  insert_block = <<~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_lines = app_rb_content.lines
+  target_index = app_rb_lines.index { |line| line =~ /^\s*class Application < Rails::Application/ }
+
+  if target_index
+    insertion_point = app_rb_lines.index { |line| line.strip == 'end' && app_rb_lines.index(line) > target_index }
+    if insertion_point
+      app_rb_lines.insert(insertion_point, insert_block)
+      File.write(app_rb_path, app_rb_lines.join)
+    end
+  end
+
+  # Clean up boot.rb again just in case
+  boot_path = "#{service_dir}/config/boot.rb"
+  if File.exist?(boot_path)
+    clean_boot_rb = <<~RUBY
+      ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
+      require "bundler/setup" # Set up gems listed in the Gemfile.
+    RUBY
+    File.write(boot_path, clean_boot_rb)
+  end
+end
+
+
+    def start_server
+      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 running at http://localhost:#{service['port']}"
+      end
+
+      puts "🏭 Service registry loaded from config/regolith.yml"
+      puts ""
+
+      exec("docker-compose up --build")
+    end
+
+    def open_console(service_name)
+      unless service_name
+        puts "❌ Error: Service name required"
+        puts "Usage: regolith console <service_name>"
+        exit 1
+      end
+
+      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("docker-compose exec #{service_name} rails console")
+    end
+
+    def load_regolith_config
+      return { 'services' => {} } unless File.exist?('config/regolith.yml')
+      config = YAML.load_file('config/regolith.yml') || {}
+      config['services'] ||= {}
+      config
+    end
+
+    def save_regolith_config(config)
+      FileUtils.mkdir_p('config')
+      File.write('config/regolith.yml', YAML.dump(config))
+    end
+
+    def update_docker_compose(config)
+      docker_compose = generate_docker_compose(config['name'], config['services'])
+      File.write('docker-compose.yml', docker_compose)
+    end
+
+    def generate_docker_compose(app_name, services = {})
+      template = <<~YAML
+        version: '3.8'
+
+        services:
+          db:
+            image: postgres:14
+            environment:
+              POSTGRES_DB: #{app_name}_development
+              POSTGRES_USER: postgres
+              POSTGRES_PASSWORD: password
+            ports:
+              - "5432:5432"
+            volumes:
+              - postgres_data:/var/lib/postgresql/data
+
+        <% services.each do |name, service| %>
+          <%= name %>:
+            build: <%= service['root'] %>
+            ports:
+              - "<%= service['port'] %>:3000"
+            depends_on:
+              - db
+            environment:
+              DATABASE_URL: postgres://postgres:password@db:5432/<%= app_name %>_development
+              REGOLITH_SERVICE_NAME: <%= name %>
+              REGOLITH_SERVICE_PORT: <%= service['port'] %>
+            volumes:
+              - <%= service['root'] %>:/app
+            command: bash -c "rm -f tmp/pids/server.pid && bundle install && rails server -b 0.0.0.0"
+        <% end %>
+
+        volumes:
+          postgres_data:
+      YAML
+
+      ERB.new(template).result(binding)
+    end
+
+    def generate_dockerfile
+      <<~DOCKERFILE
+        FROM ruby:3.1
+
+        WORKDIR /app
+
+        RUN apt-get update -qq && apt-get install -y nodejs postgresql-client libyaml-dev libsqlite3-dev build-essential pkg-config
+
+        COPY . .
+
+        RUN bundle install
+
+        EXPOSE 3000
+
+        CMD ["rails", "server", "-b", "0.0.0.0"]
+      DOCKERFILE
+    end
+
+    def generate_regolith_initializer(service_name)
+      <<~RUBY
+        # Regolith service configuration
+        Rails.application.configure do
+          config.regolith = OpenStruct.new(
+            service_name: '#{service_name}',
+            service_registry: Rails.root.join('../../config/regolith.yml')
+          )
+        end
+
+        if File.exist?(Rails.application.config.regolith.service_registry)
+          REGOLITH_SERVICES = YAML.load_file(Rails.application.config.regolith.service_registry)['services'] || {}
+        else
+          REGOLITH_SERVICES = {}
+        end
+      RUBY
+    end
+
+    def generate_makefile
+      <<~MAKEFILE
+        .PHONY: server console build clean
+
+        server:
+        	regolith server
+
+        console:
+        	regolith console
+
+        build:
+        	docker-compose build
+
+        clean:
+        	docker-compose down -v
+        	docker system prune -f
+      MAKEFILE
+    end
+
+    def generate_regolith_shim
+      <<~RUBY
+        #!/usr/bin/env ruby
+        exec("regolith", *ARGV)
+      RUBY
+    end
+
+    def generate_regolith_gemspec
+      <<~GEMSPEC
+        # -*- encoding: utf-8 -*-
+        lib = File.expand_path('../lib', __FILE__)
+        $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+        require 'regolith/version'
+
+        Gem::Specification.new do |gem|
+          gem.name          = "regolith"
+          gem.version       = Regolith::VERSION
+          gem.authors       = ["Regolith Team"]
+          gem.email         = ["team@regolith.dev"]
+          gem.description   = %q{Microservices framework for Ruby}
+          gem.summary       = %q{Build microservices with Ruby and Rails}
+          gem.homepage      = "https://github.com/regolith/regolith"
+
+          gem.files         = Dir['lib/**/*'] + ['README.md']
+          gem.executables   = ['regolith']
+          gem.test_files    = []
+          gem.require_paths = ["lib"]
+
+          gem.add_dependency "rails", ">= 7.0"
+          gem.add_dependency "rack-cors"
+        end
+      GEMSPEC
+    end
+
+    def show_help
+      puts <<~HELP
+        Regolith #{Regolith::VERSION} - Microservices framework
+
+        USAGE:
+            regolith <command> [options]
+
+        COMMANDS:
+            new <app_name>              Create a new Regolith application
+            generate service <name>     Generate a new microservice
+            server                      Start all services with Docker Compose
+            console <service_name>      Open Rails console for a service
+            version                     Show version information
+
+        EXAMPLES:
+            regolith new observatory
+            regolith generate service telescope
+            regolith generate service records
+            regolith server
+            regolith console telescope
+
+        Get started:
+            regolith new myapp
+            cd myapp
+            regolith generate service users
+            regolith server
+      HELP
+    end
+  end
+end

data/lib/regolith/regolith_association.rb

@@ -0,0 +1,74 @@
+# lib/regolith/regolith_association.rb
+module Regolith
+  class RegolithAssociation
+    def initialize(parent_record, association_name, service, type, foreign_key_value = nil)
+      @parent_record = parent_record
+      @association_name = association_name
+      @service = service
+      @type = type
+      @foreign_key_value = foreign_key_value
+      @loaded_records = nil
+    end
+
+    def create!(attributes = {})
+      case @type
+      when :has_many
+        # For has_many, set the foreign key to parent's id
+        foreign_key = "#{@parent_record.class.name.underscore}_id"
+        attributes[foreign_key] = @parent_record.id
+        
+        # Create in the target service
+        target_class = @association_name.to_s.singularize.camelize.constantize
+        target_class.create(attributes)
+      end
+    end
+
+    def first
+      case @type
+      when :belongs_to
+        target_class = @association_name.to_s.camelize.constantize
+        target_class.find(@foreign_key_value)
+      when :has_many
+        all.first
+      end
+    end
+
+    def all
+      load_records unless @loaded_records
+      @loaded_records
+    end
+
+    def method_missing(method_name, *args, &block)
+      all.send(method_name, *args, &block)
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      all.respond_to?(method_name, include_private) || super
+    end
+
+    private
+
+    def load_records
+      case @type
+      when :has_many
+        # Query the target service for records that belong to this parent
+        foreign_key = "#{@parent_record.class.name.underscore}_id"
+        target_service = @service
+        resource_name = @association_name.to_s
+        
+        response = ServiceClient.get(
+          target_service,
+          "#{resource_name}?#{foreign_key}=#{@parent_record.id}"
+        )
+        
+        if response.code == '200'
+          data = JSON.parse(response.body)
+          target_class = @association_name.to_s.singularize.camelize.constantize
+          @loaded_records = data.map { |attrs| target_class.new(attrs) }
+        else
+          @loaded_records = []
+        end
+      end
+    end
+  end
+end

data/lib/regolith/regolith_record.rb

@@ -0,0 +1,140 @@
+# lib/regolith/regolith_record.rb
+module Regolith
+  class RegolithRecord
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+    include ActiveModel::Serialization
+
+    class_attribute :service_name, :resource_name, :primary_key
+    self.primary_key = :id
+
+    def self.inherited(subclass)
+      super
+      # Auto-detect service from class name or allow explicit setting
+      subclass.resource_name = subclass.name.underscore
+    end
+
+    def self.service(service_name)
+      self.service_name = service_name
+    end
+
+    def self.has_many(association_name, options = {})
+      service = options[:service]
+      
+      define_method(association_name) do
+        RegolithAssociation.new(
+          self,
+          association_name,
+          service,
+          :has_many
+        )
+      end
+    end
+
+    def self.belongs_to(association_name, options = {})
+      service = options[:service]
+      foreign_key = options[:foreign_key] || "#{association_name}_id"
+      
+      # Add the foreign key attribute
+      attribute foreign_key, :integer
+      
+      define_method(association_name) do
+        foreign_key_value = send(foreign_key)
+        return nil unless foreign_key_value
+        
+        RegolithAssociation.new(
+          self,
+          association_name,
+          service,
+          :belongs_to,
+          foreign_key_value
+        ).first
+      end
+    end
+
+    def self.find(id)
+      response = ServiceClient.get(service_name, "#{resource_name}/#{id}")
+      if response.code == '200'
+        new(JSON.parse(response.body))
+      else
+        raise ActiveRecord::RecordNotFound, "Couldn't find #{name} with 'id'=#{id}"
+      end
+    end
+
+    def self.all
+      response = ServiceClient.get(service_name, resource_name)
+      if response.code == '200'
+        JSON.parse(response.body).map { |attrs| new(attrs) }
+      else
+        []
+      end
+    end
+
+    def self.create(attributes = {})
+      instance = new(attributes)
+      instance.save
+      instance
+    end
+
+    def self.create!(attributes = {})
+      instance = create(attributes)
+      raise "Record invalid" unless instance.persisted?
+      instance
+    end
+
+    def save
+      if persisted?
+        update
+      else
+        create
+      end
+    end
+
+    def create
+      response = ServiceClient.post(
+        self.class.service_name, 
+        self.class.resource_name,
+        attributes.to_json
+      )
+      
+      if response.code.to_i.between?(200, 299)
+        data = JSON.parse(response.body)
+        data.each { |key, value| send("#{key}=", value) if respond_to?("#{key}=") }
+        true
+      else
+        false
+      end
+    end
+
+    def update
+      response = ServiceClient.put(
+        self.class.service_name,
+        "#{self.class.resource_name}/#{id}",
+        attributes.to_json
+      )
+      
+      response.code.to_i.between?(200, 299)
+    end
+
+    def destroy
+      response = ServiceClient.delete(
+        self.class.service_name,
+        "#{self.class.resource_name}/#{id}"
+      )
+      
+      response.code.to_i.between?(200, 299)
+    end
+
+    def persisted?
+      id.present?
+    end
+
+    def id
+      send(self.class.primary_key) if respond_to?(self.class.primary_key)
+    end
+
+    def id=(value)
+      send("#{self.class.primary_key}=", value) if respond_to?("#{self.class.primary_key}=")
+    end
+  end
+end

data/lib/regolith/service_client.rb

@@ -0,0 +1,68 @@
+# lib/regolith/service_client.rb
+module Regolith
+  class ServiceClient
+    class << self
+      def get(service_name, path)
+        make_request(service_name, :get, path)
+      end
+
+      def post(service_name, path, body = nil)
+        make_request(service_name, :post, path, body)
+      end
+
+      def put(service_name, path, body = nil)
+        make_request(service_name, :put, path, body)
+      end
+
+      def delete(service_name, path)
+        make_request(service_name, :delete, path)
+      end
+
+      private
+
+      def make_request(service_name, method, path, body = nil)
+        service_config = Regolith.service_registry[service_name.to_s]
+        
+        unless service_config
+          raise "Service '#{service_name}' not found in registry"
+        end
+
+        # In Docker Compose, services can be reached by service name
+        # In development, use localhost with the mapped port
+        host = in_docker? ? service_name.to_s : 'localhost'
+        port = in_docker? ? 3000 : service_config['port']
+        
+        uri = URI("http://#{host}:#{port}/#{path}")
+        
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.read_timeout = Regolith.configuration.timeout
+        
+        case method
+        when :get
+          request = Net::HTTP::Get.new(uri)
+        when :post
+          request = Net::HTTP::Post.new(uri)
+          request.body = body if body
+          request['Content-Type'] = 'application/json'
+        when :put
+          request = Net::HTTP::Put.new(uri)
+          request.body = body if body
+          request['Content-Type'] = 'application/json'
+        when :delete
+          request = Net::HTTP::Delete.new(uri)
+        end
+
+        begin
+          http.request(request)
+        rescue => e
+          # Return a mock response for connection errors
+          OpenStruct.new(code: '500', body: { error: e.message }.to_json)
+        end
+      end
+
+      def in_docker?
+        File.exist?('/.dockerenv') || ENV['REGOLITH_SERVICE_NAME'].present?
+      end
+    end
+  end
+end

data/lib/regolith/version.rb

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

data/lib/regolith.rb

@@ -0,0 +1,51 @@
+# lib/regolith.rb
+require 'active_support/all'
+require 'active_model'
+require 'net/http'
+require 'json'
+require 'yaml'
+
+require_relative 'regolith/version'
+require_relative 'regolith/service_client'
+require_relative 'regolith/regolith_association'
+require_relative 'regolith/regolith_record'
+require_relative 'regolith/cli'
+
+module Regolith
+  class << self
+    def configure
+      yield(configuration)
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def service_registry
+      @service_registry ||= load_service_registry
+    end
+
+    private
+
+    def load_service_registry
+      if defined?(Rails) && Rails.application.config.respond_to?(:regolith)
+        registry_path = Rails.application.config.regolith.service_registry
+        if File.exist?(registry_path)
+          YAML.load_file(registry_path)['services'] || {}
+        else
+          {}
+        end
+      else
+        defined?(REGOLITH_SERVICES) ? REGOLITH_SERVICES : {}
+      end
+    end
+  end
+
+  class Configuration
+    attr_accessor :service_name, :service_port, :timeout
+
+    def initialize
+      @timeout = 30
+    end
+  end
+end

data/regolith.gemspec

@@ -0,0 +1,37 @@
+# regolith.gemspec
+require_relative 'lib/regolith/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "regolith"
+  spec.version       = Regolith::VERSION
+  spec.authors       = ["Regolith Team"]
+  spec.email         = ["team@regolith.dev"]
+
+  spec.summary       = "Rails for distributed systems"
+  spec.description   = "Regolith provides seamless inter-service communication and orchestration for Ruby microservices"
+  spec.homepage      = "https://github.com/regolith/regolith"
+  spec.license       = "MIT"
+
+  spec.required_ruby_version = ">= 2.7.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/regolith/regolith"
+  spec.metadata["changelog_uri"] = "https://github.com/regolith/regolith/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    Dir['lib/**/*', 'bin/*', '*.md', '*.txt', 'LICENSE*', 'regolith.gemspec']
+  end
+
+  spec.bindir        = "bin"
+  spec.executables   = ["regolith"]
+  spec.require_paths = ["lib"]
+
+  # Dependencies
+  spec.add_dependency "activesupport", ">= 6.0"
+  spec.add_dependency "activemodel", ">= 6.0"
+
+  # Development dependencies
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: regolith
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Regolith Team
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-07-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: Regolith provides seamless inter-service communication and orchestration
+  for Ruby microservices
+email:
+- team@regolith.dev
+executables:
+- regolith
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- bin/regolith
+- lib/regolith.rb
+- lib/regolith/cli.rb
+- lib/regolith/regolith_association.rb
+- lib/regolith/regolith_record.rb
+- lib/regolith/service_client.rb
+- lib/regolith/version.rb
+- regolith.gemspec
+homepage: https://github.com/regolith/regolith
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/regolith/regolith
+  source_code_uri: https://github.com/regolith/regolith
+  changelog_uri: https://github.com/regolith/regolith/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.15
+signing_key:
+specification_version: 4
+summary: Rails for distributed systems
+test_files: []