rails_console_ai 0.30.0 → 0.31.0

data/lib/rails_console_ai/agent_runner.rb

@@ -1,3 +1,4 @@
+require 'json'
 require 'rails_console_ai/prefixed_io'
 require 'rails_console_ai/session_logger'
 require 'rails_console_ai/channel/api'
@@ -7,6 +8,8 @@ require 'rails_console_ai/providers/base'
 require 'rails_console_ai/executor'
 
 module RailsConsoleAi
+  class RunnerTimeoutError < StandardError; end
+
   # Long-running worker that polls the sessions table for queued agent_api
   # rows, claims them atomically, and runs each in its own Thread via
   # ConversationEngine#one_shot. Started by `rake rails_console_ai:agents`.
@@ -87,13 +90,20 @@ module RailsConsoleAi
 
     def spawn(session)
       tag = "[agent/#{session.id}] @#{session.user_name || '?'}"
-      puts "#{tag} << #{session.query.to_s.strip}"
+      opts = parse_options(session)
+      banner_extras = []
+      banner_extras << 'thinking' if opts['use_thinking_model']
+      if (cap = opts['max_wall_clock_seconds'])
+        banner_extras << "cap=#{cap}s"
+      end
+      banner = banner_extras.empty? ? '' : " (#{banner_extras.join(', ')})"
+      puts "#{tag}#{banner} << #{session.query.to_s.strip}"
 
       t = Thread.new do
         Thread.current.report_on_exception = false
         Thread.current[:log_prefix] = tag
         begin
-          run_one(session)
+          run_one(session, opts)
         ensure
           ActiveRecord::Base.clear_active_connections! if defined?(ActiveRecord::Base)
         end
@@ -101,13 +111,27 @@ module RailsConsoleAi
       @mutex.synchronize { @threads[session.id] = t }
     end
 
-    def run_one(session)
+    def parse_options(session)
+      raw = session.respond_to?(:options) ? session.options : nil
+      return {} if raw.nil? || raw.to_s.empty?
+      return raw if raw.is_a?(Hash)
+      JSON.parse(raw)
+    rescue => e
+      warn "AgentRunner: failed to parse session.options (#{e.class}: #{e.message}); ignoring."
+      {}
+    end
+
+    def run_one(session, opts = nil)
+      opts ||= parse_options(session)
       started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       channel = Channel::Api.new(user_name: session.user_name)
       sandbox_binding = Object.new.instance_eval { binding }
       engine = ConversationEngine.new(binding_context: sandbox_binding, channel: channel)
+      engine.upgrade_to_thinking_model if opts['use_thinking_model']
 
-      exec_result = engine.one_shot(session.query, existing_session_id: session.id)
+      exec_result = run_with_deadline(opts['max_wall_clock_seconds']) do
+        engine.one_shot(session.query, existing_session_id: session.id)
+      end
       result_text = compose_result(channel.captured_output, exec_result)
 
       SessionLogger.update(session.id, status: 'ready', result: result_text)
@@ -116,6 +140,9 @@ module RailsConsoleAi
       preview = result_text.to_s.strip.lines.first.to_s.strip
       preview = preview[0, 120] + '…' if preview.length > 120
       puts ">> ready (#{elapsed}ms) #{preview}"
+    rescue RunnerTimeoutError => e
+      warn ">> TIMEOUT #{e.message}"
+      SessionLogger.update(session.id, status: 'failed', error_message: e.message)
     rescue => e
       warn ">> FAILED #{e.class}: #{e.message}"
       e.backtrace&.first(5)&.each { |line| warn "   #{line}" }
@@ -125,6 +152,30 @@ module RailsConsoleAi
       )
     end
 
