rails_console_ai 0.22.0 → 0.23.0

data/lib/rails_console_ai/executor.rb

@@ -148,7 +148,7 @@ module RailsConsoleAi
     rescue SyntaxError => e
       $stdout = old_stdout if old_stdout
       @last_error = "SyntaxError: #{e.message}"
-      display_error(@last_error)
+      log_execution_error(@last_error)
       @last_output = nil
       nil
     rescue => e
@@ -166,7 +166,7 @@ module RailsConsoleAi
       end
       @last_error = "#{e.class}: #{e.message}"
       backtrace = e.backtrace.first(3).map { |line| "  #{line}" }.join("\n")
-      display_error("Error: #{@last_error}\n#{backtrace}")
+      log_execution_error("Error: #{@last_error}\n#{backtrace}")
       @last_output = captured_output&.string
       nil
     end
@@ -310,6 +310,14 @@ module RailsConsoleAi
       end
     end
 
+    def execute_unsafe(code)
+      guards = RailsConsoleAi.configuration.safety_guards
+      guards.disable!
+      execute(code)
+    ensure
+      guards.enable!
+    end
+
     private
 
     def danger_allowed?
@@ -324,6 +332,15 @@ module RailsConsoleAi
       end
     end
 
+    # Log code execution errors — full details to STDOUT, brief summary to Slack
+    def log_execution_error(msg)
+      if @channel && @channel.mode == 'slack'
+        RailsConsoleAi.logger.info("Code execution error: #{msg}")
+      else
+        display_error(msg)
+      end
+    end
+
     def allow_description(guard, blocked_key)
       case guard
       when :database_writes
@@ -335,14 +352,6 @@ module RailsConsoleAi
       end
     end
 
-    def execute_unsafe(code)
-      guards = RailsConsoleAi.configuration.safety_guards
-      guards.disable!
-      execute(code)
-    ensure
-      guards.enable!
-    end
-
     def execute_prompt
       guards = RailsConsoleAi.configuration.safety_guards
       if !guards.empty? && guards.enabled? && danger_allowed?

data/lib/rails_console_ai/providers/bedrock.rb

@@ -123,6 +123,8 @@ module RailsConsoleAi
                     end
           # Bedrock rejects empty text blocks in content arrays
           content.reject! { |block| block.is_a?(Hash) && block.key?(:text) && !block.key?(:tool_use) && !block.key?(:tool_result) && block[:text].to_s.empty? }
+          # Bedrock also rejects messages with completely empty content arrays
+          content << { text: ' ' } if content.empty?
           { role: msg[:role].to_s, content: content }
         end
 

data/lib/rails_console_ai/repl.rb

@@ -58,8 +58,8 @@ module RailsConsoleAi
       @engine.send(:send_query, query, conversation: conversation)
     end
 
-    def trim_old_outputs(messages)
-      @engine.send(:trim_old_outputs, messages)
+    def trim_large_outputs(messages)
+      @engine.send(:trim_large_outputs, messages)
     end
   end
 end

data/lib/rails_console_ai/skill_loader.rb

@@ -32,8 +32,57 @@ module RailsConsoleAi
       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?
+
+      content = "---\n#{YAML.dump(frontmatter).sub("---\n", '').strip}\n---\n\n#{body}\n"
+      @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
+    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})."
+    end
+
     private
 
+    def skill_key(name)
+      slug = name.downcase.strip
+        .gsub(/[^a-z0-9\s-]/, '')
+        .gsub(/[\s]+/, '-')
+        .gsub(/-+/, '-')
+        .sub(/^-/, '').sub(/-$/, '')
+      "#{SKILLS_DIR}/#{slug}.md"
+    end
+
     def load_skill(key)
       content = @storage.read(key)
       return nil if content.nil? || content.strip.empty?

data/lib/rails_console_ai/slack_bot.rb

@@ -22,7 +22,9 @@ module RailsConsoleAi
 
       raise ConfigurationError, "SLACK_BOT_TOKEN is required" unless @bot_token
       raise ConfigurationError, "SLACK_APP_TOKEN is required (Socket Mode)" unless @app_token
