rails_console_ai 0.28.0 → 0.30.0

data/lib/rails_console_ai/channel/slack.rb

@@ -11,6 +11,9 @@ module RailsConsoleAi
         @thread_ts = thread_ts
         @user_name = user_name
         @reply_queue = Queue.new
+        @guidance_main = []
+        @guidance_sub = []
+        @guidance_mutex = Mutex.new
         @cancelled = false
         @log_prefix = "[#{@channel_id}/#{@thread_ts}] @#{@user_name}"
         @output_log = StringIO.new
@@ -18,6 +21,36 @@ module RailsConsoleAi
 
       def cancel!
         @cancelled = true
+        @guidance_mutex.synchronize do
+          @guidance_main.clear
+          @guidance_sub.clear
+        end
+      end
+
+      # Guidance is broadcast to both the main-engine queue and the sub-agent queue
+      # so a steering message arriving during a sub-agent run is seen by both layers
+      # (sub-agent reacts immediately; main engine reacts after delegate_task returns).
+      def add_guidance(text)
+        @guidance_mutex.synchronize do
+          @guidance_main << text
+          @guidance_sub << text
+        end
+      end
+
+      def drain_guidance(scope: :main)
+        @guidance_mutex.synchronize do
+          arr = scope == :sub ? @guidance_sub : @guidance_main
+          pending = arr.dup
+          arr.clear
+          pending
+        end
+      end
+
+      def pending_guidance?(scope: :main)
+        @guidance_mutex.synchronize do
+          arr = scope == :sub ? @guidance_sub : @guidance_main
+          !arr.empty?
+        end
       end
 
       def cancelled?

data/lib/rails_console_ai/channel/sub_agent.rb

@@ -64,6 +64,18 @@ module RailsConsoleAi
         @parent.cancelled?
       end
 
+      def pending_guidance?
+        @parent.respond_to?(:pending_guidance?) && @parent.pending_guidance?(scope: :sub)
+      end
+
+      def drain_guidance
+        @parent.respond_to?(:drain_guidance) ? @parent.drain_guidance(scope: :sub) : []
+      end
+
+      def add_guidance(text)
+        @parent.add_guidance(text) if @parent.respond_to?(:add_guidance)
+      end
+
       def supports_danger?
         false  # Sub-agents must never silently bypass safety guards
       end

data/lib/rails_console_ai/conversation_engine.rb

@@ -36,7 +36,7 @@ module RailsConsoleAi
 
     # --- Public API for channels ---
 
-    def one_shot(query)
+    def one_shot(query, existing_session_id: nil)
       start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       console_capture = StringIO.new
       exec_result = with_console_capture(console_capture) do
@@ -61,7 +61,8 @@ module RailsConsoleAi
           code_output: executed ? @executor.last_output : nil,
           code_result: executed && exec_result ? exec_result.inspect : nil,
           executed: executed,
-          start_time: start_time
+          start_time: start_time,
+          existing_session_id: existing_session_id
         }
 
         exec_result
@@ -803,6 +804,15 @@ module RailsConsoleAi
           break
         end
 
+        if round > 0 && @channel.respond_to?(:pending_guidance?) && @channel.pending_guidance?
+          pending = @channel.drain_guidance
+          guidance_text = format_user_interruption(pending)
+          guidance_msg = { role: :user, content: guidance_text }
+          messages << guidance_msg
+          new_messages << guidance_msg
+          @channel.display_status("  Steering: incorporating user guidance.")
+        end
+
         if round == 0
           @channel.display_status("  Thinking...")
         elsif last_thinking
@@ -1007,18 +1017,23 @@ module RailsConsoleAi
 
     def log_session(attrs)
       require 'rails_console_ai/session_logger'