+    # When cap is nil or non-positive, run inline. Otherwise spawn a nested
+    # worker thread, join with the deadline, and kill + raise on overshoot.
+    # Kept localized (vs Timeout.timeout) so a runaway provider call can't
+    # raise from inside our own bookkeeping code.
+    def run_with_deadline(cap)
+      return yield if cap.nil? || cap.to_f <= 0
+      result = nil
+      error = nil
+      worker = Thread.new do
+        Thread.current.report_on_exception = false
+        begin
+          result = yield
+        rescue => e
+          error = e
+        end
+      end
+      if worker.join(cap.to_f).nil?
+        worker.kill
+        raise RunnerTimeoutError, "exceeded max_wall_clock_seconds (#{cap}s)"
+      end
+      raise error if error
+      result
+    end
+
     # Build the `result` payload returned via get_agent_response. The
     # LLM's prose lands in the channel's captured_output; the value the
     # generated code returned lands in exec_result. Without including the

data/lib/rails_console_ai/session_logger.rb

@@ -28,6 +28,10 @@ module RailsConsoleAi
         create_attrs[:status]            = attrs[:status]            if attrs.key?(:status)
         create_attrs[:result]            = attrs[:result]            if attrs.key?(:result)
         create_attrs[:error_message]     = attrs[:error_message]     if attrs.key?(:error_message)
+        if attrs.key?(:options)
+          opts = attrs[:options]
+          create_attrs[:options] = opts.is_a?(String) ? opts : opts.to_json
+        end
         record = session_class.create!(create_attrs)
         record.id
       rescue => e

data/lib/rails_console_ai/skill_loader.rb

@@ -122,15 +122,10 @@ module RailsConsoleAi
       key = skill_key(name)
       existing = load_skill_file(key)
 
-      frontmatter = {
-        'name' => name,
-        'description' => description,
-        'tags' => Array(tags)
-      }
-      bypasses = Array(bypass_guards_for_methods)
-      frontmatter['bypass_guards_for_methods'] = bypasses unless bypasses.empty?
-
-      content = "---\n#{YAML.dump(frontmatter).sub("---\n", '').strip}\n---\n\n#{body}\n"
+      content = self.class.dump(
+        name: name, description: description, body: body,
+        tags: tags, bypass_guards_for_methods: bypass_guards_for_methods
+      )
       @storage.write(key, content)
 
       path = @storage.respond_to?(:root_path) ? File.join(@storage.root_path, key) : key
@@ -190,5 +185,19 @@ module RailsConsoleAi
     rescue Psych::SyntaxError
       nil
     end
+
+    # Inverse of parse: emit a canonical .md (frontmatter + body) string from
+    # structured attrs. Used by AI tool callers and file-fallback writers so
+    # the on-disk and DB representations stay byte-identical.
+    def self.dump(name:, description:, body:, tags: [], bypass_guards_for_methods: [])
+      frontmatter = {
+        'name' => name,
+        'description' => description,
+        'tags' => Array(tags)
+      }
+      bypasses = Array(bypass_guards_for_methods)
+      frontmatter['bypass_guards_for_methods'] = bypasses unless bypasses.empty?
+      "---\n#{YAML.dump(frontmatter).sub("---\n", '').strip}\n---\n\n#{body}\n"
+    end
   end
 end

data/lib/rails_console_ai/storage/database_storage.rb

@@ -68,14 +68,12 @@ module RailsConsoleAi
         record = RailsConsoleAi::Skill.where('LOWER(name) = ?', name.to_s.downcase).first
         record ||= RailsConsoleAi::Skill.new
         was_new = record.new_record?
+        content = RailsConsoleAi::SkillLoader.dump(
+          name: name, description: description, body: body,
+          tags: tags, bypass_guards_for_methods: bypass_guards_for_methods
+        )
         record.update_with_version!(
-          {
-            name:                      name,
-            description:               description,
-            body:                      body,
-            tags:                      Array(tags),
-            bypass_guards_for_methods: Array(bypass_guards_for_methods)
-          },
+          { content: content },
           edited_by: edited_by,
           change_note: change_note
         )
@@ -114,12 +112,11 @@ module RailsConsoleAi
         record = RailsConsoleAi::Memory.where('LOWER(name) = ?', name.to_s.downcase).first
         record ||= RailsConsoleAi::Memory.new
         was_new = record.new_record?
