agentcode 0.9.0

data/lib/agentcode/commands/install_command.rb

@@ -0,0 +1,441 @@
+# frozen_string_literal: true
+
+require "agentcode/commands/base_command"
+
+module AgentCode
+  module Commands
+    # Interactive setup wizard — mirrors Laravel `php artisan agentcode:install` exactly.
+    #
+    # Usage: rails agentcode:install
+    class InstallCommand < BaseCommand
+      def perform
+        print_banner
+
+        say ""
+        say "+ AgentCode :: Install :: Let's build something great +", :cyan
+        say ""
+
+        features = multi_select("Which features would you like to configure?") do |menu|
+          menu.default 1
+          menu.choice "Publish config & routes", "publish"
+          menu.choice "Multi-tenant support (Organizations, Roles)", "multi_tenant"
+          menu.choice "Audit trail (change logging)", "audit_trail"
+        end
+
+        test_framework = select("Which test framework do you use?") do |menu|
+          menu.default 1
+          menu.choice "RSpec", "rspec"
+          menu.choice "Minitest", "minitest"
+        end
+
+        identifier_column = "id"
+        roles = ["admin"]
+
+        if features.include?("multi_tenant")
+          identifier_column = ask("What column should be used to identify organizations?", default: "id")
+
+          roles_input = ask("What roles should your app have?", default: "admin, editor, viewer")
+          roles = (["admin"] + roles_input.split(",").map(&:strip)).uniq
+        end
+
+        say ""
+
+        if features.include?("publish")
+          task("Publishing config") { publish_config(test_framework) }
+          task("Publishing routes") { publish_routes }
+          task("Creating blueprint directory") { create_blueprint_directory }
+        end
+
+        if features.include?("multi_tenant")
+          task("Creating migrations") { create_multi_tenant_migrations }
+          task("Creating models") { create_multi_tenant_models(roles) }
+          task("Creating factories") { create_factories }
+          task("Creating policies") { create_policies }
+          task("Updating config") { update_config(identifier_column) }
+          task("Creating seeders") { create_seeders(roles) }
+        end
+
+        if features.include?("audit_trail")
+          task("Creating audit trail migration") { create_audit_trail_migration }
+        end
+
+        say ""
+        run_post_install_steps(features)
+
+        install_ai_skill
+
+        say ""
+        say "AgentCode installed successfully!", :green
+        say ""
+
+        print_next_steps(features)
+      end
+
+      private
+
+      # ----------------------------------------------------------------
+      # Banner
+      # ----------------------------------------------------------------
+
+      def print_banner
+        say ""
+
+        lines = [
+          "   █████╗  ██████╗ ███████╗███╗   ██╗████████╗ ██████╗ ██████╗ ██████╗ ███████╗",
+          "  ██╔══██╗██╔════╝ ██╔════╝████╗  ██║╚══██╔══╝██╔════╝██╔═══██╗██╔══██╗██╔════╝",
+          "  ███████║██║  ███╗█████╗  ██╔██╗ ██║   ██║   ██║     ██║   ██║██║  ██║█████╗  ",
+          "  ██╔══██║██║   ██║██╔══╝  ██║╚██╗██║   ██║   ██║     ██║   ██║██║  ██║██╔══╝  ",
+          "  ██║  ██║╚██████╔╝███████╗██║ ╚████║   ██║   ╚██████╗╚██████╔╝██████╔╝███████╗",
+          "  ╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚═╝  ╚═══╝   ╚═╝    ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝"
+        ]
+
+        gradient = [
+          [0, 255, 255],
+          [0, 230, 200],
+          [100, 220, 100],
+          [255, 220, 50],
+          [255, 170, 30],
+          [255, 120, 0]
+        ]
+
+        lines.each_with_index do |text, i|
+          r, g, b = gradient[i]
+          $stdout.puts "\033[38;2;#{r};#{g};#{b}m#{text}\033[0m"
+        end
+      end
+
+      # ----------------------------------------------------------------
+      # Publish
+      # ----------------------------------------------------------------
+
+      def publish_config(test_framework)
+        template_path = File.expand_path("../../templates/agentcode.rb", __FILE__)
+        dest_path = Rails.root.join("config/initializers/agentcode.rb")
+
+        FileUtils.mkdir_p(File.dirname(dest_path))
+
+        content = File.read(template_path)
+        content = content.gsub('test_framework: "rspec"', "test_framework: \"#{test_framework}\"")
+        File.write(dest_path, content)
+      end
+
+      def publish_routes
+        template_path = File.expand_path("../../templates/routes.rb", __FILE__)
+        dest_path = Rails.root.join("config/routes/agentcode.rb")
+
+        FileUtils.mkdir_p(File.dirname(dest_path))
+        FileUtils.cp(template_path, dest_path)
+      end
+
+      # ----------------------------------------------------------------
+      # Multi-tenant
+      # ----------------------------------------------------------------
+
+      def create_multi_tenant_migrations
+        timestamp = Time.current.strftime("%Y%m%d%H%M%S")
+        migrations_path = Rails.root.join("db/migrate")
+        FileUtils.mkdir_p(migrations_path)
+
+        templates_dir = File.expand_path("../../templates/multi_tenant/migrations", __FILE__)
+
+        {
+          "create_users" => "#{timestamp}00",
+          "create_organizations" => "#{timestamp}01",
+          "create_roles" => "#{timestamp}02",
+          "create_user_roles" => "#{timestamp}03"
+        }.each do |name, ts|
+          template = File.join(templates_dir, "#{name}.rb.erb")
+          next unless File.exist?(template)
+
+          content = ERB.new(File.read(template), trim_mode: "-").result(binding)
+          File.write(migrations_path.join("#{ts}_#{name}.rb"), content)
+        end
+      end
+
+      def create_multi_tenant_models(roles)
+        models_path = Rails.root.join("app/models")
+        FileUtils.mkdir_p(models_path)
+
+        templates_dir = File.expand_path("../../templates/multi_tenant/models", __FILE__)
+
+        %w[user organization role user_role].each do |model|
+          template = File.join(templates_dir, "#{model}.rb.erb")
+          next unless File.exist?(template)
+
+          content = ERB.new(File.read(template), trim_mode: "-").result_with_hash(roles: roles)
+          File.write(models_path.join("#{model}.rb"), content)
+        end
+      end
+
+      def create_factories
+        factories_path = Rails.root.join("spec/factories")
+        FileUtils.mkdir_p(factories_path)
+
+        templates_dir = File.expand_path("../../templates/multi_tenant/factories", __FILE__)
+
+        %w[users organizations roles user_roles].each do |factory|
+          template = File.join(templates_dir, "#{factory}.rb.erb")
+          next unless File.exist?(template)
+
+          content = ERB.new(File.read(template), trim_mode: "-").result(binding)
+          File.write(factories_path.join("#{factory}.rb"), content)
+        end
+      end
+
+      def create_policies
+        policies_path = Rails.root.join("app/policies")
+        FileUtils.mkdir_p(policies_path)
+
+        templates_dir = File.expand_path("../../templates/multi_tenant/policies", __FILE__)
+
+        %w[organization_policy role_policy].each do |policy|
+          template = File.join(templates_dir, "#{policy}.rb.erb")
+          next unless File.exist?(template)
+
+          content = ERB.new(File.read(template), trim_mode: "-").result(binding)
+          File.write(policies_path.join("#{policy}.rb"), content)
+        end
+      end
+
+      def update_config(identifier_column)
+        config_path = Rails.root.join("config/initializers/agentcode.rb")
+        return unless File.exist?(config_path)
+
+        content = File.read(config_path)
+
+        # Update organization_identifier_column
+        content = content.gsub(
+          'organization_identifier_column: "id"',
+          "organization_identifier_column: \"#{identifier_column}\""
+        )
+
+        # Add organization and role models
+        unless content.include?("config.model :organizations")
+          content = content.gsub(
+            "# config.model :posts, 'Post'",
+            "config.model :organizations, 'Organization'\n  config.model :roles, 'Role'\n  # config.model :posts, 'Post'"
+          )
+        end
+
+        # Add tenant route group
+        unless content.include?("config.route_group :tenant")
+          content = content.gsub(
+            "# config.route_group :default",
+            "config.route_group :tenant, prefix: \":organization\", middleware: [AgentCode::Middleware::ResolveOrganizationFromRoute], models: :all\n  # config.route_group :default"
+          )
+        end
+
+        File.write(config_path, content)
+      end
+
+      def create_seeders(roles)
+        seeders_path = Rails.root.join("db/seeds")
+        FileUtils.mkdir_p(seeders_path)
+
+        templates_dir = File.expand_path("../../templates/multi_tenant/seeders", __FILE__)
+
+        template = File.join(templates_dir, "role_seeder.rb.erb")
+        if File.exist?(template)
+          content = ERB.new(File.read(template), trim_mode: "-").result_with_hash(roles: roles)
+          File.write(seeders_path.join("role_seeder.rb"), content)
+        end
+
+        template = File.join(templates_dir, "organization_seeder.rb.erb")
+        if File.exist?(template)
+          content = ERB.new(File.read(template), trim_mode: "-").result(binding)
+          File.write(seeders_path.join("organization_seeder.rb"), content)
+        end
+      end
+
+      # ----------------------------------------------------------------
+      # Audit trail
+      # ----------------------------------------------------------------
+
+      def create_audit_trail_migration
+        timestamp = Time.current.strftime("%Y%m%d%H%M%S")
+        migrations_path = Rails.root.join("db/migrate")
+        FileUtils.mkdir_p(migrations_path)
+
+        # Check for existing
+        existing = Dir.glob(migrations_path.join("*_create_audit_logs.rb"))
+        return unless existing.empty?
+
+        template = File.expand_path("../../templates/audit_trail/create_audit_logs.rb.erb", __FILE__)
+        if File.exist?(template)
+          content = ERB.new(File.read(template), trim_mode: "-").result(binding)
+          File.write(migrations_path.join("#{timestamp}_create_audit_logs.rb"), content)
+        end
+      end
+
+      # ----------------------------------------------------------------
+      # Post-install
+      # ----------------------------------------------------------------
+
+      def run_post_install_steps(features)
+        has_migrations = features.include?("multi_tenant") || features.include?("audit_trail")
+
+        if has_migrations
+          if yes?("Would you like to run migrations now?")
+            task("Running migrations") { system("rails db:migrate") }
+          end
+        end
+
+        if features.include?("multi_tenant")
+          if yes?("Would you like to seed the database?")
+            task("Seeding database") { system("rails db:seed") }
+          end
+        end
+      end
+
+      def print_next_steps(features)
+        say "Remaining steps:", :yellow
+        say ""
+
+        step = 1
+
+        if features.include?("audit_trail")
+          say "  #{step}. Add AgentCode::HasAuditTrail concern to your models:"
+          say "     include AgentCode::HasAuditTrail"
+          step += 1
+        end
+
+        if features.include?("multi_tenant")
+          say "  #{step}. Add AgentCode::HasPermissions concern to your User model:"
+          say "     include AgentCode::HasPermissions"
+          step += 1
+        end
+
+        say ""
+      end
+
+      # ----------------------------------------------------------------
+      # Blueprint directory
+      # ----------------------------------------------------------------
+
+      def create_blueprint_directory
+        bp_dir = Rails.root.join(".agentcode", "blueprints")
+        FileUtils.mkdir_p(bp_dir)
+
+        guide_path = bp_dir.join("..", "BLUEPRINT.md")
+        unless File.exist?(guide_path)
+          File.write(guide_path, blueprint_guide_content)
+        end
+      end
+
+      def blueprint_guide_content
+        <<~MD
+          # AgentCode Blueprint — AI Guide
+
+          Use this file to teach AI assistants how to generate valid YAML blueprint files.
+
+          ## Quick Start
+
+          1. Create `_roles.yaml` in `.agentcode/blueprints/` with your role definitions
+          2. Create `{model_slug}.yaml` for each model
+          3. Run `rails agentcode:blueprint` to generate all files
+
+          ## Roles Format
+
+          ```yaml
+          roles:
+            owner:
+              name: Owner
+              description: "Full access"
+            viewer:
+              name: Viewer
+              description: "Read-only"
+          ```
+
+          ## Model Format
+
+          ```yaml
+          model: Contract
+          slug: contracts
+
+          options:
+            belongs_to_organization: true
+            soft_deletes: true
+
+          columns:
+            title:
+              type: string
+              filterable: true
+
+          permissions:
+            owner:
+              actions: [index, show, store, update, destroy]
+              show_fields: "*"
+              create_fields: "*"
+              update_fields: "*"
+          ```
+
+          ## Valid Column Types
+          string, text, integer, bigInteger, boolean, date, datetime, timestamp, decimal, float, json, uuid, foreignId
+
+          ## Valid Actions
+          index, show, store, update, destroy, trashed, restore, forceDelete
+        MD
+      end
+
+      # ----------------------------------------------------------------
+      # AI Skill
+      # ----------------------------------------------------------------
+
+      def install_ai_skill
+        say ""
+
+        ai_tools = multi_select("Install AgentCode AI Skill for which tools? (select none to skip)") do |menu|
+          menu.default 1
+          menu.choice "Claude Code (.claude/skills/agentcode/)", "claude"
+          menu.choice "Cursor (.cursor/rules/agentcode/)", "cursor"
+          menu.choice "AI Directory (.ai/skills/agentcode/)", "ai"
+        end
+
+        return if ai_tools.empty?
+
+        url = "https://startsoft-dev.github.io/agentcode-docs/skills/rails/SKILL.md"
+
+        destinations = {
+          "claude" => ".claude/skills/agentcode/SKILL.md",
+          "cursor" => ".cursor/rules/agentcode/SKILL.md",
+          "ai" => ".ai/skills/agentcode/SKILL.md"
+        }
+
+        # Download once
+        require "net/http"
+        require "uri"
+
+        uri = URI.parse(url)
+        response = Net::HTTP.get_response(uri)
+
+        # Follow redirect if needed
+        if response.is_a?(Net::HTTPRedirection)
+          uri = URI.parse(response["location"])
+          response = Net::HTTP.get_response(uri)
+        end
+
+        unless response.is_a?(Net::HTTPSuccess)
+          say "  Could not download skill file. You can manually download it from:", :yellow
+          say "  #{url}"
+          return
+        end
+
+        content = response.body
+
+        ai_tools.each do |tool|
+          dest_file = Rails.root.join(destinations[tool])
+
+          task("Installing skill for #{tool}") do
+            FileUtils.mkdir_p(File.dirname(dest_file))
+            File.write(dest_file, content)
+          end
+        end
+
+        say "  AI Skill installed successfully.", :green
+      rescue StandardError => e
+        say "  Could not download skill file (#{e.message}). You can manually download it from:", :yellow
+        say "  #{url}"
+      end
+    end
+  end
+end

