ask-rails 0.2.4 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e889ca7205fe9d828eaa76008efb362309f22768e553d4f656bb9e030806467b
-  data.tar.gz: 88175d5a80292be3af7d330a9431a5d3153fccda7e6bd4d822d652027a73de41
+  metadata.gz: 1a8258ca96d9513529bc1c0c9c54bd8e2492a110e48d90c9af3f53ca3aa24d9f
+  data.tar.gz: 4a776f46230d7a87719d5a6e12154e90987f71f60af63707da686ba2cce20377
 SHA512:
-  metadata.gz: 81c97d529341e34b15c6bc058a620ae85ef159d8a1450e98da92afbbf6a24757e0fd44fbf5055141fcab76d855d1eecfade26477ba5a88df11e2e58c3e9f18e9
-  data.tar.gz: ade64f24813a53a09587850816b77f59026b32eb4f6392daf367ab260a40d947de434606c942f1c08e14ab2ad4ed6be85eeedd2a1eda296729918ec49f56c737
+  metadata.gz: 894f5146923889fd014f1ac770c52eba2cfdc6d84fd546062c05ac85473f6e716e70a298761f25a19ea1b00ba60461aae3ab38889c05a95698d891320879cc86
+  data.tar.gz: d58b94569c064b58493bd0a929cfb1dde3310a43c110c92474947c57e711f5a4e6d57ca596c389e73fcb4ee6bddeff7e8797bc5915ca8e4cbf94eadaf5f2353d

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+## [0.1.0] — 2026-07-26
+
+### Added
+
+- Initial release of `ask-rails` — Rails integration for the ask-rb ecosystem.
+- **Install generator** — `rails generate ask:install` creates `config/initializers/ask.rb`, `app/agents/application_agent.rb`, and `app/agents/` directory.
+- **Railtie** — Wires `Ask::Agent.logger` to `Rails.logger`, discovers agent definitions in `app/agents/`.

data/README.md

@@ -1,34 +1,59 @@
 # ask-rails
 