+        content = RailsConsoleAi::Tools::MemoryTools.dump(
+          name: name, description: description, tags: tags
+        )
         record.update_with_version!(
-          {
-            name:        name,
-            description: description,
-            tags:        Array(tags)
-          },
+          { content: content },
           edited_by: edited_by,
           change_note: change_note
         )
@@ -158,15 +155,12 @@ module RailsConsoleAi
         record = RailsConsoleAi::Agent.where('LOWER(name) = ?', name.to_s.downcase).first
         record ||= RailsConsoleAi::Agent.new
         was_new = record.new_record?
+        content = RailsConsoleAi::AgentLoader.dump(
+          name: name, description: description, body: body,
+          max_rounds: max_rounds, model: model, tools: tools
+        )
         record.update_with_version!(
-          {
-            name:        name,
-            description: description,
-            body:        body,
-            max_rounds:  max_rounds,
-            model:       model,
-            tools:       Array(tools)
-          },
+          { content: content },
           edited_by: edited_by,
           change_note: change_note
         )

data/lib/rails_console_ai/tools/memory_tools.rb

@@ -211,6 +211,14 @@ module RailsConsoleAi
         nil
       end
 
+      # Inverse of parse: emit a canonical .md string. The DB store uses this
+      # minimal form (name + tags only in frontmatter); the file store layers
+      # created_at/updated_at on top via save_memory_to_file.
+      def self.dump(name:, description:, tags: [])
+        frontmatter = { 'name' => name, 'tags' => Array(tags) }
+        "---\n#{YAML.dump(frontmatter).sub("---\n", '').strip}\n---\n\n#{description}\n"
+      end
+
       def find_memory_key_by_name(name)
         keys = @storage.list("#{MEMORIES_DIR}/*.md")
         keys.find do |key|

data/lib/rails_console_ai/version.rb

@@ -1,3 +1,3 @@
 module RailsConsoleAi
-  VERSION = '0.30.0'.freeze
+  VERSION = '0.31.0'.freeze
 end

data/lib/rails_console_ai.rb

@@ -57,8 +57,17 @@ module RailsConsoleAi
 
     # Enqueue an agent run. Returns the Integer session id immediately;
     # the actual work is picked up by `rake rails_console_ai:agents`.
-    def run_agent(query, name: nil, user_name: nil)
+    #
+    # use_thinking_model:     run on the configured thinking-tier model
+    # max_wall_clock_seconds: hard kill the run after N seconds (nil = no cap)
+    def run_agent(query, name: nil, user_name: nil,
+                  use_thinking_model: false,
+                  max_wall_clock_seconds: 600)
       require 'rails_console_ai/session_logger'
+      options = {
+        'use_thinking_model'     => !!use_thinking_model,
+        'max_wall_clock_seconds' => max_wall_clock_seconds
+      }
       id = SessionLogger.log(
         query: query,
         conversation: [],
@@ -66,7 +75,8 @@ module RailsConsoleAi
         name: name,
         user_name: user_name,
         status: 'queued',
-        executed: false
+        executed: false,
+        options: options
       )
       raise 'Failed to enqueue agent run (session logging disabled or table missing)' unless id
       id
@@ -145,6 +155,7 @@ module RailsConsoleAi
           t.string  :slack_thread_ts, limit: 255
           t.string  :slack_channel_name, limit: 255
           t.integer :duration_ms
+          t.text    :options
           t.datetime :created_at,   null: false
         end
 
@@ -169,13 +180,22 @@ module RailsConsoleAi
       skills_table   = 'rails_console_ai_skills'
       versions_table = 'rails_console_ai_skill_versions'
 
+      # Old shape had per-field columns (body, tags, bypass_guards_for_methods,
+      # description). New shape stores the raw .md in `content`. Pre-production,
+      # so we drop and recreate when the old shape is detected.
+      if conn.table_exists?(skills_table) && !conn.column_exists?(skills_table, :content)
+        conn.drop_table(skills_table)
+        $stdout.puts "\e[33mRailsConsoleAi: dropped legacy #{skills_table} (replaced with single-content schema).\e[0m"
+      end
+      if conn.table_exists?(versions_table) && !conn.column_exists?(versions_table, :content)
+        conn.drop_table(versions_table)
+        $stdout.puts "\e[33mRailsConsoleAi: dropped legacy #{versions_table}.\e[0m"
+      end
+
       unless conn.table_exists?(skills_table)
         conn.create_table(skills_table) do |t|
           t.string   :name,        limit: 255, null: false
