ask-rails 0.3.0 → 0.11.0

data/lib/ask/rails/tools/schema_graph.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module Ask
+  module Rails
+    module Tools
+      class SchemaGraph < Ask::Rails::Tool
+        description "Return the full application schema graph — all models, tables, columns with types, " \
+                     "associations (belongs_to, has_many, has_one, HABTM, through), validations, indexes, " \
+                     "and polymorphic relationships. One call gives the agent a complete mental model " \
+                     "of the application's data layer."
+
+        param :detail, type: :string, desc: "Detail level: 'all' (default), 'models', 'associations', 'tables'", required: false
+
+        TABLE_EXCLUSIONS = %w[schema_migrations ar_internal_metadata].freeze
+
+        def execute(detail: "all")
+          models = discover_ar_models
+
+          result = {
+            summary: {
+              model_count: models.size,
+              table_count: models.map { |m| m.table_name }.uniq.size,
+              association_count: models.sum { |m| m.reflect_on_all_associations.size }
+            },
+            models: %w[all models].include?(detail) ? build_model_details(models, detail) : nil,
+            associations: %w[all associations].include?(detail) ? build_association_graph(models) : nil,
+            tables: %w[all tables].include?(detail) ? build_table_details(detail) : nil
+          }
+
+          result
+        end
+
+        private
+
+        def discover_ar_models
+          if defined?(::Rails::Application) && ::Rails.application
+            ::Rails.application.eager_load! rescue nil
+          end
+          ActiveRecord::Base.descendants.reject do |klass|
+            klass.abstract_class? ||
+            klass.name.nil? ||
+            TABLE_EXCLUSIONS.include?(klass.table_name) ||
+            klass.name.start_with?("ActiveRecord::", "ActiveStorage::", "ActionText::")
+          end.sort_by(&:name)
+        rescue StandardError
+          []
+        end
+
+        def build_model_details(models, detail)
+          models.filter_map do |klass|
+            name = klass.name rescue nil
+            next nil unless name
+
+            entry = {
+              name: name,
+              table_name: klass.table_name,
+              primary_key: safe_primary_key(klass)
+            }
+
+            if klass.respond_to?(:columns)
+              entry[:columns] = safe_columns(klass)
+            end
+
+            if klass.respond_to?(:reflect_on_all_associations)
+              entry[:associations] = klass.reflect_on_all_associations.group_by(&:macro).transform_values { |refs|
+                refs.map { |a|
+                  assoc = { name: a.name, class_name: a.class_name }
+                  assoc[:through] = a.options[:through] if a.options[:through]
+                  assoc[:source] = a.options[:source] if a.options[:source]
+                  assoc[:foreign_key] = a.foreign_key
+                  assoc[:polymorphic] = true if a.polymorphic?
+                  assoc[:as] = a.options[:as] if a.options[:as]
+                  assoc[:dependent] = a.options[:dependent] if a.options[:dependent]
+                  assoc
+                }
+              }
+            end
+
+            if klass.respond_to?(:validators)
+              entry[:validators] = klass.validators.map { |v|
+                {
+                  attribute: v.attributes.first&.to_s,
+                  kind: v.kind,
+                  options: v.options.reject { |k, _| k == :if }
+                }
+              }.reject { |v| v[:attribute].nil? }
+            end
+
+            entry
+          end
+        end
+
+        def build_association_graph(models)
+          edges = []
+
+          models.each do |klass|
+            klass.reflect_on_all_associations.each do |a|
+              next if a.macro == :has_many && a.options[:through]  # Skip through associations (derived)
+
+              target_model = find_model_for_association(models, a)
+              next unless target_model
+
+              edges << {
+                from: klass.name,
+                to: target_model.name,
+                type: a.macro,
+                via: a.name,
+                foreign_key: a.foreign_key,
+                polymorphic: a.polymorphic? || false
+              }
+            end
+          end
+
+          edges
+        end
+
+        def find_model_for_association(models, association)
+          class_name = association.class_name
+          # Try exact match first, then match by class name suffix (handles namespace issues)
+          models.find { |m| m.name == class_name } ||
+            models.find { |m| m.name.end_with?("::#{class_name}") } ||
+            models.find { |m| class_name.end_with?("::#{m.name}") }
+        end
+
+        def build_table_details(detail)
+          models = discover_ar_models
+          tables = {}
+
+          models.each do |klass|
+            table = klass.table_name
+            next if TABLE_EXCLUSIONS.include?(table)
+
+            tables[table] = {
+              model: klass.name,
+              columns: safe_columns(klass),
+              indexes: fetch_indexes_for(table)
+            }
+          end
+
+          tables
+        end
+
+        def safe_primary_key(klass)
+          klass.primary_key
+        rescue StandardError
+          nil
+        end
+
+        def safe_columns(klass)
+          klass.columns.map { |c|
+            col = { name: c.name, type: c.type, null: c.null }
+            col[:default] = c.default unless c.default.nil?
+            col[:primary_key] = true if c.name == klass.primary_key
+            col
+          }
+        rescue StandardError
+          []
+        end
+
+        def fetch_indexes_for(table_name)
+          ActiveRecord::Base.connection.indexes(table_name).map do |idx|
+            {
+              name: idx.name,
+              columns: idx.columns,
+              unique: idx.unique
+            }
+          end
+        rescue StandardError
+          []
+        end
+      end
+    end
+  end
+end

