rails_console_ai 0.13.0

data/lib/rails_console_ai/tools/code_tools.rb

@@ -0,0 +1,126 @@
+module RailsConsoleAI
+  module Tools
+    class CodeTools
+      MAX_FILE_LINES = 500
+      MAX_LIST_ENTRIES = 100
+      MAX_SEARCH_RESULTS = 50
+
+      def list_files(directory = nil)
+        directory = sanitize_directory(directory || 'app')
+        root = rails_root
+        return "Rails.root is not available." unless root
+
+        full_path = File.join(root, directory)
+        return "Directory '#{directory}' not found." unless File.directory?(full_path)
+
+        files = Dir.glob(File.join(full_path, '**', '*.rb')).sort
+        files = files.map { |f| f.sub("#{root}/", '') }
+
+        if files.length > MAX_LIST_ENTRIES
+          truncated = files.first(MAX_LIST_ENTRIES)
+          truncated.join("\n") + "\n... and #{files.length - MAX_LIST_ENTRIES} more files"
+        elsif files.empty?
+          "No Ruby files found in '#{directory}'."
+        else
+          files.join("\n")
+        end
+      rescue => e
+        "Error listing files: #{e.message}"
+      end
+
+      def read_file(path, start_line: nil, end_line: nil)
+        return "Error: path is required." if path.nil? || path.strip.empty?
+
+        root = rails_root
+        return "Rails.root is not available." unless root
+
+        path = sanitize_path(path)
+        full_path = File.expand_path(File.join(root, path))
+
+        # Security: ensure resolved path is under Rails.root
+        unless full_path.start_with?(File.expand_path(root))
+          return "Error: path must be within the Rails application."
+        end
+
+        return "File '#{path}' not found." unless File.exist?(full_path)
+        return "Error: '#{path}' is a directory, not a file." if File.directory?(full_path)
+
+        all_lines = File.readlines(full_path)
+        total = all_lines.length
+
+        # Apply line range if specified (1-based, inclusive)
+        if start_line || end_line
+          s = [(start_line || 1).to_i, 1].max
+          e = [(end_line || total).to_i, total].min
+          return "Error: start_line (#{s}) is beyond end of file (#{total} lines)." if s > total
+          lines = all_lines[(s - 1)..(e - 1)] || []
+          offset = s - 1
+          numbered = lines.each_with_index.map { |line, i| "#{offset + i + 1}: #{line}" }
+          header = "Lines #{s}-#{[e, s + lines.length - 1].min} of #{total}:\n"
+          header + numbered.join
+        elsif total > MAX_FILE_LINES
+          numbered = all_lines.first(MAX_FILE_LINES).each_with_index.map { |line, i| "#{i + 1}: #{line}" }
+          numbered.join + "\n... truncated (#{total} total lines, showing first #{MAX_FILE_LINES}). Use start_line/end_line to read specific sections."
+        else
+          all_lines.each_with_index.map { |line, i| "#{i + 1}: #{line}" }.join
+        end
+      rescue => e
+        "Error reading file '#{path}': #{e.message}"
+      end
+
+      def search_code(query, directory = nil)
+        return "Error: query is required." if query.nil? || query.strip.empty?
+
+        directory = sanitize_directory(directory || 'app')
+        root = rails_root
+        return "Rails.root is not available." unless root
+
+        full_path = File.join(root, directory)
+        return "Directory '#{directory}' not found." unless File.directory?(full_path)
+
+        results = []
+        Dir.glob(File.join(full_path, '**', '*.rb')).sort.each do |file|
+          break if results.length >= MAX_SEARCH_RESULTS
+
+          relative = file.sub("#{root}/", '')
+          File.readlines(file).each_with_index do |line, idx|
+            if line.include?(query)
+              results << "#{relative}:#{idx + 1}: #{line.strip}"
+              break if results.length >= MAX_SEARCH_RESULTS
+            end
+          end
+        rescue => e
+          # skip unreadable files
+        end
+
+        if results.empty?
+          "No matches found for '#{query}' in #{directory}/."
+        else
+          header = "Found #{results.length} match#{'es' if results.length != 1}:\n"
+          header + results.join("\n")
+        end
+      rescue => e
+        "Error searching: #{e.message}"
+      end
+
+      private
+
+      def rails_root
+        if defined?(Rails) && Rails.respond_to?(:root) && Rails.root
+          Rails.root.to_s
+        else
+          nil
+        end
+      end
+
+      def sanitize_path(path)
+        # Remove leading slashes and ../ sequences
+        path.strip.gsub(/\A\/+/, '').gsub(/\.\.\//, '').gsub(/\.\.\\/, '')
+      end
+
+      def sanitize_directory(dir)
+        sanitize_path(dir || 'app')
+      end
+    end
+  end
+end

data/lib/rails_console_ai/tools/memory_tools.rb

@@ -0,0 +1,136 @@
+require 'yaml'
+
+module RailsConsoleAI
+  module Tools
+    class MemoryTools
+      MEMORIES_DIR = 'memories'
+
+      def initialize(storage = nil)
+        @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)
+
+        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
+      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}"
+      end
+
+      def delete_memory(name:)
+        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)
+        @storage.delete(key)
+        "Memory deleted: \"#{memory ? memory['name'] : name}\""
+      rescue Storage::StorageError => e
+        "FAILED to delete memory (#{e.message})."
+      end
+
+      def recall_memories(query: nil, tag: nil)
+        memories = load_all_memories
+        return "No memories stored yet." if memories.empty?
+
+        results = memories
+        if tag && !tag.empty?
+          results = results.select { |m|
+            Array(m['tags']).any? { |t| t.downcase.include?(tag.downcase) }
+          }
+        end
+        if query && !query.empty?
+          q = query.downcase
+          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) }
+          }
+        end
+
+        return "No memories matching your search." if results.empty?
+
+        results.map { |m|
+          line = "**#{m['name']}**\n#{m['description']}"
+          line += "\nTags: #{m['tags'].join(', ')}" if m['tags'] && !m['tags'].empty?
+          line
+        }.join("\n\n")
+      end
+
+      def memory_summaries
+        memories = load_all_memories
+        return nil if memories.empty?
+
+        memories.map { |m|
+          tags = Array(m['tags'])
+          tag_str = tags.empty? ? '' : " [#{tags.join(', ')}]"
+          "- #{m['name']}#{tag_str}"
+        }
+      end
+
+      private
+
+      def memory_key(name)
+        slug = name.downcase.strip
+          .gsub(/[^a-z0-9\s-]/, '')
+          .gsub(/[\s]+/, '-')
+          .gsub(/-+/, '-')
+          .sub(/^-/, '').sub(/-$/, '')
+        "#{MEMORIES_DIR}/#{slug}.md"
+      end
+
+      def load_memory(key)
+        content = @storage.read(key)
+        return nil if content.nil? || content.strip.empty?
+        parse_memory(content)
+      rescue => e
+        RailsConsoleAI.logger.warn("RailsConsoleAI: failed to load memory #{key}: #{e.message}")
+        nil
+      end
+
+      def load_all_memories
+        keys = @storage.list("#{MEMORIES_DIR}/*.md")
+        keys.map { |key| load_memory(key) }.compact
+      rescue => e
+        RailsConsoleAI.logger.warn("RailsConsoleAI: failed to load memories: #{e.message}")
+        []
+      end
+
+      def parse_memory(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)
+      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
+        end
+      end
+    end
+  end
+end