-      raise ConfigurationError, "slack_allowed_usernames must be configured (e.g. ['alice'] or 'ALL')" unless RailsConsoleAi.configuration.slack_allowed_usernames
+      unless RailsConsoleAi.configuration.channel_setting('slack', 'allowed_usernames')
+        raise ConfigurationError, "slack allowed_usernames must be configured — either channels['slack']['allowed_usernames'] or slack_allowed_usernames (e.g. ['alice'] or 'ALL')"
+      end
 
       @bot_user_id = nil
       @sessions = {}       # thread_ts → { channel:, engine:, thread:, owner_user_id: }
@@ -316,8 +318,7 @@ module RailsConsoleAi
           unless session[:owner_user_id] == user_id
             # Non-owner: tell unrecognized users, silently ignore recognized non-owners
             chk_name = resolve_user_name(user_id)
-            chk_list = Array(RailsConsoleAi.configuration.slack_allowed_usernames).map(&:to_s).map(&:downcase)
-            unless chk_list.include?('all') || chk_list.include?(chk_name.to_s.downcase)
+            unless RailsConsoleAi.configuration.username_allowed?('slack', 'allowed_usernames', chk_name)
               puts "[#{channel_id}/#{thread_ts}]#{channel_log_tag(channel_id)} @#{chk_name} << (ignored — not in allowed usernames)"
               post_message(channel: channel_id, thread_ts: thread_ts, text: "Sorry, I don't recognize your username (@#{chk_name}). Ask an admin to add you to the allowed usernames list.")
             end
@@ -338,8 +339,7 @@ module RailsConsoleAi
       # --- Common processing (DMs and channels) ---
       user_name = resolve_user_name(user_id)
 
-      allowed_list = Array(RailsConsoleAi.configuration.slack_allowed_usernames).map(&:to_s).map(&:downcase)
-      unless allowed_list.include?('all') || allowed_list.include?(user_name.to_s.downcase)
+      unless RailsConsoleAi.configuration.username_allowed?('slack', 'allowed_usernames', user_name)
         puts "[#{channel_id}/#{thread_ts}]#{channel_log_tag(channel_id)} @#{user_name} << (ignored — not in allowed usernames)"
         post_message(channel: channel_id, thread_ts: thread_ts, text: "Sorry, I don't recognize your username (@#{user_name}). Ask an admin to add you to the allowed usernames list.")
         return
@@ -450,7 +450,7 @@ module RailsConsoleAi
           end
           engine.process_message(text)
         rescue => e
-          channel.display_error("Error: #{e.class}: #{e.message}")
+          channel.display_error("Something went wrong. Please try again.")
           RailsConsoleAi.logger.error("SlackBot session error: #{e.class}: #{e.message}\n#{e.backtrace.first(5).join("\n")}")
         ensure
           ActiveRecord::Base.clear_active_connections! if defined?(ActiveRecord::Base)
@@ -488,7 +488,7 @@ module RailsConsoleAi
         begin
           engine.process_message(text)
         rescue => e
-          channel.display_error("Error: #{e.class}: #{e.message}")
+          channel.display_error("Something went wrong. Please try again.")
           RailsConsoleAi.logger.error("SlackBot session error: #{e.class}: #{e.message}\n#{e.backtrace.first(5).join("\n")}")
         ensure
           ActiveRecord::Base.clear_active_connections! if defined?(ActiveRecord::Base)
@@ -497,6 +497,14 @@ module RailsConsoleAi
     end
 
     def handle_direct_code(session, channel_id, thread_ts, raw_code, user_name, user_id)
+      # Check code execution permission
+      unless RailsConsoleAi.configuration.username_allowed?('slack', 'allow_code_execution', user_name)
+        puts "[#{channel_id}/#{thread_ts}]#{channel_log_tag(channel_id)} @#{user_name} << (blocked — not in allow_code_execution)"
+        post_message(channel: channel_id, thread_ts: thread_ts,
+          text: "Sorry, you don't have permission to execute code directly. Ask an admin to add you to the `allow_code_execution` list.")
+        return
+      end
+
       # Ensure a session exists for this thread
       unless session
         start_direct_session(channel_id, thread_ts, user_name, user_id)
@@ -521,7 +529,7 @@ module RailsConsoleAi
           end
           engine.send(:log_interactive_turn)
         rescue => e