-      start_time = attrs.delete(:start_time)
-      duration_ms = if start_time
-                      ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round
-                    end
-      SessionLogger.log(
-        attrs.merge(
-          input_tokens: @total_input_tokens,
-          output_tokens: @total_output_tokens,
-          duration_ms: duration_ms,
-          model: effective_model
-        )
+      start_time   = attrs.delete(:start_time)
+      existing_id  = attrs.delete(:existing_session_id)
+      duration_ms  = if start_time
+                       ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round
+                     end
+      merged = attrs.merge(
+        input_tokens: @total_input_tokens,
+        output_tokens: @total_output_tokens,
+        duration_ms: duration_ms,
+        model: effective_model
       )
+      if existing_id
+        SessionLogger.update(existing_id, merged)
+        existing_id
+      else
+        SessionLogger.log(merged)
+      end
     end
 
     # --- Formatting helpers ---
@@ -1152,6 +1167,28 @@ module RailsConsoleAi
       str.length > max ? str[0..max] + '...' : str
     end
 
+    # Wraps mid-task user messages with explicit framing so the model treats them
+    # as a real-time interruption that supersedes the prior task, rather than as
+    # a reply to the most recent tool result.
+    def format_user_interruption(messages)
+      joined = messages.map { |t| t.to_s.strip }.reject(&:empty?).join("\n\n")
+      <<~MSG.strip
+        [INTERRUPTION FROM USER — REAL-TIME MESSAGE]
+
+        The user sent the following message while you were working on the previous step.
+        They sent it before seeing the result of your last tool call, so it is NOT a
+        reply to that result. It is your most recent direction from the user and
+        supersedes the prior task.
+
+        If they are telling you to stop, halt completely and acknowledge — do not
+        autonomously switch to a different method to accomplish the original task.
+        If their instruction is unclear, ask them what they want before continuing.
+
+        User message:
+        "#{joined}"
+      MSG
+    end
+
     def llm_status(round, messages, req_tokens, total_billed, last_thinking = nil, last_tool_names = [])
       status = "Calling LLM (round #{round + 1}, #{messages.length} msgs"
       status += ", ~#{format_tokens(req_tokens)} ctx" if req_tokens > 0

data/lib/rails_console_ai/session_logger.rb

@@ -25,6 +25,9 @@ module RailsConsoleAi
         }
         create_attrs[:slack_thread_ts] = attrs[:slack_thread_ts] if attrs[:slack_thread_ts]
         create_attrs[:slack_channel_name] = attrs[:slack_channel_name] if attrs[:slack_channel_name]
+        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)
         record = session_class.create!(create_attrs)
         record.id
       rescue => e
@@ -59,6 +62,9 @@ module RailsConsoleAi
         updates[:executed]      = attrs[:executed]       if attrs.key?(:executed)
         updates[:duration_ms]   = attrs[:duration_ms]    if attrs.key?(:duration_ms)
         updates[:name]          = attrs[:name]           if attrs.key?(:name)
+        updates[:status]        = attrs[:status]         if attrs.key?(:status)
+        updates[:result]        = attrs[:result]         if attrs.key?(:result)
+        updates[:error_message] = attrs[:error_message]  if attrs.key?(:error_message)
 
         session_class.where(id: id).update_all(updates) unless updates.empty?
       rescue => e

data/lib/rails_console_ai/skill_loader.rb

@@ -1,4 +1,5 @@
 require 'yaml'
+require 'rails_console_ai/storage/database_storage'
 
 module RailsConsoleAi
   class SkillLoader
@@ -8,16 +9,33 @@ module RailsConsoleAi
       @storage = storage || RailsConsoleAi.storage
     end
 
+    # Returns the union of DB-backed skills and file-backed skills.
+    # When the same name appears in both, the DB record wins and the file
+    # record is shadowed (but the file isn't touched).
+    #
+    # Includes proposed (unapproved) DB skills — they show up in the admin UI
+    # with a "PROPOSED" badge. The AI-facing surface (#skill_summaries, #find_skill)
+    # filters them out, so an unapproved skill can never be activated.
     def load_all_skills