data/lib/agentcode/commands/invitation_link_command.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "agentcode/commands/base_command"
+
+module AgentCode
+  module Commands
+    # Generate an invitation link for testing — mirrors Laravel `php artisan invitation:link` exactly.
+    #
+    # Usage: rails invitation:link EMAIL ORG [--role=ROLE] [--create]
+    class InvitationLinkCommand < BaseCommand
+      attr_accessor :email, :organization_identifier, :options
+
+      def initialize
+        super
+        @options = { role: nil, create: false }
+      end
+
+      def perform(email = @email, organization_identifier = @organization_identifier)
+        role_identifier = options[:role]
+        should_create = options[:create]
+
+        # Find organization
+        identifier_column = AgentCode.config.multi_tenant[:organization_identifier_column] || "slug"
+
+        org_class = "Organization".safe_constantize
+        unless org_class
+          say "Organization model not found.", :red
+          return
+        end
+
+        organization = org_class.find_by(identifier_column => organization_identifier)
+
+        unless organization
+          say "Organization '#{organization_identifier}' not found.", :red
+          return
+        end
+
+        # Find or create invitation
+        invitation = OrganizationInvitation
+                       .where(email: email, organization_id: organization.id, status: "pending")
+                       .first
+
+        if !invitation && !should_create
+          say "No pending invitation found for '#{email}' in organization '#{organization.name}'.", :red
+          say "Use --create flag to create a new invitation."
+          return
+        end
+
+        if !invitation && should_create
+          unless role_identifier
+            say "Role is required when creating a new invitation. Use --role option.", :red
+            return
+          end
+
+          role_class = "Role".safe_constantize
+          unless role_class
+            say "Role model not found.", :red
+            return
+          end
+
+          role = if role_identifier.match?(/\A\d+\z/)
+                   role_class.find_by(id: role_identifier)
+                 else
+                   role_class.find_by(slug: role_identifier)
+                 end
+
+          unless role
+            say "Role '#{role_identifier}' not found.", :red
+            return
+          end
+
+          user_class = "User".safe_constantize
+          invited_by = user_class&.first
+
+          unless invited_by
+            say "No user found to assign as 'invited_by'. Please create a user first.", :red
+            return
+          end
+
+          invitation = OrganizationInvitation.create!(
+            organization_id: organization.id,
+            email: email,
+            role_id: role.id,
+            invited_by: invited_by.id
+          )
+
+          say "Created new invitation for #{email}.", :green
+        end
+
+        # Build the invitation URL
+        frontend_url = ENV.fetch("FRONTEND_URL", "http://localhost:5173")
+        url = "#{frontend_url}/accept-invitation?token=#{invitation.token}"
+
+        say ""
+        say "Invitation link for #{email}:", :green
+        say url
+        say ""
+        say "Token: #{invitation.token}"
+        say "Organization: #{organization.name} (#{organization.try(:slug) || organization.id})"
+        say "Role: #{invitation.role&.name}" if invitation.respond_to?(:role) && invitation.role
+        say "Status: #{invitation.status}"
+        say "Expires: #{invitation.expires_at&.strftime('%Y-%m-%d %H:%M:%S')}" if invitation.expires_at
+        say ""
+      end
+    end
+  end
+end