-          t.text     :description
-          t.text     :body
-          t.text     :tags
-          t.text     :bypass_guards_for_methods
+          t.text     :content,     null: false
           t.string   :status,      limit: 20,  default: 'proposed', null: false
           t.string   :approved_by, limit: 255
           t.datetime :approved_at
@@ -187,34 +207,13 @@ module RailsConsoleAi
         conn.add_index(skills_table, :name, unique: true)
         conn.add_index(skills_table, :status)
         $stdout.puts "\e[32mRailsConsoleAi: created #{skills_table} table.\e[0m"
-      else
-        # Idempotent column-add probes for existing installs.
-        unless conn.column_exists?(skills_table, :status)
-          conn.add_column(skills_table, :status, :string, limit: 20, default: 'proposed', null: false)
-          conn.add_index(skills_table, :status) unless conn.index_exists?(skills_table, :status)
-        end
-        unless conn.column_exists?(skills_table, :approved_by)
-          conn.add_column(skills_table, :approved_by, :string, limit: 255)
-        end
-        unless conn.column_exists?(skills_table, :approved_at)
-          conn.add_column(skills_table, :approved_at, :datetime)
-        end
-        unless conn.column_exists?(skills_table, :use_count)
-          conn.add_column(skills_table, :use_count, :integer, default: 0, null: false)
-        end
-        unless conn.column_exists?(skills_table, :last_used_at)
-          conn.add_column(skills_table, :last_used_at, :datetime)
-        end
       end
 
       unless conn.table_exists?(versions_table)
         conn.create_table(versions_table) do |t|
           t.integer  :skill_id
           t.string   :name,        limit: 255
-          t.text     :description
-          t.text     :body
-          t.text     :tags
-          t.text     :bypass_guards_for_methods
+          t.text     :content
           t.string   :status,      limit: 20
           t.string   :edited_by,   limit: 255
           t.text     :change_note
@@ -223,10 +222,6 @@ module RailsConsoleAi
         conn.add_index(versions_table, :skill_id)
         conn.add_index(versions_table, :created_at)
         $stdout.puts "\e[32mRailsConsoleAi: created #{versions_table} table.\e[0m"
-      else
-        unless conn.column_exists?(versions_table, :status)
-          conn.add_column(versions_table, :status, :string, limit: 20)
-        end
       end
     end
 
@@ -234,11 +229,19 @@ module RailsConsoleAi
       memories_table = 'rails_console_ai_memories'
       versions_table = 'rails_console_ai_memory_versions'
 
+      if conn.table_exists?(memories_table) && !conn.column_exists?(memories_table, :content)
+        conn.drop_table(memories_table)
+        $stdout.puts "\e[33mRailsConsoleAi: dropped legacy #{memories_table}.\e[0m"
+      end
+      if conn.table_exists?(versions_table) && !conn.column_exists?(versions_table, :content)
+        conn.drop_table(versions_table)
+        $stdout.puts "\e[33mRailsConsoleAi: dropped legacy #{versions_table}.\e[0m"
+      end
+
       unless conn.table_exists?(memories_table)
         conn.create_table(memories_table) do |t|
           t.string   :name,        limit: 255, null: false
-          t.text     :description
-          t.text     :tags
+          t.text     :content,     null: false
           t.integer  :use_count,   default: 0, null: false
           t.datetime :last_used_at
           t.datetime :created_at,  null: false
@@ -246,21 +249,13 @@ module RailsConsoleAi
         end
         conn.add_index(memories_table, :name, unique: true)
         $stdout.puts "\e[32mRailsConsoleAi: created #{memories_table} table.\e[0m"