data/lib/rails_console_ai/tools/model_tools.rb

@@ -0,0 +1,95 @@
+module RailsConsoleAI
+  module Tools
+    class ModelTools
+      def list_models
+        return "ActiveRecord is not available." unless defined?(ActiveRecord::Base)
+
+        eager_load_app!
+        models = find_models
+        return "No models found." if models.empty?
+
+        lines = models.map do |model|
+          assoc_names = model.reflect_on_all_associations.map { |a| a.name.to_s }
+          if assoc_names.empty?
+            model.name
+          else
+            "#{model.name} (#{assoc_names.join(', ')})"
+          end
+        end
+
+        lines.join("\n")
+      rescue => e
+        "Error listing models: #{e.message}"
+      end
+
+      def describe_model(model_name)
+        return "ActiveRecord is not available." unless defined?(ActiveRecord::Base)
+        return "Error: model_name is required." if model_name.nil? || model_name.strip.empty?
+
+        eager_load_app!
+        model_name = model_name.strip
+
+        model = find_models.detect { |m| m.name == model_name || m.name.underscore == model_name.underscore }
+        return "Model '#{model_name}' not found. Use list_models to see available models." unless model
+
+        result = "Model: #{model.name}\n"
+        result += "Table: #{model.table_name}\n"
+
+        assocs = model.reflect_on_all_associations.map { |a| "#{a.macro} :#{a.name}" }
+        unless assocs.empty?
+          result += "Associations:\n"
+          assocs.each { |a| result += "  #{a}\n" }
+        end
+
+        begin
+          validators = model.validators.map { |v|
+            attrs = v.attributes.join(', ')
+            kind = v.class.name.split('::').last.sub('Validator', '').downcase
+            "#{kind} on #{attrs}"
+          }.uniq
+          unless validators.empty?
+            result += "Validations:\n"
+            validators.each { |v| result += "  #{v}\n" }
+          end
+        rescue => e
+          # validations may not be accessible
+        end
+
+        # Scopes - detect via singleton methods that aren't inherited
+        begin
+          base = defined?(ApplicationRecord) ? ApplicationRecord : ActiveRecord::Base
+          scope_candidates = (model.singleton_methods - base.singleton_methods)
+            .reject { |m| m.to_s.start_with?('_') || m.to_s.start_with?('find') }
+            .sort
+            .first(20)
+          unless scope_candidates.empty?
+            result += "Possible scopes/class methods:\n"
+            scope_candidates.each { |s| result += "  #{s}\n" }
+          end
+        rescue => e
+          # ignore
+        end
+
+        result
+      rescue => e
+        "Error describing model '#{model_name}': #{e.message}"
+      end
+
+      private
+
+      def find_models
+        base_class = defined?(ApplicationRecord) ? ApplicationRecord : ActiveRecord::Base
+        ObjectSpace.each_object(Class).select { |c|
+          c < base_class && !c.abstract_class? && c.name && !c.name.start_with?('HABTM_')
+        }.sort_by(&:name)
+      end
+
+      def eager_load_app!
+        return unless defined?(Rails) && Rails.respond_to?(:application)
+        Rails.application.eager_load! if Rails.application.respond_to?(:eager_load!)
+      rescue => e
+        # ignore
+      end
+    end
+  end
+end