rails_console_ai 0.35.0 → 0.38.0

data/lib/rails_console_ai/tools/registry.rb

@@ -6,7 +6,7 @@ module RailsConsoleAi
       attr_reader :definitions, :last_sub_agent_usage
 
       # Tools that should never be cached (side effects or user interaction)
-      NO_CACHE = %w[ask_user save_memory delete_memory recall_memory execute_code execute_plan activate_skill save_skill delete_skill save_agent delete_agent delegate_task explore_output].freeze
+      NO_CACHE = %w[ask_user save_memory delete_memory recall_memory execute_code execute_plan activate_skill save_skill delete_skill save_agent delete_agent delegate_task explore_output save_artifact list_artifacts read_artifact delete_artifact].freeze
 
       def initialize(executor: nil, mode: :default, channel: nil, allowed_tools: nil)
         @executor = executor
@@ -258,6 +258,236 @@ module RailsConsoleAi
             register_execute_plan
             register_delegate_task
           end
+
+          register_artifact_tools
+        end
+      end
+
+      ARTIFACT_TYPES = %w[text/html text/markdown text/csv application/json text/plain].freeze
+
+      # How much of an artifact read_artifact returns inline before handing back
+      # an output_id instead. A full report would otherwise swamp the context.
+      ARTIFACT_READ_LIMIT = 12_000
+
+      def register_artifact_tools
+        register(
+          name: 'save_artifact',
+          description: 'Save a generated file — an HTML report, a CSV extract, a JSON dump — so the user can open it in a browser ' \
+            'instead of reading it in the console. Use this whenever the user asks for a summary, report, export or page, ' \
+            'or whenever the output is a document rather than an answer. ' \
+            'Returns a URL to view it. Prefer this over printing hundreds of lines of HTML or CSV into the transcript. ' \
+            'New artifacts are stamped with today\'s date automatically — pass a plain title like "Q3 churn summary", ' \
+            'not a dated one. Saving under a name that already exists REPLACES its content and bumps its revision; ' \
+            'to revise an artifact from an earlier day pass its exact handle (e.g. "20260911_Q3 churn summary") as the name, ' \
+            'and call read_artifact first if you need to keep most of what is already there. ' \
+            'HTML is rendered in a sandboxed frame: inline CSS works, but scripts never run, so do not rely on JavaScript ' \
+            'or on loading anything over the network — inline all styles and embed any data directly. ' \
+            'IMPORTANT: content must be the complete literal text, never a placeholder to fill in later. ' \
+            'If the content already exists as a value in the console — a file you read, a string you built — do NOT ' \
+            'retype it here. Your response has an output-token limit and a large file will be cut off mid-argument, ' \
+            'discarding the call. Use execute_code instead and save it directly from Ruby: ' \
+            'RailsConsoleAi.save_artifact(name: "Q3 churn summary", content: the_string). Same naming and revision ' \
+            'rules, and it returns the URL.',
+          parameters: {
+            'type' => 'object',
+            'properties' => {
+              'name' => { 'type' => 'string', 'description' => 'Short title, e.g. "Q3 churn summary". Reusing an existing name updates that artifact.' },
+              'content_type' => {
+                'type' => 'string',
+                'enum' => ARTIFACT_TYPES,
+                'description' => 'MIME type of the content'
+              },
+              'content' => { 'type' => 'string', 'description' => 'The full, literal file content — not a placeholder. Replaces the previous content entirely. For content that already exists as a console value, use RailsConsoleAi.save_artifact from execute_code instead.' },
+              'description' => { 'type' => 'string', 'description' => 'Optional one-line note about what this is and how it was built' }
+            },
+            'required' => ['name', 'content_type', 'content']
+          },
+          handler: ->(args) {
+            save_artifact(args['name'], args['content_type'], args['content'], args['description'])
+          }
+        )
+
+        register(
+          name: 'list_artifacts',
+          description: 'List saved artifacts, newest first, with the handle each one is addressed by. ' \
+            'Call this when the user refers to an artifact from an earlier session ("update the churn report") ' \
+            'and you do not already know its handle.',
+          parameters: {
+            'type' => 'object',
+            'properties' => {
+              'search' => { 'type' => 'string', 'description' => 'Optional filter over name and description' }
+            },
+            'required' => []
+          },
+          handler: ->(args) { list_artifacts(args['search']) }
+        )
+
+        register(
+          name: 'read_artifact',
+          description: 'Read back the content of a saved artifact so you can revise it. ' \
+            'Accepts the handle, the name, or the token from its URL.',
+          parameters: {
+            'type' => 'object',
+            'properties' => {
+              'handle' => { 'type' => 'string', 'description' => 'Handle, name, or token, e.g. "q3-churn-summary"' }
+            },
+            'required' => ['handle']
+          },
+          handler: ->(args) { read_artifact(args['handle']) }
+        )
+
+        register(
+          name: 'delete_artifact',
+          description: 'Delete a saved artifact. Only when the user asks for it to be removed.',
+          parameters: {
+            'type' => 'object',
+            'properties' => {
+              'handle' => { 'type' => 'string', 'description' => 'Handle, name, or token' }
+            },
+            'required' => ['handle']
+          },
+          handler: ->(args) { delete_artifact(args['handle']) }
+        )
+      end
+
+      # Referencing the constant is what makes Rails autoload it. `defined?` does
+      # not: under autoloading the constant is absent until something asks for it
+      # by name, so a `defined?` guard reports "no model" in a perfectly healthy
+      # app and the tool never runs. NameError is the real "no engine here" case.
+      def artifact_model
+        RailsConsoleAi::Artifact
+      rescue NameError
+        nil
+      end
+
+      # Nil when artifacts can't be used at all; otherwise the model class.
+      # Returns the explanation as a String so each tool can hand it straight back.
+      def artifact_store
+        model = artifact_model
+        return [nil, 'artifacts need the Rails engine loaded.'] unless model
+        unless model.available?
+          return [nil, 'the rails_console_ai_artifacts table does not exist. ' \
+                       'Ask the user to run `ai_db_setup` in the Rails console, then try again.']
+        end
+        [model, nil]
+      end
+
+      # Addressed by slug so the link itself says what it points at. Absolute
+      # when the app's base URL is known: this string is read in a terminal,
+      # pasted into Slack and opened on a phone, none of which resolve a path.
+      def artifact_url(artifact)
+        "#{RailsConsoleAi.base_url}#{RailsConsoleAi.engine_mount_path}/artifacts/#{artifact.slug}"
+      end
+
+      # The write itself lives on the model, shared with RailsConsoleAi.save_artifact
+      # so a console-side save and a tool-side save land identically.
+      def save_artifact(name, content_type, content, description = nil)
+        model, problem = artifact_store
+        return "FAILED to save artifact: #{problem}" if problem
+
+        existing = model.find_by(slug: model.slug_for(model.stamped_name(name)))
+        verb = existing ? 'updated' : 'saved'
+
+        artifact = model.store(name: name, content_type: content_type,
+                               content: content, description: description)
+
+        if artifact.errors.any? || artifact.new_record?
+          return "FAILED to save artifact: #{artifact.errors.full_messages.join('; ')}"
+        end
+
+        url = artifact_url(artifact)
+        revision_note = existing ? " revision #{artifact.revision}," : ''
+        if @channel
+          @channel.display_status("  Artifact #{verb}: #{artifact.name} (#{artifact.human_size}) #{url}")
+        end
+        "Artifact #{verb}: \"#{artifact.name}\" (handle: #{artifact.slug},#{revision_note} " \
+          "#{artifact.content_type}, #{artifact.human_size}). " \
+          "The user can view it at #{url} — give them that URL. " \
+          "Refer to it later as #{artifact.slug}."
+      rescue ::ActiveRecord::ActiveRecordError => e
+        "FAILED to save artifact (#{e.class}: #{e.message})."
+      end
+
+      def list_artifacts(search = nil)
+        model, problem = artifact_store
+        return "FAILED to list artifacts: #{problem}" if problem
+
+        scope = model.newest_first
+        search = search.to_s.strip
+        unless search.empty?
+          needle = "%#{search.downcase}%"
+          scope = scope.where("LOWER(name) LIKE :q OR LOWER(COALESCE(description, '')) LIKE :q", q: needle)
+        end
+
+        rows = scope.limit(50).to_a
+        if rows.empty?
+          return search.empty? ? 'No artifacts saved yet.' : "No artifacts match #{search.inspect}."
+        end
+
+        lines = rows.map { |a|
+          bits = ["#{a.slug} — \"#{a.name}\"", a.content_type, a.human_size]
+          bits << "rev #{a.revision}" if a.revision.to_i > 1
+          bits << a.updated_at.strftime('%Y-%m-%d')
+          line = bits.join(', ')
+          line += "\n    #{a.description}" if a.description.present?
+          "- #{line}"
+        }
+        "#{rows.length} artifact#{rows.length == 1 ? '' : 's'} (address one by its handle):\n#{lines.join("\n")}"
+      rescue ::ActiveRecord::ActiveRecordError => e
+        "FAILED to list artifacts (#{e.class}: #{e.message})."
+      end
+
+      def read_artifact(handle)
+        model, problem = artifact_store
+        return "FAILED to read artifact: #{problem}" if problem
+
+        artifact = model.find_by_handle(handle)
+        return artifact_not_found(model, handle) unless artifact
+
+        header = "Artifact \"#{artifact.name}\" (handle: #{artifact.slug}, #{artifact.content_type}, " \
+                 "#{artifact.human_size}, revision #{artifact.revision}):\n"
+
+        body = artifact.content.to_s
+        return header + body if body.length <= ARTIFACT_READ_LIMIT
+
+        # Same escape hatch large tool results use: keep the head, park the rest
+        # where explore_output can query it rather than flooding the context.
+        output_id = @executor && @executor.store_output(body)
+        preview = body[0, ARTIFACT_READ_LIMIT]
+        tail = if output_id
+                 "\n\n[Truncated at #{ARTIFACT_READ_LIMIT} of #{body.length} chars — " \
+                 "use explore_output with output_id=#{output_id} to query the rest, " \
+                 "or recall_output to expand it in place]"
+               else
+                 "\n\n[Truncated at #{ARTIFACT_READ_LIMIT} of #{body.length} chars]"
+               end
+        header + preview + tail
+      rescue ::ActiveRecord::ActiveRecordError => e
+        "FAILED to read artifact (#{e.class}: #{e.message})."
+      end
+
+      def delete_artifact(handle)
+        model, problem = artifact_store
+        return "FAILED to delete artifact: #{problem}" if problem
+
+        artifact = model.find_by_handle(handle)
+        return artifact_not_found(model, handle) unless artifact
+
+        name = artifact.name
+        slug = artifact.slug
+        artifact.destroy
+        @channel.display_status("  Deleted artifact: #{name}") if @channel
+        "Artifact deleted: \"#{name}\" (#{slug})."
+      rescue ::ActiveRecord::ActiveRecordError => e
+        "FAILED to delete artifact (#{e.class}: #{e.message})."
+      end
+
+      def artifact_not_found(model, handle)
+        available = model.newest_first.limit(20).pluck(:slug)
+        if available.empty?
+          "No artifact found for #{handle.inspect}. There are no saved artifacts."
+        else
+          "No artifact found for #{handle.inspect}. Available handles: #{available.join(', ')}"
         end
       end
 