data/lib/agentcode/concerns/belongs_to_organization.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module AgentCode
+  # Multi-tenant scoping concern.
+  # Mirrors the Laravel BelongsToOrganization trait.
+  #
+  # Usage:
+  #   class Post < ApplicationRecord
+  #     include AgentCode::BelongsToOrganization
+  #   end
+  #
+  # For nested ownership (model doesn't have organization_id directly),
+  # the path is auto-detected from belongs_to associations.
+  module BelongsToOrganization
+    extend ActiveSupport::Concern
+
+    included do
+      belongs_to :organization
+
+      # Auto-set organization_id on creation from request context
+      before_create :set_organization_from_context
+
+      # Default scope to filter by current organization
+      default_scope lambda {
+        if defined?(RequestStore) && RequestStore.store[:agentcode_organization]
+          where(organization_id: RequestStore.store[:agentcode_organization].id)
+        else
+          all
+        end
+      }
+    end
+
+    class_methods do
+      def for_organization(organization)
+        where(organization_id: organization.id)
+      end
+    end
+
+    private
+
+    def set_organization_from_context
+      return if organization_id.present?
+      return unless defined?(RequestStore)
+
+      org = RequestStore.store[:agentcode_organization]
+      self.organization_id = org.id if org
+    end
+  end
+end