-      else
-        unless conn.column_exists?(memories_table, :use_count)
-          conn.add_column(memories_table, :use_count, :integer, default: 0, null: false)
-        end
-        unless conn.column_exists?(memories_table, :last_used_at)
-          conn.add_column(memories_table, :last_used_at, :datetime)
-        end
       end
 
       unless conn.table_exists?(versions_table)
         conn.create_table(versions_table) do |t|
           t.integer  :memory_id
           t.string   :name,        limit: 255
-          t.text     :description
-          t.text     :tags
+          t.text     :content
           t.string   :edited_by,   limit: 255
           t.text     :change_note
           t.datetime :created_at,  null: false
@@ -275,14 +270,19 @@ module RailsConsoleAi
       agents_table   = 'rails_console_ai_agents'
       versions_table = 'rails_console_ai_agent_versions'
 
+      if conn.table_exists?(agents_table) && !conn.column_exists?(agents_table, :content)
+        conn.drop_table(agents_table)
+        $stdout.puts "\e[33mRailsConsoleAi: dropped legacy #{agents_table}.\e[0m"
+      end
+      if conn.table_exists?(versions_table) && !conn.column_exists?(versions_table, :content)
+        conn.drop_table(versions_table)
+        $stdout.puts "\e[33mRailsConsoleAi: dropped legacy #{versions_table}.\e[0m"
+      end
+
       unless conn.table_exists?(agents_table)
         conn.create_table(agents_table) do |t|
           t.string   :name,        limit: 255, null: false
-          t.text     :description
-          t.text     :body
-          t.integer  :max_rounds
-          t.string   :model,       limit: 100
-          t.text     :tools
+          t.text     :content,     null: false
           t.string   :status,      limit: 20,  default: 'proposed', null: false
           t.string   :approved_by, limit: 255
           t.datetime :approved_at
@@ -294,34 +294,13 @@ module RailsConsoleAi
         conn.add_index(agents_table, :name, unique: true)
         conn.add_index(agents_table, :status)
         $stdout.puts "\e[32mRailsConsoleAi: created #{agents_table} table.\e[0m"
-      else
-        unless conn.column_exists?(agents_table, :status)
-          conn.add_column(agents_table, :status, :string, limit: 20, default: 'proposed', null: false)
-          conn.add_index(agents_table, :status) unless conn.index_exists?(agents_table, :status)
-        end
-        unless conn.column_exists?(agents_table, :approved_by)
-          conn.add_column(agents_table, :approved_by, :string, limit: 255)
-        end
-        unless conn.column_exists?(agents_table, :approved_at)
-          conn.add_column(agents_table, :approved_at, :datetime)
-        end
-        unless conn.column_exists?(agents_table, :use_count)
-          conn.add_column(agents_table, :use_count, :integer, default: 0, null: false)
-        end
-        unless conn.column_exists?(agents_table, :last_used_at)
-          conn.add_column(agents_table, :last_used_at, :datetime)
-        end
       end
 
       unless conn.table_exists?(versions_table)
         conn.create_table(versions_table) do |t|
           t.integer  :agent_id
           t.string   :name,        limit: 255
-          t.text     :description
-          t.text     :body
-          t.integer  :max_rounds
-          t.string   :model,       limit: 100
-          t.text     :tools
+          t.text     :content
           t.string   :status,      limit: 20
           t.string   :edited_by,   limit: 255
           t.text     :change_note
@@ -376,6 +355,11 @@ module RailsConsoleAi
         migrations << 'error_message'
       end
 
+      unless conn.column_exists?(table, :options)
+        conn.add_column(table, :options, :text)
+        migrations << 'options'
+      end
+
       unless conn.index_exists?(table, [:mode, :status], name: 'idx_rca_sessions_mode_status')
         conn.add_index(table, [:mode, :status], name: 'idx_rca_sessions_mode_status')
         migrations << 'idx_rca_sessions_mode_status'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_console_ai
 version: !ruby/object:Gem::Version
-  version: 0.30.0
+  version: 0.31.0
 platform: ruby
 authors:
 - Cortfr