@@ -381,7 +611,7 @@ module RailsConsoleAi
         # the live database. Scoped via thread-local (explore_output runs synchronously),
         # so the parent session's guard state is untouched.
         result = RailsConsoleAi.configuration.safety_guards.with_database_blocked { sub.run }
-        @last_sub_agent_usage = { input: sub.input_tokens, output: sub.output_tokens, model: sub.model_used }
+        @last_sub_agent_usage = { input: sub.input_tokens, output: sub.output_tokens, model: sub.model_used, cost: sub.cost }
         "Exploration result (#{sub.input_tokens + sub.output_tokens} tokens used, #{payload.length} chars explored):\n#{result}"
       end
 
@@ -418,7 +648,7 @@ module RailsConsoleAi
           executor: @executor
         )
         result = sub.run
-        @last_sub_agent_usage = { input: sub.input_tokens, output: sub.output_tokens, model: sub.model_used }
+        @last_sub_agent_usage = { input: sub.input_tokens, output: sub.output_tokens, model: sub.model_used, cost: sub.cost }
         "Sub-agent result (#{sub.input_tokens + sub.output_tokens} tokens used):\n#{result}"
       end
 

data/lib/rails_console_ai/version.rb

@@ -1,3 +1,3 @@
 module RailsConsoleAi