data/lib/ask/rails/tools/search_codebase.rb

@@ -6,15 +6,14 @@ module Ask
       class SearchCodebase < Ask::Rails::Tool
         description "Search the Rails codebase with grep."
         param :pattern, type: :string, desc: "Search pattern", required: true
-        param :path, type: :string, desc: "Subdirectory to search (optional)"
+        param :path, type: :string, desc: "Subdirectory to search (optional)", required: false
 
         def execute(pattern:, path: nil)
-          search_path = path ? rails_root.join(path) : rails_root
-          results = `cd #{rails_root} && grep -rn '#{pattern}' #{search_path} 2>&1 | head -50`
-          Ask::Result.success(
-            data: { results: results, count: results.lines.count },
-            metadata: { pattern: pattern, count: results.lines.count }
-          )
+          search_path = (path ? rails_root.join(path) : rails_root).to_s
+          escaped_pattern = pattern.gsub("'", "'\\\\''")
+          escaped_path = search_path.gsub("'", "'\\\\''")
+          results = `cd #{rails_root} && grep -rn '#{escaped_pattern}' #{escaped_path} 2>&1 | head -50`
+          { results: results.lines.map(&:chomp), count: results.lines.count }
         end
       end
     end

data/lib/ask/rails/version.rb

@@ -2,6 +2,6 @@
 
 module Ask
   module Rails
-    VERSION = "0.3.0"
+    VERSION = "0.11.0"
   end
 end

data/lib/ask/rails.rb

@@ -16,21 +16,41 @@ module Ask
       end
 
       def agent_session(**extra)
+        # Auto-prune if configured
+        cleanup! if configuration.max_session_age || configuration.max_sessions
+
         tools = configuration.tools.map { |t| t.is_a?(Class) ? t.new : t }
         prompt = extra.delete(:system_prompt) || configuration.system_prompt || default_system_prompt
 
+        # Resolve environment-specific permissions and wire into agent hooks
+        hooks = build_environment_hooks
+
         Ask::Agent::Session.new(
           model: configuration.default_model,
           max_turns: configuration.max_turns,
           system_prompt: prompt,
           tools: tools,
-          persistence: configuration.persistence_adapter,
+          state: configuration.persistence_adapter,
+          hooks: hooks,
           **extra
         )
       end
 
       def discover_tools!