-          channel.display_error("Error: #{e.class}: #{e.message}")
+          channel.display_error("Something went wrong. Please try again.")
           RailsConsoleAi.logger.error("SlackBot direct code error: #{e.class}: #{e.message}\n#{e.backtrace.first(5).join("\n")}")
         ensure
           ActiveRecord::Base.clear_active_connections! if defined?(ActiveRecord::Base)
@@ -646,7 +654,7 @@ module RailsConsoleAi
             engine.send(:log_interactive_turn)
           rescue => e
             post_message(channel: channel_id, thread_ts: thread_ts,
-              text: "Retry failed: #{e.message}")
+              text: ":x: Retry didn't work. Please try again.")
           ensure
             ActiveRecord::Base.clear_active_connections! if defined?(ActiveRecord::Base)
           end
@@ -744,13 +752,9 @@ module RailsConsoleAi
       history = engine.history
       return "No conversation history yet." if history.empty?
 
-      msg_count = history.length
-      chars = history.sum { |m| m[:content].to_s.length }
-      user_msgs = history.count { |m| m[:role].to_s == 'user' }
-      asst_msgs = history.count { |m| m[:role].to_s == 'assistant' }
-      name_str = engine.session_name ? " (*#{engine.session_name}*)" : ""
-
-      "Context#{name_str}: #{msg_count} messages (#{user_msgs} user, #{asst_msgs} assistant), ~#{chars} chars"
+      buf = StringIO.new
+      engine.send(:display_conversation_to, buf)
+      "```\n#{buf.string}```"
     end
 
     def count_bot_messages(channel_id, thread_ts)

data/lib/rails_console_ai/tools/memory_tools.rb

@@ -50,6 +50,20 @@ module RailsConsoleAi
         "FAILED to delete memory (#{e.message})."
       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
+        return "No memory found: \"#{name}\"" unless memory
+
+        line = "**#{memory['name']}**\n#{memory['description']}"
+        line += "\nTags: #{memory['tags'].join(', ')}" if memory['tags'] && !memory['tags'].empty?
+        line
+      end
+
       def recall_memories(query: nil, tag: nil)
         memories = load_all_memories
         return "No memories stored yet." if memories.empty?
@@ -61,11 +75,14 @@ module RailsConsoleAi
           }
         end
         if query && !query.empty?
-          q = query.downcase
+          words = query.downcase.split(/\s+/)
           results = results.select { |m|
-            m['name'].to_s.downcase.include?(q) ||
-            m['description'].to_s.downcase.include?(q) ||
-            Array(m['tags']).any? { |t| t.downcase.include?(q) }
+            searchable = [
+              m['name'].to_s.downcase,
+              m['description'].to_s.downcase,
+              Array(m['tags']).map(&:downcase).join(' ')
+            ].join(' ')
+            words.all? { |w| searchable.include?(w) }
           }
         end
 
@@ -75,7 +92,7 @@ module RailsConsoleAi
           line = "**#{m['name']}**\n#{m['description']}"
           line += "\nTags: #{m['tags'].join(', ')}" if m['tags'] && !m['tags'].empty?
           line
-        }.join("\n\n")
+        }.join("\n\n---\n\n")
       end
 
       def memory_summaries

data/lib/rails_console_ai/tools/model_tools.rb

@@ -35,6 +35,34 @@ module RailsConsoleAi
         result = "Model: #{model.name}\n"
         result += "Table: #{model.table_name}\n"
 
+        # Columns and indexes from the database table
+        begin
+          if ActiveRecord::Base.connected?
+            conn = ActiveRecord::Base.connection
+            if conn.tables.include?(model.table_name)
+              cols = conn.columns(model.table_name).map do |c|
+                parts = ["#{c.name}:#{c.type}"]
+                parts << "nullable" if c.null
+                parts << "default=#{c.default}" unless c.default.nil?
+                parts.join(" ")
+              end
+              result += "Columns:\n"
+              cols.each { |c| result += "  #{c}\n" }
+
+              indexes = conn.indexes(model.table_name).map do |idx|
+                unique = idx.unique ? "UNIQUE " : ""
+                "#{unique}INDEX on (#{idx.columns.join(', ')})"
+              end
+              unless indexes.empty?
+                result += "Indexes:\n"
+                indexes.each { |i| result += "  #{i}\n" }
+              end
+            end
+          end
+        rescue => e
+          # table introspection may fail
+        end
+
         assocs = model.reflect_on_all_associations.map { |a| "#{a.macro} :#{a.name}" }
         unless assocs.empty?
           result += "Associations:\n"

