rails_console_ai 0.28.0 → 0.30.0

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,39 @@ 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
 
       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

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 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].freeze
 
       def initialize(executor: nil, mode: :default, channel: nil, allowed_tools: nil)
         @executor = executor
@@ -254,6 +254,7 @@ module RailsConsoleAi
 
             register_memory_tools
             register_skill_tools
+            register_agent_tools
             register_execute_plan
             register_delegate_task
           end
@@ -381,9 +382,20 @@ module RailsConsoleAi
           loader = AgentLoader.new
           agent_config = loader.find_agent(agent_name)
           unless agent_config
-            available = loader.load_all_agents.map { |a| a['name'] }
+            # Distinguish "doesn't exist" from "exists but isn't approved yet".
+            proposed = loader.find_any_agent(agent_name)
+            if proposed && proposed['source'] == :db && proposed['status'] != 'approved'
+              return "Agent \"#{agent_name}\" exists but is awaiting human approval and cannot be invoked yet. " \
+                     "Ask the user to approve it in the web UI at /rails_console_ai/agents."
+            end
+            available = loader.load_activatable_agents.map { |a| a['name'] }
             return "Agent not found: \"#{agent_name}\". Available agents: #{available.join(', ')}"
           end
+
+          # Usage tracking — DB-backed agents only.
+          if agent_config['source'] == :db && agent_config['id']
+            RailsConsoleAi::Agent.record_use!(agent_config['id'])
+          end
         end
 
         sub = SubAgent.new(
@@ -406,18 +418,26 @@ module RailsConsoleAi
 
         register(
           name: 'save_memory',
-          description: 'Save a fact or pattern you learned about this codebase for future sessions. Use after discovering how something works (e.g. sharding, auth, custom business logic).',
+          description: 'Save a fact or pattern you learned about this codebase for future sessions. Use after discovering how something works (e.g. sharding, auth, custom business logic). Defaults to the versioned DB store; pass target: "file" to write to the on-disk .rails_console_ai/memories directory instead.',
           parameters: {
             'type' => 'object',
             'properties' => {
               'name' => { 'type' => 'string', 'description' => 'Short name for this memory (e.g. "Sharding architecture")' },
               'description' => { 'type' => 'string', 'description' => 'Detailed description of what you learned' },
-              'tags' => { 'type' => 'array', 'items' => { 'type' => 'string' }, 'description' => 'Optional tags (e.g. ["database", "sharding"])' }
+              'tags' => { 'type' => 'array', 'items' => { 'type' => 'string' }, 'description' => 'Optional tags (e.g. ["database", "sharding"])' },
+              'target' => { 'type' => 'string', 'enum' => ['db', 'file'], 'description' => 'Where to store this memory. "db" (default) is versioned and editable via the web UI; "file" writes a Markdown file under .rails_console_ai/memories/.' },
+              'change_note' => { 'type' => 'string', 'description' => 'Optional one-line note describing this edit (DB store only).' }
             },
             'required' => ['name', 'description']
           },
           handler: ->(args) {
-            memory.save_memory(name: args['name'], description: args['description'], tags: args['tags'] || [])
+            memory.save_memory(
+              name: args['name'],
+              description: args['description'],
+              tags: args['tags'] || [],
+              target: (args['target'] || 'db').to_sym,
+              change_note: args['change_note']
+            )
           }
         )
 
@@ -480,19 +500,30 @@ module RailsConsoleAi
           handler: ->(args) {
             skill = loader.find_skill(args['name'])
             unless skill
+              # Distinguish "doesn't exist" from "exists but isn't approved yet".
+              proposed = loader.find_any_skill(args['name'])
+              if proposed && proposed['source'] == :db && proposed['status'] != 'approved'
+                return "Skill \"#{args['name']}\" exists but is awaiting human approval and cannot be activated yet. " \
+                       "Ask the user to approve it in the web UI at /rails_console_ai/skills."
+              end
               return "Skill not found: \"#{args['name']}\". Use the skills listed in the system prompt."
             end
 
             bypass_methods = Array(skill['bypass_guards_for_methods'])
             @executor.activate_skill_bypasses(bypass_methods) unless bypass_methods.empty?
 
+            # Usage tracking — DB-backed skills only (file skills have no row to update).
+            if skill['source'] == :db && skill['id']
+              RailsConsoleAi::Skill.record_use!(skill['id'])
+            end
+
             skill['body']
           }
         )
 
         register(
           name: 'save_skill',
-          description: 'Create or update a skill — a reusable procedure for a specific operation. Use when the user asks you to create a skill, recipe, or runbook. Skills differ from memories: a skill is a step-by-step procedure to follow, while a memory is a fact or pattern you learned.',
+          description: 'Create or update a skill — a reusable procedure for a specific operation. Use when the user asks you to create a skill, recipe, or runbook. Skills differ from memories: a skill is a step-by-step procedure to follow, while a memory is a fact or pattern you learned. Defaults to the versioned DB store; pass target: "file" to write to the on-disk .rails_console_ai/skills directory instead. IMPORTANT: skills saved to the DB start in "proposed" state and must be approved by a human in the web UI before you can activate them. Edits to an approved skill also revert it to proposed. Tell the user to visit /rails_console_ai/skills to approve.',
           parameters: {
             'type' => 'object',
             'properties' => {
@@ -500,7 +531,9 @@ module RailsConsoleAi
               'description' => { 'type' => 'string', 'description' => 'One-line description of when to use this skill' },
               'body' => { 'type' => 'string', 'description' => 'The full skill recipe in markdown. Include: ## When to use, ## Recipe (numbered steps with code blocks), ## Notes (optional).' },
               'tags' => { 'type' => 'array', 'items' => { 'type' => 'string' }, 'description' => 'Optional tags for categorization (e.g. ["booking-page", "admin"])' },
-              'bypass_guards_for_methods' => { 'type' => 'array', 'items' => { 'type' => 'string' }, 'description' => 'Methods that should bypass safety guards when this skill is active (e.g. ["BookingPage#save!", "BookingPage#ensure_subdomain_set!"])' }
+              'bypass_guards_for_methods' => { 'type' => 'array', 'items' => { 'type' => 'string' }, 'description' => 'Methods that should bypass safety guards when this skill is active (e.g. ["BookingPage#save!", "BookingPage#ensure_subdomain_set!"])' },
+              'target' => { 'type' => 'string', 'enum' => ['db', 'file'], 'description' => 'Where to store this skill. "db" (default) is versioned and editable via the web UI; "file" writes a Markdown file under .rails_console_ai/skills/.' },
+              'change_note' => { 'type' => 'string', 'description' => 'Optional one-line note describing this edit (DB store only).' }
             },
             'required' => %w[name description body]
           },
@@ -510,7 +543,9 @@ module RailsConsoleAi
               description: args['description'],
               body: args['body'],
               tags: args['tags'] || [],
-              bypass_guards_for_methods: args['bypass_guards_for_methods'] || []
+              bypass_guards_for_methods: args['bypass_guards_for_methods'] || [],
+              target: (args['target'] || 'db').to_sym,
+              change_note: args['change_note']
             )
           }
         )