-  VERSION = '0.35.0'.freeze
+  VERSION = '0.38.0'.freeze
 end

data/lib/rails_console_ai.rb

@@ -57,6 +57,146 @@ module RailsConsoleAi
       @current_user = name
     end
 
+    # Scheme + host for links the gem hands out, without a trailing slash.
+    # Empty string when nothing is configured and Rails has no url options, in
+    # which case callers fall back to a relative path.
+    def base_url
+      configured = configuration.base_url.to_s.strip
+      return normalize_base_url(configured) unless configured.empty?
+
+      from_rails = rails_default_url_base
+      from_rails ? normalize_base_url(from_rails) : ''
+    end
+
+    def normalize_base_url(value)
+      value = value.to_s.strip.chomp('/')
+      return '' if value.empty?
+      # Forgiving about a host given without a scheme — "secure.apptoto.com".
+      value = "https://#{value}" unless value =~ %r{\A[a-z][a-z0-9+.-]*://}i
+      value
+    end
+
+    # Most apps already declare their canonical host for mailers or url helpers.
+    def rails_default_url_base
+      return nil unless defined?(::Rails) && ::Rails.respond_to?(:application) && ::Rails.application
+
+      opts = ::Rails.application.routes.default_url_options
+      opts = nil if opts.nil? || opts[:host].to_s.empty?
+
+      if opts.nil?
+        mailer = ::Rails.application.config.action_mailer.default_url_options rescue nil
+        opts = mailer if mailer && !mailer[:host].to_s.empty?
+      end
+      return nil unless opts && !opts[:host].to_s.empty?
+
+      protocol = opts[:protocol].to_s.sub(%r{://\z}, '')
+      protocol = 'https' if protocol.empty?
+      port = opts[:port]
+      host = opts[:host].to_s.chomp('/')
+      port_part = port && ![80, 443, '80', '443'].include?(port) ? ":#{port}" : ''
+      "#{protocol}://#{host}#{port_part}"
+    rescue StandardError
+      nil
+    end
+
+    # Where the host app mounted the engine, so a tool can hand the user a URL
+    # that actually resolves. Discovered from the route table rather than assumed,
+    # since the mount point is the host's choice.
+    def engine_mount_path
+      return @engine_mount_path if defined?(@engine_mount_path) && @engine_mount_path
+
+      @engine_mount_path =
+        begin
+          found = nil
+          if defined?(::Rails) && ::Rails.respond_to?(:application) && ::Rails.application
+            ::Rails.application.routes.routes.each do |route|
+              app = route.app
+              # Mounted engines sit behind one or more wrappers; unwrap a bounded
+              # number of times rather than trusting the shape of any one Rails version.
+              5.times do
+                break unless app.respond_to?(:app) && !app.app.equal?(app)
+                app = app.app
+              end
+              next unless app == RailsConsoleAi::Engine
+
+              found = route.path.spec.to_s.sub(/\(\.:format\)\z/, '').chomp('/')
+              break
+            end
+          end
+          found.to_s.empty? ? '/rails_console_ai' : found
+        rescue StandardError
+          '/rails_console_ai'
+        end
+    end
+
+    # Where a logged session can be read back. Relative when no host is known.
+    def session_url(id)
+      "#{base_url}#{engine_mount_path}/sessions/#{id}"
+    end
+
+    # The session row the current turn belongs to, so tools that persist
+    # something (save_artifact) can point back at the conversation that produced
+    # it. Set by the engine as it logs each turn; nil outside a logged session.
+    def current_session_id
+      @current_session_id
+    end
+
+    def current_session_id=(id)
+      @current_session_id = id
+    end
+
+    # Save an artifact from Ruby, for content the console already holds.
+    #
+    #   html = S3.read_file("report.html")
+    #   RailsConsoleAi.save_artifact(name: "Mathnasium migration", content: html)
+    #
+    # This exists because the save_artifact TOOL can only carry content the model
+    # types out into its response, and a response has a hard output-token cap. A
+    # 40KB file does not fit under it: the call is cut off mid-argument, discarded,
+    # and retried identically forever. Going through Ruby, the bytes never enter
+    # the model's response at all — and what lands in the artifact is the string
+    # itself, byte for byte, not the model's recollection of it.
+    #
+    # Returns the URL. Saving under a name that already exists replaces that
+    # artifact and bumps its revision, exactly as the tool does.
+    def save_artifact(name:, content:, content_type: nil, description: nil)
+      model = artifact_model
+      raise 'Artifacts need the Rails engine loaded.' unless model
+      unless model.available?
+        raise "The rails_console_ai_artifacts table does not exist. Run `ai_db_setup` first."
+      end
+
+      content_type ||= model.infer_content_type(content)
+      # Called from inside execute_code, this INSERT would otherwise be stopped by
+      # the database_writes guard — which is the whole point of safe mode, except
+      # that the target is the gem's own artifacts table. The save_artifact tool
+      # writes to it unguarded already, being a tool rather than eval'd code; this
+      # is the same write reached a different way, so it gets the same exemption.
+      # Scoped to the one save, nothing the caller passes runs inside it.
+      artifact = configuration.safety_guards.without_guards do
+        model.store(name: name, content: content,
+                    content_type: content_type, description: description)
+      end
+      if artifact.errors.any?
+        raise ArgumentError, "Could not save artifact: #{artifact.errors.full_messages.join('; ')}"
+      end
+
+      "#{base_url}#{engine_mount_path}/artifacts/#{artifact.slug}"
+    end
+
+    # Fully qualified on purpose. A bare `Artifact` here reads as
+    # RailsConsoleAi::Artifact to Ruby, but the enclosing scope is the singleton
+    # class — an anonymous module — so once Rails' autoloader is the one
+    # resolving it, const_missing has no namespace to derive from and goes
+    # looking for a top-level Artifact that does not exist. Referencing the full
+    # path is also what triggers the autoload in the first place; `defined?`
+    # would report "no engine" in a perfectly healthy app.
+    def artifact_model
+      RailsConsoleAi::Artifact
+    rescue NameError
+      nil
+    end
+
     # Enqueue an agent run. Returns the Integer session id immediately;
     # the actual work is picked up by `rake rails_console_ai:agents`.
     #
@@ -125,6 +265,7 @@ module RailsConsoleAi
       lines << "  Model:          #{c.resolved_model}"
       lines << "  API key:        #{masked_key}"
       lines << "  Local URL:      #{c.local_url}" if c.provider == :local
+      lines << "  OpenRouter URL: #{c.openrouter_url}" if c.openrouter_url
       lines << "  Max tokens:     #{c.max_tokens || '(auto)'}"
       lines << "  Temperature:    #{c.temperature}"
       lines << "  Timeout:        #{c.timeout}s"
@@ -184,6 +325,7 @@ module RailsConsoleAi
       setup_skills_tables!(conn)
       setup_memories_tables!(conn)
       setup_agents_tables!(conn)
+      setup_artifacts_table!(conn)
 
       migrate!
     rescue => e
@@ -351,6 +493,80 @@ module RailsConsoleAi
       end
     end
 
+    def setup_artifacts_table!(conn)
+      table = 'rails_console_ai_artifacts'
+      return if conn.table_exists?(table)
+
+      conn.create_table(table) do |t|
+        t.string   :name,         limit: 255, null: false
+        # Stable handle derived from the name, so the assistant can be told
+        # "update the churn summary" in a later session and find the same row.
+        t.string   :slug,         limit: 255, null: false
+        t.text     :description
+        t.string   :content_type, limit: 100, null: false
+        t.text     :content,      null: false
+        t.integer  :byte_size,    default: 0, null: false
+        t.integer  :revision,     default: 1, null: false
+        # Addressed by an unguessable token rather than a sequential id, so a
+        # shared link can't be walked to the neighbouring artifact.
+        t.string   :token,        limit: 64,  null: false
+        t.integer  :session_id
+        t.string   :created_by,   limit: 255
+        t.datetime :created_at,   null: false
+        t.datetime :updated_at,   null: false
+      end
+
+      conn.add_index(table, :token, unique: true)
+      conn.add_index(table, :slug, unique: true)
+      conn.add_index(table, :created_at)
+      conn.add_index(table, :session_id)
+      $stdout.puts "\e[32mRailsConsoleAi: created #{table} table.\e[0m"
+    end
+
+    # Brings an artifacts table created before slugs existed up to date, and
+    # backfills a handle for every row already in it.
+    def upgrade_artifacts_table!(conn)
+      table = 'rails_console_ai_artifacts'
+      return [] unless conn.table_exists?(table)
+
+      added = []
+
+      unless conn.column_exists?(table, :revision)
+        conn.add_column(table, :revision, :integer, default: 1, null: false)
+        added << "#{table}.revision"
+      end
+
+      unless conn.column_exists?(table, :slug)
+        # Added nullable, backfilled, and only then made unique — an existing
+        # table has rows that need a handle before the index can be built.
+        conn.add_column(table, :slug, :string, limit: 255)
+        backfill_artifact_slugs!(conn, table)
+        conn.add_index(table, :slug, unique: true) unless conn.index_exists?(table, :slug)
+        added << "#{table}.slug"
+      end
+
+      added
+    end
+
+    def backfill_artifact_slugs!(conn, table)
+      require 'rails_console_ai/slash_commands'
+      seen = {}
+      rows = conn.select_all("SELECT id, name FROM #{table} WHERE slug IS NULL ORDER BY id")
+      rows.each do |row|
+        base = RailsConsoleAi::SlashCommands.slugify(row['name'])
+        base = "artifact-#{row['id']}" if base.empty?
+        slug = base
+        n = 1
+        # Two rows can share a name; the older one keeps the bare handle.
+        while seen.key?(slug) || conn.select_value("SELECT 1 FROM #{table} WHERE slug = #{conn.quote(slug)} LIMIT 1")
+          n += 1
+          slug = "#{base}-#{n}"
+        end
+        seen[slug] = true
+        conn.execute("UPDATE #{table} SET slug = #{conn.quote(slug)} WHERE id = #{row['id'].to_i}")
+      end
+    end
+
     def migrate!
       conn = session_connection
       table = 'rails_console_ai_sessions'
@@ -434,6 +650,13 @@ module RailsConsoleAi
       setup_memories_tables!(conn)
       setup_agents_tables!(conn)
 
+      if conn.table_exists?('rails_console_ai_artifacts')
+        migrations.concat(upgrade_artifacts_table!(conn))
+      else
+        setup_artifacts_table!(conn)
+        migrations << 'rails_console_ai_artifacts'
+      end
+
       [[:skills, 'rails_console_ai_skills'], [:memories, 'rails_console_ai_memories'], [:agents, 'rails_console_ai_agents']].each do |key, name|
         post = table_columns(conn, name)
         added = post - pre_columns[key]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_console_ai
 version: !ruby/object:Gem::Version
-  version: 0.35.0
+  version: 0.38.0
 platform: ruby
 authors:
 - Cortfr
@@ -106,6 +106,7 @@ files:
 - app/controllers/rails_console_ai/agent_versions_controller.rb
 - app/controllers/rails_console_ai/agents_controller.rb
 - app/controllers/rails_console_ai/application_controller.rb
+- app/controllers/rails_console_ai/artifacts_controller.rb
 - app/controllers/rails_console_ai/memories_controller.rb
 - app/controllers/rails_console_ai/memory_versions_controller.rb
 - app/controllers/rails_console_ai/sessions_controller.rb
@@ -115,6 +116,7 @@ files:
 - app/helpers/rails_console_ai/sessions_helper.rb
 - app/models/rails_console_ai/agent.rb
 - app/models/rails_console_ai/agent_version.rb
+- app/models/rails_console_ai/artifact.rb
 - app/models/rails_console_ai/memory.rb
 - app/models/rails_console_ai/memory_version.rb
 - app/models/rails_console_ai/session.rb
@@ -129,6 +131,8 @@ files:
 - app/views/rails_console_ai/agents/index.html.erb
 - app/views/rails_console_ai/agents/new.html.erb
 - app/views/rails_console_ai/agents/show.html.erb
+- app/views/rails_console_ai/artifacts/index.html.erb
+- app/views/rails_console_ai/artifacts/show.html.erb
 - app/views/rails_console_ai/memories/_form.html.erb
 - app/views/rails_console_ai/memories/diff.html.erb
 - app/views/rails_console_ai/memories/edit.html.erb
@@ -166,18 +170,21 @@ files:
 - lib/rails_console_ai/conversation_engine.rb
 - lib/rails_console_ai/engine.rb
 - lib/rails_console_ai/executor.rb
+- lib/rails_console_ai/line_editor.rb
 - lib/rails_console_ai/prefixed_io.rb
 - lib/rails_console_ai/providers/anthropic.rb
 - lib/rails_console_ai/providers/base.rb
 - lib/rails_console_ai/providers/bedrock.rb
 - lib/rails_console_ai/providers/local.rb
 - lib/rails_console_ai/providers/openai.rb
+- lib/rails_console_ai/providers/openrouter.rb
 - lib/rails_console_ai/railtie.rb
 - lib/rails_console_ai/repl.rb
 - lib/rails_console_ai/safety_guards.rb
 - lib/rails_console_ai/session_logger.rb
 - lib/rails_console_ai/skill_loader.rb
 - lib/rails_console_ai/slack_bot.rb
+- lib/rails_console_ai/slash_commands.rb
 - lib/rails_console_ai/storage/base.rb
 - lib/rails_console_ai/storage/database_storage.rb
 - lib/rails_console_ai/storage/file_storage.rb