rails_console_ai 0.36.0 → 0.38.0

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`.
     #
@@ -185,6 +325,7 @@ module RailsConsoleAi
       setup_skills_tables!(conn)
       setup_memories_tables!(conn)
       setup_agents_tables!(conn)
+      setup_artifacts_table!(conn)
 
       migrate!
     rescue => e
@@ -352,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'
@@ -435,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.36.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