-        self.configuration.tools = Ask::Tools::Shell::TOOLS.map(&:new) + discovered_rails_tools
+        self.configuration.tools = Ask::Tools::Shell::TOOLS.map(&:new) + core_rails_tools + discovered_user_tools
+      end
+
+      # Prune old sessions and audit logs based on configuration limits.
+      #
+      # Removes sessions older than +max_session_age+ seconds, and limits the
+      # total number of sessions to +max_sessions+ (deleting the oldest first).
+      # Audit log entries older than the oldest kept session are also removed.
+      #
+      # Call manually via rake task or cron, or configure limits to auto-prune
+      # on agent_session creation.
+      def cleanup!
+        prune_old_sessions
+        limit_session_count
       end
 
       def root
@@ -39,7 +59,76 @@ module Ask
 
       private
 
-      def discovered_rails_tools
+      def build_environment_hooks
+        env_mode = configuration.effective_mode
+        return {} unless env_mode
+
+        perms = Ask::Agent::Extensions::Permissions.new(mode: env_mode)
+        { before_tool: [perms.method(:before_tool_call)] }
+      rescue ArgumentError => e
+        warn "[ask-rails] Invalid environment mode: #{e.message}"
+        {}
+      end
+
+      def prune_old_sessions
+        age = configuration.max_session_age
+        return unless age&.> 0
+        return unless persistence_available?
+
+        cutoff = age.seconds.ago
+        count = 0
+
+        configuration.persistence_adapter.list.each do |id|
+          data = configuration.persistence_adapter.load(id)
+          created = data&.dig(:metadata, :created_at)
+          if created && Time.parse(created) < cutoff
+            configuration.persistence_adapter.delete(id)
+            count += 1
+          end
+        end
+
+        count
+      rescue StandardError
+        nil
+      end
+
+      def limit_session_count
+        max = configuration.max_sessions
+        return unless max&.> 0
+        return unless persistence_available?
+
+        sessions = configuration.persistence_adapter.list
+        excess = sessions.size - max
+        return unless excess > 0
+
+        # Delete oldest sessions first
+        with_timestamps = sessions.map { |id|
+          data = configuration.persistence_adapter.load(id)
+          created = data&.dig(:metadata, :created_at)
+          [id, created ? Time.parse(created) : Time.at(0)]
+        }.sort_by(&:last)
+
+        with_timestamps.first(excess).each do |id, _|
+          configuration.persistence_adapter.delete(id)
+        end
+
+        excess
+      rescue StandardError
+        nil
+      end
+
+      def persistence_available?
+        defined?(ActiveRecord::Base) &&
+          ActiveRecord::Base.connection.data_source_exists?("ask_sessions")
+      rescue StandardError
+        false
+      end
+
+      def core_rails_tools
+        CORE_RAILS_TOOLS.map(&:new)
+      end
+
+      def discovered_user_tools
         tools = []
         files = Dir[::Rails.root.join("app", "tools", "*.rb")]
         files.each do |f|
@@ -67,6 +156,8 @@ end
 require_relative "rails/version"
 require_relative "rails/engine"
 require_relative "rails/configuration"
+require_relative "rails/audit_log"
+require_relative "rails/environment_permissions"
 require_relative "rails/auth"
 require_relative "rails/persistence"
 require_relative "rails/service_discovery"
@@ -78,8 +169,19 @@ require_relative "rails/tools/read_routes"
 require_relative "rails/tools/query_database"
 require_relative "rails/tools/read_model"
 require_relative "rails/tools/read_log"
+require_relative "rails/tools/schema_graph"
+require_relative "rails/tools/route_inspector"
 
 # Railtie is loaded only when Rails is fully available
 if defined?(::Rails::Railtie)
   require_relative "rails/railtie"
 end
+
+# Define after all tool files are loaded so the constants resolve
+Ask::Rails::CORE_RAILS_TOOLS = [
+  Ask::Rails::Tools::ReadFile, Ask::Rails::Tools::RunCommand,
+  Ask::Rails::Tools::SearchCodebase, Ask::Rails::Tools::ReadRoutes,
+  Ask::Rails::Tools::QueryDatabase, Ask::Rails::Tools::ReadModel,
+  Ask::Rails::Tools::ReadLog, Ask::Rails::Tools::SchemaGraph,
+  Ask::Rails::Tools::RouteInspector
+].freeze

