rails_console_ai 0.29.0 → 0.31.0

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,44 +46,70 @@ 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
 
-    def save_skill(name:, description:, body:, tags: [], bypass_guards_for_methods: [])
-      key = skill_key(name)
-      existing = find_skill(name)
-
-      frontmatter = {
-        'name' => name,
-        'description' => description,
-        'tags' => Array(tags)
-      }
-      bypasses = Array(bypass_guards_for_methods)
-      frontmatter['bypass_guards_for_methods'] = bypasses unless bypasses.empty?
+    # 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
 
-      content = "---\n#{YAML.dump(frontmatter).sub("---\n", '').strip}\n---\n\n#{body}\n"
-      @storage.write(key, content)
+    # 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
 
-      path = @storage.respond_to?(:root_path) ? File.join(@storage.root_path, key) : key
-      if existing
-        "Skill updated: \"#{name}\" (#{path})"
+      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
-        "Skill created: \"#{name}\" (#{path})"
+        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 => e
+    rescue Storage::StorageError, ::ActiveRecord::RecordInvalid => e
       "FAILED to save skill (#{e.message})."
     end
 
+    # 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)
       unless @storage.exists?(key)
-        found = load_all_skills.find { |s| s['name'].to_s.downcase == name.to_s.downcase }
+        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(key)
+      skill = load_skill_file(key)
       @storage.delete(key)
       "Skill deleted: \"#{skill ? skill['name'] : name}\""
     rescue Storage::StorageError => e
@@ -74,6 +118,40 @@ module RailsConsoleAi
 
     private
 
+    def save_skill_to_file(name:, description:, body:, tags:, bypass_guards_for_methods:)
+      key = skill_key(name)
+      existing = load_skill_file(key)
+
+      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
+      if existing
+        "Skill updated: \"#{name}\" (#{path})"
+      else
+        "Skill created: \"#{name}\" (#{path})"
+      end
+    end
+
+    def safe_load_db_skills
+      Storage::DatabaseStorage.all_skills
+    end
+
+    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
         .gsub(/[^a-z0-9\s-]/, '')
@@ -83,7 +161,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 +171,33 @@ 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
+
+    # 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