@@ -529,6 +564,62 @@ module RailsConsoleAi
         )
       end
 
+      def register_agent_tools
+        return unless @executor
+
+        require 'rails_console_ai/agent_loader'
+        loader = RailsConsoleAi::AgentLoader.new
+
+        register(
+          name: 'save_agent',
+          description: 'Create or update a sub-agent definition — a reusable specialist that the main assistant can invoke via delegate_task. ' \
+            'Use when the user asks you to create a new agent, recipe-agent, or sub-task specialist. ' \
+            'Agents differ from skills: an agent runs in its own sub-conversation with a constrained tool set, while a skill is a procedure followed inline. ' \
+            'Defaults to the versioned DB store; pass target: "file" to write to the on-disk .rails_console_ai/agents directory instead. ' \
+            'IMPORTANT: agents saved to the DB start in "proposed" state and must be approved by a human in the web UI before delegate_task can invoke them. ' \
+            'Edits to an approved agent also revert it to proposed. Tell the user to visit /rails_console_ai/agents to approve.',
+          parameters: {
+            'type' => 'object',
+            'properties' => {
+              'name' => { 'type' => 'string', 'description' => 'Agent name (e.g. "Investigate billing"), shown in the Agents list and used as the delegate_task `agent` parameter' },
+              'description' => { 'type' => 'string', 'description' => 'One-line description of what this agent specializes in' },
+              'body' => { 'type' => 'string', 'description' => 'The agent\'s system instructions in markdown. Include: persona, strategy, rules, expected output format.' },
+              'max_rounds' => { 'type' => 'integer', 'description' => 'Optional: maximum tool-loop iterations for the sub-agent (defaults to global config). Use a smaller number for tightly-scoped agents.' },
+              'model' => { 'type' => 'string', 'description' => 'Optional: model override for this agent (e.g. "claude-haiku-4" for cheap fast agents)' },
+              'tools' => { 'type' => 'array', 'items' => { 'type' => 'string' }, 'description' => 'Optional: whitelist of tool names the sub-agent is allowed to call. Omit to allow the default set.' },
+              'target' => { 'type' => 'string', 'enum' => ['db', 'file'], 'description' => 'Where to store this agent. "db" (default) is versioned and editable via the web UI; "file" writes a Markdown file under .rails_console_ai/agents/.' },
+              'change_note' => { 'type' => 'string', 'description' => 'Optional one-line note describing this edit (DB store only).' }
+            },
+            'required' => %w[name description body]
+          },
+          handler: ->(args) {
+            loader.save_agent(
+              name: args['name'],
+              description: args['description'],
+              body: args['body'],
+              max_rounds: args['max_rounds'],
+              model: args['model'],
+              tools: args['tools'] || [],
+              target: (args['target'] || 'db').to_sym,
+              change_note: args['change_note']
+            )
+          }
+        )
+
+        register(
+          name: 'delete_agent',
+          description: 'Delete a sub-agent by name. Built-in (gem-shipped) agents cannot be deleted; this tool will tell you that and suggest creating a same-named override instead.',
+          parameters: {
+            'type' => 'object',
+            'properties' => {
+              'name' => { 'type' => 'string', 'description' => 'The agent name to delete' }
+            },
+            'required' => ['name']
+          },
+          handler: ->(args) { loader.delete_agent(name: args['name']) }
+        )
+      end
+
       def register_execute_plan
         return unless @executor
 

data/lib/rails_console_ai/version.rb

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