data/lib/generators/ask/rails/install/install_generator.rb

@@ -19,6 +19,11 @@ module Ask
           template "migration.rb", "db/migrate/#{timestamp}_create_ask_sessions.rb"
         end
 
+        def create_audit_log_migration
+          timestamp = Time.now.utc.strftime("%Y%m%d%H%M%S")
+          template "audit_log_migration.rb", "db/migrate/#{timestamp}_create_ask_audit_logs.rb"
+        end
+
         def create_tools_directory
           empty_directory "app/tools"
           create_file "app/tools/.keep", ""

data/lib/generators/ask/rails/install/templates/audit_log_migration.rb

@@ -0,0 +1,22 @@
+class CreateAskAuditLogs < ActiveRecord::Migration[7.1]
+  def change
+    create_table :ask_audit_logs do |t|
+      t.string :session_id, null: false
+      t.string :tool_name, null: false
+      t.jsonb :params
+      t.jsonb :result_summary
+      t.string :status, null: false, default: "success"
+      t.text :error_message
+      t.integer :duration_ms
+      t.jsonb :user_context
+      t.string :environment
+      t.datetime :recorded_at, null: false
+
+      t.timestamps
+    end
+
+    add_index :ask_audit_logs, :session_id
+    add_index :ask_audit_logs, [:recorded_at, :tool_name]
+    add_index :ask_audit_logs, :status
+  end
+end

data/lib/generators/ask/rails/install/templates/initializer.rb

@@ -1,5 +1,5 @@
 Ask::Rails.configure do |config|
   config.default_model = ENV.fetch("ASK_DEFAULT_MODEL", "gpt-4o")
   config.max_turns = ENV.fetch("ASK_MAX_TURNS", 25).to_i
-  # config.persistence_adapter = Ask::Rails::Persistence.new
+  config.persistence_adapter = Ask::Rails::Persistence.new
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ask-rails
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Kaka Ruto
@@ -147,14 +147,17 @@ files:
 - LICENSE
 - README.md
 - app/controllers/ask/rails/chat_controller.rb
+- app/models/ask/rails/session.rb
 - app/views/ask/rails/chat/index.html.erb
 - app/views/layouts/ask/rails/application.html.erb
 - config/routes.rb
 - lib/ask-rails.rb
 - lib/ask/rails.rb
+- lib/ask/rails/audit_log.rb
 - lib/ask/rails/auth.rb
 - lib/ask/rails/configuration.rb
 - lib/ask/rails/engine.rb
+- lib/ask/rails/environment_permissions.rb
 - lib/ask/rails/persistence.rb
 - lib/ask/rails/railtie.rb
 - lib/ask/rails/service_discovery.rb
@@ -164,13 +167,16 @@ files:
 - lib/ask/rails/tools/read_log.rb
 - lib/ask/rails/tools/read_model.rb
 - lib/ask/rails/tools/read_routes.rb
+- lib/ask/rails/tools/route_inspector.rb
 - lib/ask/rails/tools/run_command.rb
+- lib/ask/rails/tools/schema_graph.rb
 - lib/ask/rails/tools/search_codebase.rb
 - lib/ask/rails/version.rb
 - lib/ask/skills/rails.db_debug/SKILL.md
 - lib/ask/skills/rails.deploy_pipeline/SKILL.md
 - lib/ask/skills/rails.route_trouble/SKILL.md
 - lib/generators/ask/rails/install/install_generator.rb
+- lib/generators/ask/rails/install/templates/audit_log_migration.rb
 - lib/generators/ask/rails/install/templates/initializer.rb
 - lib/generators/ask/rails/install/templates/migration.rb
 homepage: https://github.com/ask-rb/ask-rails