-      keys = @storage.list("#{SKILLS_DIR}/*.md")
-      keys.filter_map { |key| load_skill(key) }
-    rescue => e
-      RailsConsoleAi.logger.warn("RailsConsoleAi: failed to load skills: #{e.message}")
-      []
+      db = safe_load_db_skills
+      file = safe_load_file_skills
+
+      names = db.map { |s| s['name'].to_s.downcase }
+      file.reject! { |s| names.include?(s['name'].to_s.downcase) }
+
+      (db + file).sort_by { |s| s['name'].to_s.downcase }
+    end
+
+    # Skills the AI is allowed to see / activate: approved DB skills + all file skills.
+    # File skills are considered pre-approved because they're git-tracked.
+    def load_activatable_skills
+      # Use string literal so this doesn't require the AR model to be autoloaded
+      # in environments that don't reference it.
+      load_all_skills.reject { |s| s['source'] == :db && s['status'] != 'approved' }
     end
 
     def skill_summaries
-      skills = load_all_skills
+      skills = load_activatable_skills
       return nil if skills.empty?
 
       skills.map { |s|
@@ -28,13 +46,81 @@ module RailsConsoleAi
     end
 
     def find_skill(name)
-      skills = load_all_skills
-      skills.find { |s| s['name'].to_s.downcase == name.to_s.downcase }
+      load_activatable_skills.find { |s| s['name'].to_s.downcase == name.to_s.downcase }
+    end
+
+    # UI-facing: includes proposed skills too, with name-collision DB wins.
+    def find_any_skill(name)
+      load_all_skills.find { |s| s['name'].to_s.downcase == name.to_s.downcase }
+    end
+
+    # target: :db (default) | :file
+    # Falls back to :file (with a notice in the return string) if DB tables aren't set up.
+    def save_skill(name:, description:, body:, tags: [], bypass_guards_for_methods: [], target: :db, edited_by: nil, change_note: nil)
+      target = (target || :db).to_sym
+      db_fell_back = false
+      if target == :db && !Storage::DatabaseStorage.available?
+        target = :file
+        db_fell_back = true
+      end
+
+      if target == :file
+        result = save_skill_to_file(
+          name: name, description: description, body: body,
+          tags: tags, bypass_guards_for_methods: bypass_guards_for_methods
+        )
+        if db_fell_back
+          result += "\nNOTE: DB storage was requested but the rails_console_ai_skills table does not exist. " \
+                    "Run `ai_db_setup` in your Rails console to enable the versioned DB store. " \
+                    "Saved to a file instead."
+        end
+        result
+      else
+        record, was_new = Storage::DatabaseStorage.save_skill(
+          name: name, description: description, body: body,
+          tags: tags, bypass_guards_for_methods: bypass_guards_for_methods,
+          edited_by: edited_by || 'ai', change_note: change_note
+        )
+        status_note = if record.respond_to?(:proposed?) && record.proposed?
+                        ' — status: PROPOSED. A human must approve it at /rails_console_ai/skills before it can be activated.'
+                      else
+                        ''
+                      end
+        if was_new
+          "Skill created (db): \"#{record.name}\" (id=#{record.id})#{status_note}"
+        else
+          "Skill updated (db): \"#{record.name}\" (id=#{record.id})#{status_note}"
+        end
+      end
+    rescue Storage::StorageError, ::ActiveRecord::RecordInvalid => e
+      "FAILED to save skill (#{e.message})."
     end
 
-    def save_skill(name:, description:, body:, tags: [], bypass_guards_for_methods: [])
+    # Tries DB first, falls back to file. Reports which source it removed from.
+    def delete_skill(name:)
+      if Storage::DatabaseStorage.delete_skill_by_name(name)
+        return "Skill deleted (db): \"#{name}\""
+      end
+
       key = skill_key(name)
-      existing = find_skill(name)
+      unless @storage.exists?(key)
+        found = safe_load_file_skills.find { |s| s['name'].to_s.downcase == name.to_s.downcase }
+        return "No skill found: \"#{name}\"" unless found
+        key = skill_key(found['name'])
+      end
+
+      skill = load_skill_file(key)
+      @storage.delete(key)
+      "Skill deleted: \"#{skill ? skill['name'] : name}\""
+    rescue Storage::StorageError => e
+      "FAILED to delete skill (#{e.message})."
+    end
+
+    private
+
+    def save_skill_to_file(name:, description:, body:, tags:, bypass_guards_for_methods:)
+      key = skill_key(name)
+      existing = load_skill_file(key)
 
       frontmatter = {
         'name' => name,
@@ -53,26 +139,23 @@ module RailsConsoleAi
       else
         "Skill created: \"#{name}\" (#{path})"
       end
-    rescue Storage::StorageError => e
-      "FAILED to save skill (#{e.message})."
     end
 
-    def delete_skill(name:)
-      key = skill_key(name)
-      unless @storage.exists?(key)
-        found = load_all_skills.find { |s| s['name'].to_s.downcase == name.to_s.downcase }
-        return "No skill found: \"#{name}\"" unless found
-        key = skill_key(found['name'])
-      end
-
-      skill = load_skill(key)
-      @storage.delete(key)
-      "Skill deleted: \"#{skill ? skill['name'] : name}\""
-    rescue Storage::StorageError => e
-      "FAILED to delete skill (#{e.message})."
+    def safe_load_db_skills
+      Storage::DatabaseStorage.all_skills
     end
 
-    private
+    def safe_load_file_skills
+      keys = @storage.list("#{SKILLS_DIR}/*.md")
+      keys.filter_map { |key|
+        skill = load_skill_file(key)
+        next nil unless skill
+        skill.merge('source' => :file, 'file_key' => key)
+      }
+    rescue => e
+      RailsConsoleAi.logger.warn("RailsConsoleAi: failed to load file skills: #{e.message}")
+      []
+    end
 
     def skill_key(name)
       slug = name.downcase.strip
@@ -83,7 +166,7 @@ module RailsConsoleAi
       "#{SKILLS_DIR}/#{slug}.md"
     end
 
-    def load_skill(key)
+    def load_skill_file(key)
       content = @storage.read(key)
       return nil if content.nil? || content.strip.empty?
       parse_skill(content)
@@ -93,10 +176,19 @@ module RailsConsoleAi
     end
 
     def parse_skill(content)
+      self.class.parse(content)
+    end
+
+    # Public: parse a raw .md (YAML frontmatter + body) string into a hash.
+    # Returns nil for content that doesn't have valid frontmatter so the caller
+    # can show a clear error instead of producing a half-formed record.
+    def self.parse(content)
       return nil unless content =~ /\A---\s*\n(.*?\n)---\s*\n(.*)/m
       frontmatter = YAML.safe_load($1, permitted_classes: [Time, Date]) || {}
       body = $2.strip
       frontmatter.merge('body' => body)
+    rescue Psych::SyntaxError
+      nil
     end
   end
 end

data/lib/rails_console_ai/slack_bot.rb

@@ -491,6 +491,14 @@ module RailsConsoleAi
         return
       end
 
+      # If the engine is mid-run, treat the message as steering guidance to be
+      # folded in at the next tool-loop boundary instead of restarting.
+      if session[:thread]&.alive? && channel.respond_to?(:add_guidance)
+        channel.add_guidance(text)
+        channel.display("Got it. One moment.")
+        return
+      end
+
       # Otherwise treat as a new message in the conversation
       replace_session_thread(session) do
         Thread.current.report_on_exception = false

data/lib/rails_console_ai/storage/database_storage.rb

@@ -0,0 +1,201 @@
+module RailsConsoleAi
+  module Storage
+    # Thin facade over the AR-backed Skill / Memory tables.
+    #
+    # Not a drop-in Storage::Base adapter: the loaders read & write structured
+    # records, not opaque Markdown blobs, so we expose a small typed API instead.
+    # All methods are safe to call before `ai_db_setup` has run — they detect
+    # missing tables and return empty results / nil rather than raising.
+    module DatabaseStorage
+      module_function
+
+      def available?
+        table_exists?('rails_console_ai_skills')
+      end
+
+      def memories_available?
+        table_exists?('rails_console_ai_memories')
+      end
+
+      def agents_available?
+        table_exists?('rails_console_ai_agents')
+      end
+
+      # Ask the connection directly so we don't depend on the AR model being
+      # autoloaded yet. In a Rails console, the models in app/models are
+      # autoloaded lazily — the constant is `defined?`-false until first
+      # reference. Going through the connection avoids that timing trap.
+      def table_exists?(table_name)
+        return false unless defined?(::ActiveRecord)
+        conn = active_record_connection
+        return false unless conn
+        conn.table_exists?(table_name)
+      rescue ::ActiveRecord::ActiveRecordError, ::ActiveRecord::NoDatabaseError, NoMethodError
+        false
+      end
+
+      def active_record_connection
+        klass = RailsConsoleAi.configuration.connection_class
+        if klass
+          klass = Object.const_get(klass) if klass.is_a?(String)
+          klass.connection
+        else
+          ::ActiveRecord::Base.connection
+        end
+      end
+
+      # --- Skills ---
+
+      def all_skills
+        return [] unless available?
+        RailsConsoleAi::Skill.alphabetical.map(&:to_hash)
+      rescue => e
+        warn_failure(:all_skills, e)
+        []
+      end
+
+      def find_skill_by_name(name)
+        return nil unless available?
+        record = RailsConsoleAi::Skill.where('LOWER(name) = ?', name.to_s.downcase).first
+        record&.to_hash
+      rescue => e
+        warn_failure(:find_skill_by_name, e)
+        nil
+      end
+
+      def save_skill(name:, description:, body:, tags: [], bypass_guards_for_methods: [], edited_by: nil, change_note: nil)
+        ensure_tables!(:skills)
+        record = RailsConsoleAi::Skill.where('LOWER(name) = ?', name.to_s.downcase).first
+        record ||= RailsConsoleAi::Skill.new
+        was_new = record.new_record?
+        record.update_with_version!(
+          {
+            name:                      name,
+            description:               description,
+            body:                      body,
+            tags:                      Array(tags),
+            bypass_guards_for_methods: Array(bypass_guards_for_methods)
+          },
+          edited_by: edited_by,
+          change_note: change_note
+        )
+        [record, was_new]
+      end
+
+      def delete_skill_by_name(name)
+        return false unless available?
+        record = RailsConsoleAi::Skill.where('LOWER(name) = ?', name.to_s.downcase).first
+        return false unless record
+        record.destroy
+        true
+      end
+
+      # --- Memories ---
+
+      def all_memories
+        return [] unless memories_available?
+        RailsConsoleAi::Memory.alphabetical.map(&:to_hash)
+      rescue => e
+        warn_failure(:all_memories, e)
+        []
+      end
+
+      def find_memory_by_name(name)
+        return nil unless memories_available?
+        record = RailsConsoleAi::Memory.where('LOWER(name) = ?', name.to_s.downcase).first
+        record&.to_hash
+      rescue => e
+        warn_failure(:find_memory_by_name, e)
+        nil
+      end
+
+      def save_memory(name:, description:, tags: [], edited_by: nil, change_note: nil)
+        ensure_tables!(:memories)
+        record = RailsConsoleAi::Memory.where('LOWER(name) = ?', name.to_s.downcase).first
+        record ||= RailsConsoleAi::Memory.new
+        was_new = record.new_record?
+        record.update_with_version!(
+          {
+            name:        name,
+            description: description,
+            tags:        Array(tags)
+          },
+          edited_by: edited_by,
+          change_note: change_note
+        )
+        [record, was_new]
+      end
+
+      def delete_memory_by_name(name)
+        return false unless memories_available?
+        record = RailsConsoleAi::Memory.where('LOWER(name) = ?', name.to_s.downcase).first
+        return false unless record
+        record.destroy
+        true
+      end
+
+      # --- Agents ---
+
+      def all_agents
+        return [] unless agents_available?
+        RailsConsoleAi::Agent.alphabetical.map(&:to_hash)
+      rescue => e
+        warn_failure(:all_agents, e)
+        []
+      end
+
+      def find_agent_by_name(name)
+        return nil unless agents_available?
+        record = RailsConsoleAi::Agent.where('LOWER(name) = ?', name.to_s.downcase).first
+        record&.to_hash
+      rescue => e
+        warn_failure(:find_agent_by_name, e)
+        nil
+      end
+
+      def save_agent(name:, description:, body:, max_rounds: nil, model: nil, tools: [], edited_by: nil, change_note: nil)
+        ensure_tables!(:agents)
+        record = RailsConsoleAi::Agent.where('LOWER(name) = ?', name.to_s.downcase).first
+        record ||= RailsConsoleAi::Agent.new
+        was_new = record.new_record?
+        record.update_with_version!(
+          {
+            name:        name,
+            description: description,
+            body:        body,
+            max_rounds:  max_rounds,
+            model:       model,
+            tools:       Array(tools)
+          },
+          edited_by: edited_by,
+          change_note: change_note
+        )
+        [record, was_new]
+      end
+
+      def delete_agent_by_name(name)
+        return false unless agents_available?
+        record = RailsConsoleAi::Agent.where('LOWER(name) = ?', name.to_s.downcase).first
+        return false unless record
+        record.destroy
+        true
+      end
+
+      def ensure_tables!(kind)
+        ready = case kind
+                when :skills   then available?
+                when :memories then memories_available?
+                when :agents   then agents_available?
+                else false
+                end
+        return if ready
+        raise StorageError, "rails_console_ai_#{kind} table does not exist. Run `ai_db_setup` in your console."
+      end
+
+      def warn_failure(method, error)
+        return unless defined?(RailsConsoleAi.logger) && RailsConsoleAi.logger
+        RailsConsoleAi.logger.warn("RailsConsoleAi::Storage::DatabaseStorage##{method} failed: #{error.class}: #{error.message}")
+      end
+    end
+  end
+end

data/lib/rails_console_ai/sub_agent.rb

@@ -66,6 +66,12 @@ module RailsConsoleAi
       max_rounds.times do |round|
         break if channel.cancelled?
 
+        if round > 0 && channel.respond_to?(:pending_guidance?) && channel.pending_guidance?
+          pending = channel.drain_guidance
+          messages << { role: :user, content: format_user_interruption(pending) }
+          channel.display_status("  Steering: incorporating user guidance.")
+        end
+
         if round == 0
           channel.display_status("Thinking...")
         end
@@ -147,6 +153,25 @@ module RailsConsoleAi
       result&.text || '(sub-agent returned no result)'
     end
 
+    def format_user_interruption(messages)
+      joined = messages.map { |t| t.to_s.strip }.reject(&:empty?).join("\n\n")
+      <<~MSG.strip
+        [INTERRUPTION FROM USER — REAL-TIME MESSAGE]
+
+        The user sent the following message while you were working. They sent it
+        before seeing your latest tool result, so it is NOT a reply to that result.
+        It is your most recent direction from the user and supersedes the prior task.
+
+        If they are telling you to stop, halt immediately and finish with a brief
+        acknowledgement — do not switch to a different method to accomplish the
+        original task on your own. If unclear, return what you have so far and let
+        the parent agent ask the user.
+
+        User message:
+        "#{joined}"
+      MSG
+    end
+
     def build_provider
       config = RailsConsoleAi.configuration
       model_override = @agent_config['model'] || config.sub_agent_model