-Rails integration for the ask-rb ecosystem. The only gem a Rails app needs to join
-the ask-rb stack — provides a Railtie, AR session persistence, a session factory,
-automatic service gem discovery, and generators.
+Rails integration for the [ask-rb](https://github.com/ask-rb) ecosystem. Provides generators, file conventions, and railtie for using AI agents in your Rails app.
 
 ## Installation
 
 ```bash
 bundle add ask-rails
-rails generate ask_rails:install
+rails generate ask:install
 ```
 
+This creates:
+- `config/initializers/ask.rb` — agent configuration
+- `app/agents/application_agent.rb` — base class for your agents
+- `app/agents/` — directory for agent definitions
+
 ## Usage
 
+Define an agent:
+
 ```ruby
-# In any Rails context
-session = Ask::Rails.agent_session
-session.run("Find all open issues labeled 'bug' in our repo")
+# app/agents/support_bot.rb
+class Agents::SupportBot < ApplicationAgent
+  model "gpt-4o"
+  system_prompt "You help users with support questions."
+
+  tool :bash
+  tool :read
+  tool :grep
+end
 ```
 
-Service gems like `ask-github`, `ask-slack` are auto-discovered — the agent gets their
-context (auth info, quick-start snippets, error guides) in the system prompt automatically.
+Run it:
+
+```ruby
+agent = Ask::Agent.new("support_bot")
+response = agent.run("Find all open issues in the codebase")
+puts response
+```
 
-## Development
+Or use `Ask.chat` for one-off conversations:
 
-```bash
-bin/setup
-bundle exec rake test
+```ruby
+Ask.chat("Summarize this article: #{text}")
 ```
 
+## Configuration
+
+API keys are resolved automatically by `Ask::Auth`:
+
+- **Environment variables:** `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, etc.
+- **Rails credentials:** `rails credentials:edit` → add `ask.openai`, `ask.anthropic`
+- **File:** `~/.ask/credentials.yml`
+
+No manual credential setup is required.
+
 ## License
 
 MIT

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module Ask
+  module Rails
+    module Generators
+      class InstallGenerator < ::Rails::Generators::Base
+        source_root File.expand_path("templates", __dir__)
+
+        desc "Sets up ask-rb for Rails — creates initializer and app/agents/ directory"
+
+        def create_initializer
+          template "initializer.rb", "config/initializers/ask.rb"
+        end
+
+        def create_application_agent
+          template "application_agent.rb", "app/agents/application_agent.rb"
+        end
+
+        def create_agents_directory
+          empty_directory "app/agents"
+          create_file "app/agents/.keep", "" unless options[:skip_keep]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Base class for your application's AI agents.
+#
+# Subclass this to define agents:
+#
+#   class Agents::SupportBot < ApplicationAgent
+#     model "gpt-4o"
+#     system_prompt "You help users with support questions."
+#
+#     tool :search_knowledge_base
+#   end
+#
+# Then run:
+#   agent = Ask::Agent.new("support_bot")
+#   agent.run("How do I reset my password?")
+#
+class ApplicationAgent < Ask::Agent::Definition
+  # Default instructions — override in subclasses
+  system_prompt "You are a helpful assistant."
+
+  # Uncomment to add built-in tools:
+  # tool :bash
+  # tool :read
+  # tool :grep
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Ask Agent Configuration
+# ========================
+#
+# API keys are resolved automatically by Ask::Auth:
+#   - Environment variables: OPENAI_API_KEY, ANTHROPIC_API_KEY, etc.
+#   - Rails credentials: rails credentials:edit → ask.openai, ask.anthropic
+#   - ~/.ask/credentials.yml
+#
+# See https://github.com/ask-rb/ask-auth for details.
+
+Ask::Agent.configure do |config|
+  # config.default_model = "gpt-4o"
+end

data/lib/ask/rails/railtie.rb

@@ -3,25 +3,8 @@
 module Ask
   module Rails
     class Railtie < ::Rails::Railtie
-      rake_tasks do
-        # Load rake tasks if any
-      end
-
       generators do
-        require_relative "../../generators/ask/rails/install/install_generator"
-      end
-
-      initializer "ask_rails.configure" do |app|
-        Ask::Rails.configuration.default_model ||= ENV["ASK_DEFAULT_MODEL"] || "gpt-4o"
-        Ask::Rails.configuration.max_turns ||= (ENV["ASK_MAX_TURNS"] || 25).to_i
-      end
-
-      initializer "ask_rails.discover_tools", after: :eager_load_most do
-        Ask::Rails.discover_tools!
-      end
-
-      initializer "ask_rails.discover_services", after: :eager_load_most do
-        Ask::Rails::ServiceDiscovery.discover!
+        require_relative "generators/install/install_generator"
       end
     end
   end

data/lib/ask/rails/version.rb

@@ -2,6 +2,6 @@
 
 module Ask
   module Rails
-    VERSION = "0.2.4"
+    VERSION = "0.4.0"
   end
 end

data/lib/ask/rails.rb

@@ -1,80 +1,11 @@
 # frozen_string_literal: true
 
-require "rails"
 require "ask/agent"
-require "ask/auth"
 
 module Ask
   module Rails
-    class << self
-      def configure
-        yield configuration
-      end
-
-      def configuration
-        @configuration ||= Configuration.new
-      end
-
-      def agent_session(**extra)
-        tools = configuration.tools.map { |t| t.is_a?(Class) ? t.new : t }
-        prompt = extra.delete(:system_prompt) || configuration.system_prompt || default_system_prompt
-
-        Ask::Agent::Session.new(
-          model: configuration.default_model,
-          max_turns: configuration.max_turns,
-          system_prompt: prompt,
-          tools: tools,
-          persistence: configuration.persistence_adapter,
-          **extra
-        )
-      end
-
-      def discover_tools!
-        self.configuration.tools = Ask::Tools::Shell::TOOLS.map(&:new) + discovered_rails_tools
-      end
-
-      def root
-        @root ||= Pathname.new(File.expand_path("..", __dir__))
-      end
-
-      private
-
-      def discovered_rails_tools
-        tools = []
-        files = Dir[::Rails.root.join("app", "tools", "*.rb")]
-        files.each do |f|
-          require f
-          klass = File.basename(f, ".rb").camelize.constantize rescue next
-          tools << klass if klass < Ask::Rails::Tool
-        end
-        tools
-      rescue
-        tools
-      end
-
-      def default_system_prompt
-        <<~PROMPT
-          You are a Ruby on Rails software engineer.
-          You have direct access to the application's code, database, and runtime.
-          Use your tools to inspect and modify the codebase.
-          Once you have enough information, stop calling tools and give your answer.
-        PROMPT
-      end
-    end
   end
 end
 
 require_relative "rails/version"
-require_relative "rails/engine"
-require_relative "rails/configuration"
-require_relative "rails/railtie"
-require_relative "rails/persistence"
-require_relative "rails/service_discovery"
-require_relative "rails/tool"
-require_relative "rails/tools/read_file"
-require_relative "rails/tools/run_command"
-require_relative "rails/tools/search_codebase"
-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/railtie" if defined?(::Rails::Railtie)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ask-rails
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.4.0
 platform: ruby
 authors:
 - Kaka Ruto
@@ -24,21 +24,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '7.1'
 - !ruby/object:Gem::Dependency
-  name: ask-tools
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.1'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.1'
-- !ruby/object:Gem::Dependency
-  name: ask-tools-shell
+  name: ask-agent
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -51,48 +37,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0.1'
-- !ruby/object:Gem::Dependency
-  name: ask-agent
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.1'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.1'
-- !ruby/object:Gem::Dependency
-  name: ask-auth
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.1'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.1'
-- !ruby/object:Gem::Dependency
-  name: sqlite3
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -135,42 +79,31 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '13.0'
-description: Railtie, AR session persistence, session factory, service gem discovery,
-  and generators.
+description: Rails generators, file conventions, and railtie for using ask-agent in
+  Rails apps.
 email:
 - kaka@myrrlabs.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - LICENSE
 - README.md
 - lib/ask-rails.rb
 - lib/ask/rails.rb
-- lib/ask/rails/configuration.rb
-- lib/ask/rails/engine.rb
-- lib/ask/rails/persistence.rb
+- lib/ask/rails/generators/install/install_generator.rb
+- lib/ask/rails/generators/install/templates/application_agent.rb
+- lib/ask/rails/generators/install/templates/initializer.rb
 - lib/ask/rails/railtie.rb
-- lib/ask/rails/service_discovery.rb
-- lib/ask/rails/tool.rb
-- lib/ask/rails/tools/query_database.rb
-- lib/ask/rails/tools/read_file.rb
-- 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/run_command.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/initializer.rb
-- lib/generators/ask/rails/install/templates/migration.rb
 homepage: https://github.com/ask-rb/ask-rails
 licenses:
 - MIT
-metadata: {}
+metadata:
+  homepage_uri: https://github.com/ask-rb/ask-rails
+  source_code_uri: https://github.com/ask-rb/ask-rails
+  changelog_uri: https://github.com/ask-rb/ask-rails/blob/main/CHANGELOG.md
 rdoc_options: []
 require_paths:
 - lib

data/lib/ask/rails/configuration.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Ask
-  module Rails
-    class Configuration
-      attr_accessor :default_model, :max_turns, :system_prompt,
-                    :tool_concurrency, :persistence_adapter, :tools
-
-      def initialize
-        @default_model = "gpt-4o"
-        @max_turns = 25
-        @system_prompt = nil
-        @tool_concurrency = 5
-        @persistence_adapter = nil
-        @tools = []
-      end
-    end
-  end
-end

data/lib/ask/rails/engine.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "railtie"
-
-module Ask
-  module Rails
-    class Engine < ::Rails::Engine
-      isolate_namespace Ask::Rails
-    end
-  end
-end

data/lib/ask/rails/persistence.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Ask
-  module Rails
-    class Persistence
-      def initialize(model_class: nil)
-        @model_class = model_class
-      end
-
-      def save(session_id, data)
-        record = model_class.find_or_initialize_by(session_id: session_id)
-        record.update!(data: data)
-      end
-
-      def load(session_id)
-        record = model_class.find_by(session_id: session_id)
-        record&.data
-      end
-
-      def delete(session_id)
-        model_class.where(session_id: session_id).delete_all
-      end
-
-      def list
-        model_class.pluck(:session_id)
-      end
-
-      private
-
-      def model_class
-        @model_class || (raise "No model class configured. Use Persistence.new(model_class: MyModel)")
-      end
-    end
-  end
-end

data/lib/ask/rails/service_discovery.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module Ask
-  module Rails
-    module ServiceDiscovery
-      SERVICE_GEMS_PATTERN = /\Aask-(?!tools|tools-shell|agent|rails|core|auth|schema|llm)/
-
-      module_function
-
-      def discover!
-        service_gems = Gem.loaded_specs.keys.select { |name| name.match?(SERVICE_GEMS_PATTERN) }
-        contexts = []
-
-        service_gems.each do |name|
-          begin
-            require "#{name.tr("-", "/")}/context"
-            mod = name.split("-").map(&:capitalize).join.constantize
-            contexts << mod if mod.respond_to?(:const_defined?) && mod.const_defined?(:DESCRIPTION)
-          rescue LoadError, NameError
-          end
-        end
-
-        unless contexts.empty?
-          prompt = build_system_prompt(contexts)
-          existing = Ask::Rails.configuration.system_prompt
-          Ask::Rails.configuration.system_prompt = [existing, prompt].compact.join("\n\n")
-        end
-
-        contexts
-      end
-
-      def build_system_prompt(contexts)
-        sections = ["## Available Services"]
-
-        contexts.each do |mod|
-          name = mod.respond_to?(:name) ? mod.name.to_s.split("::").last || "Unknown" : "Unknown"
-          sections << "### #{name}"
-          sections << mod::DESCRIPTION if mod.const_defined?(:DESCRIPTION)
-          sections << "Documentation: #{mod::DOCS_URL}" if mod.const_defined?(:DOCS_URL)
-          sections << "Authentication: #{mod::AUTH_HOW}" if mod.const_defined?(:AUTH_HOW)
-          sections << ""
-        end
-
-        sections.join("\n")
-      end
-    end
-  end
-end

data/lib/ask/rails/tool.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Ask
-  module Rails
-    class Tool < Ask::Tool
-      def rails_root
-        ::Rails.root
-      end
-    end
-  end
-end

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

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-module Ask
-  module Rails
-    module Tools
-      class QueryDatabase < Ask::Rails::Tool
-        description "Run a read-only SQL query against the application database. " \
-                     "Returns columns and rows. Only SELECT queries are allowed in production."
-
-        param :sql,   type: :string, desc: "SQL query (SELECT only in production)", required: true
-        param :limit, type: :integer, desc: "Max rows to return (default 50)", required: false
-
-        WRITE_STATEMENTS = /\A\s*(INSERT|UPDATE|DELETE|DROP|TRUNCATE|ALTER|CREATE|GRANT|REVOKE)\b/i
-
-        def execute(sql:, limit: 50)
-          sql = sql.strip
-
-          if WRITE_STATEMENTS.match?(sql)
-            return Ask::Result.failure(
-              "Only SELECT queries are allowed. Write statements (#{sql.match(WRITE_STATEMENTS)[1]}) are rejected in all environments."
-            )
-          end
-
-          if ::Rails.env.production? && !sql.match?(/\A\s*SELECT\b/i)
-            return Ask::Result.failure(
-              "Only SELECT queries are allowed in the production environment."
-            )
-          end
-
-          pool = ActiveRecord::Base.connection_pool
-          pool.with_connection do |conn|
-            limited_sql = sql.match?(/\bLIMIT\b/i) ? sql : "#{sql.chomp(';')} LIMIT #{limit.to_i}"
-            result = conn.exec_query(limited_sql)
-            columns = result.columns
-            rows = result.rows.first(limit.to_i).map { |row| build_row(row, columns) }
-            {
-              columns: columns,
-              rows: rows,
-              count: rows.size,
-              truncated: result.rows.size > limit.to_i
-            }
-          end
-        rescue ActiveRecord::StatementInvalid => e
-          Ask::Result.failure("SQL error: #{e.message}")
-        rescue ActiveRecord::ConnectionNotEstablished => e
-          Ask::Result.failure("Database not connected: #{e.message}. Verify the database is running and Rails is connected.")
-        end
-
-        private
-
-        def build_row(row, columns)
-          columns.each_with_index.each_with_object({}) do |(col, i), hash|
-            value = row[i]
-            hash[col] = sanitize_value(value)
-          end
-        end
-
-        def sanitize_value(value)
-          return "[BINARY DATA]" if binary_value?(value)
-          return value.iso8601 if value.respond_to?(:iso8601)
-          value
-        end
-
-        def binary_value?(value)
-          value.is_a?(String) && value.encoding == Encoding::ASCII_8BIT && value.bytesize > 0
-        rescue
-          false
-        end
-      end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Ask
-  module Rails
-    module Tools
-      class ReadFile < Ask::Rails::Tool
-        description "Read a file from the Rails app. Paths are relative to Rails.root."
-
-        param :path, type: :string, desc: "Relative path from Rails.root", required: true
-
-        def execute(path:)
-          full_path = rails_root.join(path)
-          return Ask::Result.error(message: "File not found: #{path}") unless full_path.exist?
-
-          content = full_path.read
-          Ask::Result.success(
-            data: { path: path, content: content, size: content.length },
-            metadata: { path: path, size: content.length }
-          )
-        end
-      end
-    end
-  end
-end

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

@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-
-module Ask
-  module Rails
-    module Tools
-      class ReadLog < Ask::Rails::Tool
-        description "Read application log files with filtering. Supports Rails default " \
-                     "logger and log rotation. Reads from the end of the file (most recent first)."
-
-        param :lines,  type: :integer, desc: "Number of recent lines (default 50, max 500)", required: false
-        param :level,  type: :string, desc: "Filter by level: ERROR, WARN, INFO, DEBUG", required: false
-        param :search, type: :string, desc: "Search term (plain text, case-insensitive)", required: false
-        param :file,   type: :string, desc: "Log file name (default: log/<env>.log)", required: false
-
-        MAX_LINES = 500
-        LEVEL_PATTERNS = {
-          "ERROR" => /\bERROR\b/i,
-          "WARN"  => /\bWARN\b/i,
-          "INFO"  => /\bINFO\b/i,
-          "DEBUG" => /\bDEBUG\b/i
-        }.freeze
-
-        def execute(lines: 50, level: nil, search: nil, file: nil)
-          max_lines = [lines.to_i, MAX_LINES].min
-          log_path = resolve_log_path(file)
-
-          unless log_path.exist?
-            return Ask::Result.failure(
-              "Log file not found: #{log_path}. The application may not have written any logs yet."
-            )
-          end
-
-          raw_lines = read_all_log_files(log_path)
-          return { lines: [], total_lines: 0, path: log_path.to_s } if raw_lines.empty?
-
-          filtered = apply_filters(raw_lines, level: level, search: search)
-          recent = filtered.last(max_lines).map(&:chomp)
-
-          {
-            lines: recent,
-            total_lines: raw_lines.size,
-            matched_lines: filtered.size,
-            path: log_path.to_s,
-            filters_applied: { level: level, search: search }.compact
-          }
-        end
-
-        private
-
-        def resolve_log_path(custom_path)
-          return rails_root.join(custom_path) if custom_path
-          rails_root.join("log", "#{Rails.env}.log")
-        end
-
-        # Read from rotated archives too: log/production.log, .1, .2.gz, etc.
-        def read_all_log_files(log_path)
-          all_content = +""
-          rotated_files(log_path).each do |path|
-            content = read_file_content(path)
-            all_content.prepend(content) if content
-          end
-          all_content.lines
-        end
-
-        def rotated_files(log_path)
-          dir = log_path.dirname
-          base = log_path.basename.to_s
-          # Primary file, then rotated files in reverse order (oldest first, then primary last)
-          pattern = File.join(dir, "#{base}.*")
-          rotations = Dir[pattern].sort_by { |f| extract_rotation_number(f) }
-          # Primary file is read last (most recent)
-          rotations + [log_path.to_s]
-        end
-
-        def extract_rotation_number(path)
-          File.basename(path).sub(/.*\.(\d+)(\.gz)?$/, '\1').to_i
-        rescue
-          0
-        end
-
-        def read_file_content(path)
-          if path.to_s.end_with?(".gz")
-            Zlib::GzipReader.open(path.to_s) { |gz| gz.read }
-          else
-            File.read(path.to_s)
-          end
-        rescue => e
-          warn "[ReadLog] Could not read #{path}: #{e.message}"
-          nil
-        end
-
-        def read_tail(path, max_bytes)
-          return "" unless path.exist?
-
-          size = path.size
-          return path.read if size <= max_bytes
-
-          File.open(path, "rb") do |f|
-            f.seek(-max_bytes, IO::SEEK_END)
-            partial = f.read(max_bytes)
-            if (idx = partial.index("\n"))
-              partial[idx + 1..]
-            else
-              partial
-            end
-          end
-        end
-
-        def apply_filters(lines, level: nil, search: nil)
-          filtered = lines
-          filtered = filtered.select { |l| LEVEL_PATTERNS.fetch(level) { // }.match?(l) } if level
-          filtered = filtered.select { |l| l.downcase.include?(search.downcase) } if search
-          filtered
-        end
-      end
-    end
-  end
-end

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

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-module Ask
-  module Rails
-    module Tools
-      class ReadModel < Ask::Rails::Tool
-        description "Inspect an ActiveRecord model — columns, associations, validations, " \
-                     "scopes, and indexes. Returns structured data the agent can act on."
-
-        param :name,   type: :string, desc: "Model class name (e.g. 'User', 'Blog::Post')", required: true
-        param :detail, type: :string, desc: "Which details: 'all' (default), 'columns', 'associations', 'validations', 'scopes'", required: false
-
-        def execute(name:, detail: "all")
-          klass = safe_constantize(name)
-          return Ask::Result.failure("Model '#{name}' not found or is not an ActiveRecord model.") unless klass
-
-          result = { name: klass.name, table_name: klass.table_name }
-
-          result[:primary_key] = klass.primary_key if klass.respond_to?(:primary_key)
-
-          if %w[all columns].include?(detail)
-            result[:columns] = klass.columns.map { |c|
-              entry = { name: c.name, type: c.type, null: c.null, default: c.default }
-              entry[:primary_key] = true if c.name == klass.primary_key
-              entry
-            }
-          end
-
-          if %w[all associations].include?(detail)
-            result[:associations] = klass.reflect_on_all_associations.group_by(&:macro).transform_values { |refs|
-              refs.map { |a|
-                entry = { name: a.name, class_name: a.class_name }
-                entry[:through] = a.options[:through] if a.options[:through]
-                entry[:source] = a.options[:source] if a.options[:source]
-                entry[:foreign_key] = a.foreign_key if a.respond_to?(:foreign_key)
-                entry
-              }
-            }
-          end
-
-          if %w[all scopes].include?(detail) && klass.respond_to?(:all)
-            result[:scopes] = klass.methods(false)
-              .reject { |m| m.to_s.end_with?("=", "!", "?") || %i[new allocate inspect to_s].include?(m) }
-              .map(&:to_s).sort
-          end
-
-          if %w[all validations].include?(detail)
-            result[: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
-
-          result
-        end
-
-        private
-
-        def safe_constantize(name)
-          klass = name.safe_constantize
-          return nil unless klass
-          return nil unless klass < ActiveRecord::Base
-          klass
-        rescue
-          nil
-        end
-      end
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Ask
-  module Rails
-    module Tools
-      class ReadRoutes < Ask::Rails::Tool
-        description "Read the Rails routes from config/routes.rb"
-        def execute
-          routes_file = rails_root.join("config", "routes.rb")
-          return Ask::Result.error(message: "No routes file found") unless routes_file.exist?
-
-          content = routes_file.read
-          Ask::Result.success(
-            data: { content: content },
-            metadata: { size: content.length }
-          )
-        end
-      end
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Ask
-  module Rails
-    module Tools
-      class RunCommand < Ask::Rails::Tool
-        description "Run a shell command in the Rails app root directory."
-        param :command, type: :string, desc: "Shell command to run", required: true
-
-        def execute(command:)
-          output = `cd #{rails_root} && #{command} 2>&1`
-          Ask::Result.success(
-            data: { output: output, exit_status: $?.exitstatus },
-            metadata: { exit_status: $?.exitstatus }
-          )
-        end
-      end
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Ask
-  module Rails
-    module Tools
-      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)"
-
-        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 }
-          )
-        end
-      end
-    end
-  end
-end

data/lib/ask/skills/rails.db_debug/SKILL.md

@@ -1,118 +0,0 @@
----
-name: rails.db_debug
-description: Step-by-step methodology for debugging database performance issues in Rails
----
-
-Use this skill when investigating slow queries, N+1 problems, missing indexes, or
-general database performance issues in a Rails application.
-
-## Step 1: Identify the Slow Queries
-
-Use `ReadLog.new.call(lines: 200, search: "SELECT")` to find recent database
-queries in the application log. Look for:
-
-- Queries taking > 100ms (look for "duration:" or "↳" markers in Rails logs)
-- Repetitive queries with the same structure (potential N+1)
-- Queries running in loops (same query, different IDs)
-
-If you need more detail, narrow the search: `ReadLog.new.call(lines: 500, level: "WARN")`.
-
-## Step 2: Understand the Schema
-
-For each model involved in the slow queries, inspect it:
-
-```ruby
-ReadModel.new.call(name: "User")
-ReadModel.new.call(name: "Post")
-```
-
-Focus on:
-- **Columns** — are there columns that look like foreign keys without indexes?
-- **Associations** — what associations exist and what `class_name` do they use?
-- **Validators** — any database-level constraints that could be missing?
-
-Run `ReadModel.new.call(name: "User", detail: "columns")` if you only need columns.
-
-## Step 3: Check for Missing Indexes
-
-Query the database for actual indexes:
-
-```ruby
-QueryDatabase.new.call(
-  sql: "SELECT tablename, indexname, indexdef FROM pg_indexes WHERE schemaname = 'public' ORDER BY tablename, indexname",
-  limit: 200
-)
-```
-
-Look for:
-- Foreign key columns that lack indexes (e.g. `user_id` without index)
-- Columns used in `WHERE` clauses without indexes
-- Composite indexes that could cover multiple query patterns
-
-If an index is missing, check if adding one would help:
-```ruby
-QueryDatabase.new.call(
-  sql: "EXPLAIN ANALYZE SELECT * FROM posts WHERE user_id = 1",
-  limit: 10
-)
-```
-
-## Step 4: Detect N+1 Queries
-
-N+1 manifests as the same query repeated with different IDs:
-
-```ruby
-# Search for repetitive query patterns
-ReadLog.new.call(lines: 500, search: "WHERE.*IN")
-```
-
-Common N+1 patterns:
-- Loading `Post.all` then accessing `post.comments` individually
-- Loading `User.all` then accessing `user.profile` individually
-- Serializing associations in views without eager loading
-
-Fix with `.includes(:association)`, `.eager_load(:association)`, or
-`.preload(:association)`.
-
-## Step 5: Profile Slow Queries with EXPLAIN
-
-For any identified slow query, get the execution plan:
-
-```ruby
-QueryDatabase.new.call(
-  sql: "EXPLAIN (ANALYZE, BUFFERS) SELECT posts.* FROM posts WHERE posts.user_id = 1 ORDER BY posts.created_at DESC LIMIT 20",
-  limit: 10
-)
-```
-
-What to look for in explain output:
-- **Sequential scans** (`Seq Scan`) — missing index
-- **Sort operations** — missing index on sort column
-- **Nested loop joins** with high row counts — missing composite index
-- **Bitmap heap scans** with high costs — index may be suboptimal
-
-If `ANALYZE` takes too long, use `EXPLAIN (BUFFERS)` without `ANALYZE` for cost estimates.
-
-## Step 6: Check Bulk Loading and Batch Operations
-
-If the issue involves importing or updating many records:
-
-```ruby
-QueryDatabase.new.call(
-  sql: "SELECT schemaname, tablename, seq_scan, seq_tup_read, idx_scan, idx_tup_fetch FROM pg_stat_user_tables ORDER BY seq_scan DESC",
-  limit: 20
-)
-```
-
-High `seq_scan` counts compared to `idx_scan` indicate tables where indexes
-are missing and sequential scans are happening frequently.
-
-## Failure Mode Guide
-
-| Symptom | Likely Cause | Action |
-|---------|-------------|--------|
-| Query takes >1s | Missing index on WHERE column | Check pg_indexes, add index |
-| Same query 50x in log | N+1 in controller/view | Add `.includes()` |
-| Query slow AFTER adding index | Wrong index type or order | Verify index column order matches query |
-| `EXPLAIN ANALYZE` hanging | Table lock or very large table | Use `EXPLAIN (BUFFERS)` without ANALYZE |
-| Missing `pg_indexes` output | Not Postgres | Use `SHOW INDEX FROM <table>` for MySQL |

data/lib/ask/skills/rails.deploy_pipeline/SKILL.md

@@ -1,125 +0,0 @@
----
-name: rails.deploy_pipeline
-description: Pre-deployment checklist for Rails applications — migrations, assets, credentials, jobs, and logs
----
-
-Use this skill before or during a Rails deployment to ensure nothing is missed.
-Follow the steps in order — each builds on the previous.
-
-## Step 1: Check Pending Migrations
-
-Before deploying, always check for unapplied migrations:
-
-```ruby
-RunCommand.new.call(command: "bin/rails db:migrate:status | grep 'down'")
-```
-
-If there are pending migrations:
-1. Review them with `ReadFile.new.call(path: "db/migrate/<TIMESTAMP>_migration_name.rb")`
-2. Verify they're reversible: check `change`, `up`/`down`, or `reversible` blocks
-3. Check for data migrations (e.g., backfills) that should run separately
-4. Estimate execution time — large tables may need locking strategy
-
-## Step 2: Verify Assets Pipeline
-
-For Rails with assets (Sprockets or Propshaft):
-
-```ruby
-# Precompile locally to catch errors early
-RunCommand.new.call(command: "bin/rails assets:precompile 2>&1")
-```
-
-Check for:
-- Missing asset references (SCSS variables, image references)
-- JavaScript compilation errors
-- Asset fingerprint changes (manifold fingerprints if CSS changed)
-
-For importmap or esbuild/vite setups:
-
-```ruby
-# Check build config
-ReadFile.new.call(path: "package.json")
-ReadFile.new.call(path: "vite.config.ts") if File.exist?("Rails.root.join('vite.config.ts')")
-```
-
-## Step 3: Review Credentials and Secrets
-
-Verify that all required credentials exist in the target environment:
-
-```ruby
-# For production credentials
-RunCommand.new.call(command: "bin/rails credentials:show --environment production 2>&1")
-```
-
-Check for common secrets that may need updating:
-- `secret_key_base`
-- `database_password`
-- Third-party API keys (AWS, Stripe, SendGrid, etc.)
-- JWT signing keys
-- Any env vars referenced in `config/` files that aren't in credentials
-
-## Step 4: Check Background Jobs
-
-Review sidekiq/active job configuration before deploy:
-
-```ruby
-# Check job files for any that need queue configuration
-Glob.new.call(pattern: "app/jobs/**/*.rb")
-```
-
-For any new or modified jobs:
-1. Verify the queue adapter is configured in `production.rb`
-2. Check for job retry logic that might affect rollback
-3. Review `ReadFile.new.call(path: "config/sidekiq.yml")` if using Sidekiq
-4. Verify scheduled/cron jobs if using `sidekiq-cron` or `whenever`
-
-## Step 5: Review Production Log for Pre-deploy Issues
-
-Check that the current production environment is healthy before deploying:
-
-```ruby
-ReadLog.new.call(lines: 100, level: "ERROR")
-```
-
-If there are recent errors, investigate before deploying more changes.
-
-## Step 6: Verify Dependencies and Gem Versions
-
-Check for critical gem updates or changes:
-
-```ruby
-# Review Gemfile for new/modified gems
-RunCommand.new.call(command: "git diff HEAD -- Gemfile")
-```
-
-If adding a gem that needs system dependencies or native extensions:
-```ruby
-RunCommand.new.call(command: "bundle platform")
-```
-
-## Step 7: Config File Checklist
-
-Verify configuration files for the target environment:
-
-```ruby
-ReadFile.new.call(path: "config/environments/production.rb")
-ReadFile.new.call(path: "config/database.yml")
-ReadFile.new.call(path: "config/cable.yml") if File.exist?("config/cable.yml")
-ReadFile.new.call(path: "config/storage.yml") if File.exist?("config/storage.yml")
-```
-
-Key production checks:
-- `config.force_ssl = true`
-- `config.consider_all_requests_local = false`
-- Proper cache store configured (`:mem_cache_store`, `:redis_cache_store`)
-- Active Storage service configured for production
-
-## Step 8: Quick Rollback Checklist
-
-Before deploying, know how to roll back:
-
-1. **Database**: `RunCommand.new.call(command: "bin/rails db:migrate:down VERSION=<previous>")`
-2. **Code**: Git revert the deploy commit
-3. **Assets**: Previous version's assets should still be cached
-4. **Jobs**: Check if backward-incompatible changes won't replay failed jobs
-5. **Feature flags**: If using flipper or similar, toggle off new features first

data/lib/ask/skills/rails.route_trouble/SKILL.md

@@ -1,127 +0,0 @@
----
-name: rails.route_trouble
-description: Step-by-step methodology for debugging routing issues in Rails
----
-
-Use this skill when a route is returning 404, you're getting route matching errors,
-or routes aren't behaving as expected in a Rails application.
-
-## Step 1: Read the Routes File
-
-Start by examining the routes configuration:
-
-```ruby
-ReadRoutes.new.call
-```
-
-This reads `config/routes.rb` — the source of truth for all route definitions.
-
-Look for:
-- The overall structure (namespaced, nested, shallow routes?)
-- Resources that might be missing
-- Constraints or conditions that could block matching
-- Route ordering (more specific routes should come before less specific)
-
-## Step 2: Check the Compiled Routes
-
-Rails routes have a specific matching order. Use `RunCommand` to inspect the live routes:
-
-```ruby
-RunCommand.new.call(command: "bin/rails routes")
-```
-
-If you know the path you're trying to match, grep for it:
-
-```ruby
-RunCommand.new.call(command: "bin/rails routes | grep users")
-```
-
-For a specific route name:
-
-```ruby
-RunCommand.new.call(command: "bin/rails routes --grep user_profile")
-```
-
-## Step 3: Check Route Parameters and Constraints
-
-Routes often fail because of parameter mismatches or constraints. Check for:
-
-**Required parameters:** Does the route define `:id` but the URL doesn't include it?
-
-**Format constraints:** Routes with `:format` (like `.json`, `.html`) constraints
-can fail silently. Check if there's a default format:
-
-```ruby
-# In routes.rb:
-resources :posts, defaults: { format: :json }
-```
-
-**Constraint classes:** Custom route constraints like `subdomain` or request-based
-constraints can prevent matching:
-
-```ruby
-# In routes.rb:
-get "admin", to: "admin/dashboard#show", constraints: ->(req) { req.subdomain == "admin" }
-```
-
-Check the constraints against the actual request parameters.
-
-## Step 4: Trace the Match
-
-For a failing request, trace how Rails would match it:
-
-```ruby
-RunCommand.new.call(
-  command: "bin/rails runner \"puts Rails.application.routes.recognize_path('/users/1/edit', method: :get)\""
-)
-```
-
-This will raise `ActionController::RoutingError` if no route matches — the
-error message tells you what routes were tried before failing.
-
-If the route exists but the controller isn't found:
-
-```ruby
-ReadFile.new.call(path: "app/controllers/users_controller.rb")
-```
-
-## Step 5: Check Namespace and Module Nesting
-
-Routes in namespaced controllers fail when the controller file is in the wrong
-directory or the module is misnamed:
-
-```ruby
-# Route:
-namespace :admin do
-  resources :users
-end
-
-# Expects:
-# app/controllers/admin/users_controller.rb
-# class Admin::UsersController < ApplicationController
-```
-
-Use `Glob` to verify the controller exists:
-
-```ruby
-# Via RunCommand:
-RunCommand.new.call(command: "ls app/controllers/admin/")
-```
-
-## Step 6: Verify Helper Paths and Named Routes
-
-If you're debugging a `No route matches` error from a view (link_to, form_with):
-
-1. Check the route name: `RunCommand.new.call(command: "bin/rails routes | grep user_path")`
-2. Verify the route helper: `RunCommand.new.call(command: "bin/rails routes --grep user")`
-3. Check for route helper overrides in custom constraints or defaults
-
-## Failure Mode Guide
-
-| Symptom | Likely Cause | Action |
-|---------|-------------|--------|
-| 404 for existing route | Route constraint blocking | Check `constraints:` block in routes.rb |
-| `No route matches` | Missing resource definition | Add `resources :model_name` |
-| Route works in dev, not prod | Different route ordering | Check routes file isn't conditionally loaded |
-| `Missing controller` | Wrong namespace or filename | Verify file path matches module structure |
-| Path helper not responding | Wrong route name or params mismatch | Check `bin/rails routes --grep helper_name` |

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

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require "rails/generators"
-
-module Ask
-  module Rails
-    module Generators
-      class InstallGenerator < ::Rails::Generators::Base
-        source_root File.expand_path("templates", __dir__)
-
-        desc "Creates ask-rails configuration and migration"
-
-        def create_initializer
-          template "initializer.rb", "config/initializers/ask_rails.rb"
-        end
-
-        def create_migration
-          timestamp = Time.now.utc.strftime("%Y%m%d%H%M%S")
-          template "migration.rb", "db/migrate/#{timestamp}_create_ask_sessions.rb"
-        end
-
-        def create_tools_directory
-          empty_directory "app/tools"
-          create_file "app/tools/.keep", ""
-        end
-      end
-    end
-  end
-end

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

@@ -1,5 +0,0 @@
-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
-end

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

@@ -1,12 +0,0 @@
-class CreateAskSessions < ActiveRecord::Migration[7.1]
-  def change
-    create_table :ask_sessions do |t|
-      t.string :session_id, null: false
-      t.string :model
-      t.jsonb :data, default: {}
-      t.timestamps
-    end
-
-    add_index :ask_sessions, :session_id, unique: true
-  end
-end