data/lib/agentcode/concerns/has_agentcode.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module AgentCode
+  # Main model concern that provides the DSL for configuring query builder options.
+  #
+  # Usage:
+  #   class Post < ApplicationRecord
+  #     include AgentCode::HasAgentCode
+  #
+  #     agentcode_filters :status, :user_id
+  #     agentcode_sorts :title, :created_at
+  #     agentcode_default_sort '-created_at'
+  #     agentcode_includes :user, :comments
+  #     agentcode_fields :id, :title, :status, :created_at
+  #     agentcode_search :title, :content, 'user.name'
+  #     agentcode_per_page 25
+  #     agentcode_pagination_enabled true
+  #     agentcode_middleware 'throttle:60,1'
+  #     agentcode_middleware_actions store: ['verified'], update: ['verified']
+  #     agentcode_except_actions :destroy
+  #   end
+  module HasAgentCode
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :allowed_filters, default: []
+      class_attribute :allowed_sorts, default: []
+      class_attribute :default_sort_field, default: nil
+      class_attribute :allowed_includes, default: []
+      class_attribute :allowed_fields, default: []
+      class_attribute :allowed_search, default: []
+      class_attribute :agentcode_per_page_count, default: 25
+      class_attribute :pagination_enabled, default: false
+      class_attribute :agentcode_model_middleware, default: []
+      class_attribute :agentcode_middleware_actions_map, default: {}
+      class_attribute :agentcode_except_actions_list, default: []
+      class_attribute :agentcode_owner_path, default: nil
+    end
+
+    class_methods do
+      def agentcode_filters(*fields)
+        self.allowed_filters = fields.map(&:to_s)
+      end
+
+      def agentcode_sorts(*fields)
+        self.allowed_sorts = fields.map(&:to_s)
+      end
+
+      def agentcode_default_sort(field)
+        self.default_sort_field = field.to_s
+      end
+
+      def agentcode_includes(*relations)
+        self.allowed_includes = relations.map(&:to_s)
+      end
+
+      def agentcode_fields(*fields)
+        self.allowed_fields = fields.map(&:to_s)
+      end
+
+      def agentcode_search(*fields)
+        self.allowed_search = fields.map(&:to_s)
+      end
+
+      def agentcode_per_page(count)
+        self.agentcode_per_page_count = count
+      end
+
+      def agentcode_pagination_enabled(enabled = true)
+        self.pagination_enabled = enabled
+      end
+
+      def agentcode_middleware(*middleware)
+        self.agentcode_model_middleware = middleware.map(&:to_s)
+      end
+
+      def agentcode_middleware_actions(actions_hash)
+        self.agentcode_middleware_actions_map = actions_hash.transform_keys(&:to_s)
+      end
+
+      def agentcode_except_actions(*actions)
+        self.agentcode_except_actions_list = actions.map(&:to_s)
+      end
+
+      # Check if model uses soft deletes (Discard gem)
+      def uses_soft_deletes?
+        column_names.include?("discarded_at") || column_names.include?("deleted_at")
+      rescue ActiveRecord::StatementInvalid
+        false
+      end
+    end
+  end
+end