@@ -0,0 +1,195 @@
+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?
+        content = RailsConsoleAi::SkillLoader.dump(
+          name: name, description: description, body: body,
+          tags: tags, bypass_guards_for_methods: bypass_guards_for_methods
+        )
+        record.update_with_version!(
+          { content: content },
+          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?
+        content = RailsConsoleAi::Tools::MemoryTools.dump(
+          name: name, description: description, tags: tags
+        )
+        record.update_with_version!(
+          { content: content },
+          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?
+        content = RailsConsoleAi::AgentLoader.dump(
+          name: name, description: description, body: body,
+          max_rounds: max_rounds, model: model, tools: tools
+        )
+        record.update_with_version!(
+          { content: content },
+          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/tools/memory_tools.rb

@@ -1,4 +1,5 @@
 require 'yaml'
+require 'rails_console_ai/storage/database_storage'
 
 module RailsConsoleAi
   module Tools
@@ -9,41 +10,61 @@ module RailsConsoleAi
         @storage = storage || RailsConsoleAi.storage
       end
 
-      def save_memory(name:, description:, tags: [])
-        key = memory_key(name)
-        existing = load_memory(key)
-
-        frontmatter = {
-          'name' => name,
-          'tags' => Array(tags).empty? && existing ? (existing['tags'] || []) : Array(tags),
-          'created_at' => existing ? existing['created_at'] : Time.now.utc.iso8601
-        }
-        frontmatter['updated_at'] = Time.now.utc.iso8601 if existing
-
-        content = "---\n#{YAML.dump(frontmatter).sub("---\n", '').strip}\n---\n\n#{description}\n"
-        @storage.write(key, content)
+      # target: :db (default) | :file
+      # Falls back to :file (with a notice in the return string) if DB tables aren't set up.
+      def save_memory(name:, description:, tags: [], target: :db, edited_by: nil, change_note: nil)
+        target = (target || :db).to_sym
+        db_fell_back = false
+        if target == :db && !Storage::DatabaseStorage.memories_available?
+          target = :file
+          db_fell_back = true
+        end
 
-        path = @storage.respond_to?(:root_path) ? File.join(@storage.root_path, key) : key
-        if existing
-          "Memory updated: \"#{name}\" (#{path})"
+        if target == :file
+          result = save_memory_to_file(name: name, description: description, tags: tags)
+          if db_fell_back
+            result += "\nNOTE: DB storage was requested but the rails_console_ai_memories 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
-          "Memory saved: \"#{name}\" (#{path})"
+          record, was_new = Storage::DatabaseStorage.save_memory(
+            name: name, description: description, tags: tags,
+            edited_by: edited_by || 'ai', change_note: change_note
+          )
+          if was_new
+            "Memory saved (db): \"#{record.name}\" (id=#{record.id})"
+          else
+            "Memory updated (db): \"#{record.name}\" (id=#{record.id})"
+          end
         end
       rescue Storage::StorageError => e
-        "FAILED to save (#{e.message}). Add this manually to .rails_console_ai/#{key}:\n" \
-        "---\nname: #{name}\ntags: #{Array(tags).inspect}\n---\n\n#{description}"
+        if target == :file
+          # Preserve the original behaviour: include a hint with the raw frontmatter
+          # so the user (or AI) can paste it manually when the filesystem is read-only.
+          "FAILED to save (#{e.message}). Add this manually to .rails_console_ai/#{memory_key(name)}:\n" \
+          "---\nname: #{name}\ntags: #{Array(tags).inspect}\n---\n\n#{description}"
+        else
+          "FAILED to save (#{e.message})."
+        end
+      rescue ::ActiveRecord::RecordInvalid => e
+        "FAILED to save (#{e.message})."
       end
 
       def delete_memory(name:)
+        if Storage::DatabaseStorage.delete_memory_by_name(name)
+          return "Memory deleted (db): \"#{name}\""
+        end
+
         key = memory_key(name)
         unless @storage.exists?(key)
-          # Try to find by name match across all memory files
           found_key = find_memory_key_by_name(name)
           return "No memory found: \"#{name}\"" unless found_key
           key = found_key
         end
 
-        memory = load_memory(key)
+        memory = load_memory_file(key)
         @storage.delete(key)
         "Memory deleted: \"#{memory ? memory['name'] : name}\""
       rescue Storage::StorageError => e
@@ -51,14 +72,11 @@ module RailsConsoleAi
       end
 
       def recall_memory(name:)
-        key = memory_key(name)
-        memory = load_memory(key)
-        # Fall back to case-insensitive name search
-        unless memory
-          memory = load_all_memories.find { |m| m['name'].to_s.downcase == name.downcase }
-        end
+        memory = load_all_memories.find { |m| m['name'].to_s.downcase == name.to_s.downcase }
         return "No memory found: \"#{name}\"" unless memory
 
+        record_use(memory)
+
         line = "**#{memory['name']}**\n#{memory['description']}"
         line += "\nTags: #{memory['tags'].join(', ')}" if memory['tags'] && !memory['tags'].empty?
         line
@@ -88,6 +106,9 @@ module RailsConsoleAi
 
         return "No memories matching your search." if results.empty?
 
+        # Every memory in the result set was loaded into the AI's context.
+        results.each { |m| record_use(m) }
+
         results.map { |m|
           line = "**#{m['name']}**\n#{m['description']}"
           line += "\nTags: #{m['tags'].join(', ')}" if m['tags'] && !m['tags'].empty?
@@ -106,8 +127,44 @@ module RailsConsoleAi
         }
       end
 
+      def load_all_memories
+        db = Storage::DatabaseStorage.all_memories
+        file = load_all_file_memories
+        names = db.map { |m| m['name'].to_s.downcase }
+        file.reject! { |m| names.include?(m['name'].to_s.downcase) }
+        (db + file).sort_by { |m| m['name'].to_s.downcase }
+      end
+
       private
 
+      # DB-backed memories only — file memories have no row to update.
+      def record_use(memory)
+        return unless memory.is_a?(Hash) && memory['source'] == :db && memory['id']
+        RailsConsoleAi::Memory.record_use!(memory['id'])
+      end
+
+      def save_memory_to_file(name:, description:, tags:)
+        key = memory_key(name)
+        existing = load_memory_file(key)
+
+        frontmatter = {
+          'name' => name,
+          'tags' => Array(tags).empty? && existing ? (existing['tags'] || []) : Array(tags),
+          'created_at' => existing ? existing['created_at'] : Time.now.utc.iso8601
+        }
+        frontmatter['updated_at'] = Time.now.utc.iso8601 if existing
+
+        content = "---\n#{YAML.dump(frontmatter).sub("---\n", '').strip}\n---\n\n#{description}\n"
+        @storage.write(key, content)
+
+        path = @storage.respond_to?(:root_path) ? File.join(@storage.root_path, key) : key
+        if existing
+          "Memory updated: \"#{name}\" (#{path})"
+        else
+          "Memory saved: \"#{name}\" (#{path})"
+        end
+      end
+
       def memory_key(name)
         slug = name.downcase.strip
           .gsub(/[^a-z0-9\s-]/, '')
@@ -117,7 +174,7 @@ module RailsConsoleAi
         "#{MEMORIES_DIR}/#{slug}.md"
       end
 
-      def load_memory(key)
+      def load_memory_file(key)
         content = @storage.read(key)
         return nil if content.nil? || content.strip.empty?
         parse_memory(content)
@@ -126,26 +183,47 @@ module RailsConsoleAi
         nil
       end
 
-      def load_all_memories
+      def load_all_file_memories
         keys = @storage.list("#{MEMORIES_DIR}/*.md")
-        keys.map { |key| load_memory(key) }.compact
+        keys.filter_map { |key|
+          memory = load_memory_file(key)
+          next nil unless memory
+          memory.merge('source' => :file, 'file_key' => key)
+        }
       rescue => e
         RailsConsoleAi.logger.warn("RailsConsoleAi: failed to load memories: #{e.message}")
         []
       end
 
       def parse_memory(content)
+        self.class.parse(content)
+      end
+
+      # Public: parse a raw .md (YAML frontmatter + body) string into a hash.
+      # For memories, the body is stored under the 'description' key (memories
+      # don't have a separate description vs body — the markdown IS the memory).
+      def self.parse(content)
         return nil unless content =~ /\A---\s*\n(.*?\n)---\s*\n(.*)/m
         frontmatter = YAML.safe_load($1, permitted_classes: [Time, Date]) || {}
         description = $2.strip
         frontmatter.merge('description' => description)
+      rescue Psych::SyntaxError
+        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|
-          memory = load_memory(key)
-          memory && memory['name'].to_s.downcase == name.downcase
+          memory = load_memory_file(key)
+          memory && memory['name'].to_s.downcase == name.to_s.downcase
         end
       end
     end