data/lib/rails_console_ai/tools/registry.rb

@@ -6,7 +6,7 @@ module RailsConsoleAi
       attr_reader :definitions
 
       # Tools that should never be cached (side effects or user interaction)
-      NO_CACHE = %w[ask_user save_memory delete_memory execute_code execute_plan activate_skill].freeze
+      NO_CACHE = %w[ask_user save_memory delete_memory recall_memory execute_code execute_plan activate_skill save_skill delete_skill].freeze
 
       def initialize(executor: nil, mode: :default, channel: nil)
         @executor = executor
@@ -111,7 +111,7 @@ module RailsConsoleAi
 
         register(
           name: 'describe_table',
-          description: 'Get column names and types for a specific database table.',
+          description: 'Get column names, types, and indexes for a database table. Use this only for tables that have no corresponding ActiveRecord model — for tables with models, use describe_model instead (it includes columns).',
           parameters: {
             'type' => 'object',
             'properties' => {
@@ -131,7 +131,7 @@ module RailsConsoleAi
 
         register(
           name: 'describe_model',
-          description: 'Get detailed info about a specific model: associations, validations, table name.',
+          description: 'Get full details about a model: columns, indexes, associations, validations, and scopes. This is the primary tool for understanding a model — it includes the table schema.',
           parameters: {
             'type' => 'object',
             'properties' => {
@@ -270,6 +270,19 @@ module RailsConsoleAi
           handler: ->(args) { memory.delete_memory(name: args['name']) }
         )
 
+        register(
+          name: 'recall_memory',
+          description: 'Retrieve a specific memory by name. Use this when you know which memory you need (e.g. from the Memories list in the system prompt). For searching across memories, use recall_memories instead.',
+          parameters: {
+            'type' => 'object',
+            'properties' => {
+              'name' => { 'type' => 'string', 'description' => 'The exact memory name (e.g. "Sharding architecture")' }
+            },
+            'required' => ['name']
+          },
+          handler: ->(args) { memory.recall_memory(name: args['name']) }
+        )
+
         register(
           name: 'recall_memories',
           description: 'Search your saved memories about this codebase. Call with no args to list all, or pass a query/tag to filter.',
@@ -312,11 +325,56 @@ module RailsConsoleAi
             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.',
+          parameters: {
+            'type' => 'object',
+            'properties' => {
+              'name' => { 'type' => 'string', 'description' => 'Skill name (e.g. "Resurrect deleted BookingPage")' },
+              '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!"])' }
+            },
+            'required' => %w[name description body]
+          },
+          handler: ->(args) {
+            loader.save_skill(
+              name: args['name'],
+              description: args['description'],
+              body: args['body'],
+              tags: args['tags'] || [],
+              bypass_guards_for_methods: args['bypass_guards_for_methods'] || []
+            )
+          }
+        )
+
+        register(
+          name: 'delete_skill',
+          description: 'Delete a skill by name.',
+          parameters: {
+            'type' => 'object',
+            'properties' => {
+              'name' => { 'type' => 'string', 'description' => 'The skill name to delete' }
+            },
+            'required' => ['name']
+          },
+          handler: ->(args) { loader.delete_skill(name: args['name']) }
+        )
       end
 
       def register_execute_plan
         return unless @executor
 
+        # Check per-channel code execution permission
+        if @channel
+          unless RailsConsoleAi.configuration.username_allowed?(@channel.mode, 'allow_code_execution', @channel.user_identity)
+            return
+          end
+        end
+
         register(
           name: 'execute_code',
           description: 'Execute Ruby code in the Rails console and return the result. Use this for all code execution — simple queries, data lookups, reports, etc. The output of puts/print statements is automatically shown to the user. The return value is sent back to you so you can summarize the findings.',

data/lib/rails_console_ai/version.rb

@@ -1,3 +1,3 @@
 module RailsConsoleAi
-  VERSION = '0.22.0'.freeze
+  VERSION = '0.23.0'.freeze
 end

metadata

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