rails_console_ai 0.29.0 → 0.31.0

data/app/controllers/rails_console_ai/skills_controller.rb

@@ -0,0 +1,171 @@
+require 'rails_console_ai/skill_loader'
+
+module RailsConsoleAi
+  class SkillsController < ApplicationController
+    before_action :load_skill, only: [:show, :edit, :update, :destroy, :approve]
+
+    def index
+      @skills = SkillLoader.new.load_all_skills
+      @q = params[:q].to_s.strip
+      unless @q.empty?
+        needle = @q.downcase
+        @skills = @skills.select { |s|
+          [s['name'], s['description'], Array(s['tags']).join(' ')].compact.join(' ').downcase.include?(needle)
+        }
+      end
+
+      @sort = params[:sort].to_s
+      if @sort == 'used'
+        # Most-used first; file/builtin records (no counter) sink to the bottom alphabetically.
+        @skills = @skills.sort_by { |s| [-(s['use_count'].to_i), s['name'].to_s.downcase] }
+      end
+    end
+
+    def show
+      @versions = @skill.versions if @skill.is_a?(RailsConsoleAi::Skill)
+    end
+
+    def new
+      @skill = Skill.new(content: new_skill_template)
+    end
+
+    def create
+      @skill = Skill.new
+      attrs = skill_params
+      begin
+        @skill.update_with_version!(
+          attrs,
+          edited_by: edited_by_param,
+          change_note: params[:change_note].presence
+        )
+        redirect_to skill_path(@skill), notice: 'Skill created.'
+      rescue ActiveRecord::RecordInvalid => e
+        flash.now[:alert] = e.message
+        render :new
+      end
+    end
+
+    def edit
+      redirect_to skills_path, alert: file_skill_message and return unless @skill.is_a?(RailsConsoleAi::Skill)
+    end
+
+    def update
+      redirect_to skills_path, alert: file_skill_message and return unless @skill.is_a?(RailsConsoleAi::Skill)
+
+      begin
+        @skill.update_with_version!(
+          skill_params,
+          edited_by: edited_by_param,
+          change_note: params[:change_note].presence
+        )
+        redirect_to skill_path(@skill), notice: 'Skill updated.'
+      rescue ActiveRecord::RecordInvalid => e
+        flash.now[:alert] = e.message
+        render :edit
+      end
+    end
+
+    def destroy
+      if @skill.is_a?(RailsConsoleAi::Skill)
+        @skill.destroy
+        redirect_to skills_path, notice: 'Skill deleted. Past versions remain in history.'
+      else
+        redirect_to skills_path, alert: file_skill_message
+      end
+    end
+
+    def approve
+      redirect_to skills_path, alert: file_skill_message and return unless @skill.is_a?(RailsConsoleAi::Skill)
+
+      approver = params[:approved_by].presence ||
+                 (request.respond_to?(:remote_user) && request.remote_user.presence) ||
+                 'web'
+
+      if @skill.approved?
+        redirect_to skill_path(@skill), notice: 'Skill is already approved.'
+        return
+      end
+
+      begin
+        @skill.approve!(approved_by: approver)
+        redirect_to skill_path(@skill), notice: "Approved by #{approver}. The AI can now activate this skill."
+      rescue ArgumentError, ActiveRecord::RecordInvalid => e
+        redirect_to skill_path(@skill), alert: "Could not approve: #{e.message}"
+      end
+    end
+
+    # GET /skills/diff?skill_id=&from=&to=
+    def diff
+      @skill = Skill.find(params[:skill_id])
+      @from = @skill.versions.find(params[:from])
+      @to   = params[:to].present? ? @skill.versions.find(params[:to]) : nil
+      # If `to` is omitted, diff against the current skill.
+      @to_label   = @to ? "Version ##{@to.id}" : 'Current'
+      @to_content = @to ? @to.content : @skill.content
+    end
+
+    private
+
+    def load_skill
+      # /skills/:id supports DB ids and file slugs/names. For DB-sourced records we
+      # always return the AR record so write actions (update/destroy/approve) can
+      # operate on it; for file-sourced records we return the loaded Hash (view-only).
+      if params[:id].to_s =~ /\A\d+\z/
+        @skill = Skill.find(params[:id])
+        return
+      end
+
+      # Non-numeric :id — could be a DB-backed name/slug OR a file-only name.
+      # Try the DB by name first; fall back to the union (which surfaces file skills).
+      ar = Skill.where('LOWER(name) = ?', params[:id].to_s.downcase).first
+      if ar.nil?
+        # Maybe the URL has a slugified name (spaces → hyphens, punctuation stripped).
+        ar = Skill.all.find { |s| slugify(s.name) == params[:id] }
+      end
+      if ar
+        @skill = ar
+        return
+      end
+
+      all = SkillLoader.new.load_all_skills
+      @skill = all.find { |s| slugify(s['name']) == params[:id] || s['name'] == params[:id] }
+      raise ActiveRecord::RecordNotFound, "Skill not found: #{params[:id]}" unless @skill
+    end
+
+    def skill_params
+      { content: params.require(:skill)[:content].to_s }
+    end
+
+    def edited_by_param
+      params[:edited_by].presence || 'web'
+    end
+
+    def new_skill_template
+      <<~MD
+        ---
+        name:
+        description:
+        tags: []
+        bypass_guards_for_methods: []
+        ---
+
+        ## When to use
+
+        ## Recipe
+
+        ## Notes
+      MD
+    end
+
+    def slugify(name)
+      name.to_s.downcase.strip
+        .gsub(/[^a-z0-9\s-]/, '')
+        .gsub(/[\s]+/, '-')
+        .gsub(/-+/, '-')
+    end
+
+    def file_skill_message
+      'This skill lives on disk under .rails_console_ai/skills/. Edit the file directly to change it.'
+    end
+  end
+end

data/app/helpers/rails_console_ai/diff_helper.rb

@@ -0,0 +1,114 @@
+require 'erb'
+require 'json'
+
+module RailsConsoleAi
+  module DiffHelper
+    # Render a side-by-side line diff of two strings.
+    #
+    # Returns HTML-safe markup with <span class="diff-add"> and
+    # <span class="diff-del"> rows. Uses a tiny LCS-based algorithm so we
+    # avoid taking on the diff-lcs gem as a runtime dependency.
+    def render_text_diff(left, right, left_label: 'Before', right_label: 'After')
+      a = (left || '').split("\n", -1)
+      b = (right || '').split("\n", -1)
+      ops = diff_ops(a, b)
+
+      rows = []
+      ops.each do |op, l_line, r_line|
+        rows << render_diff_row(op, l_line, r_line)
+      end
+
+      html = +%(<table class="diff-table">)
+      html << %(<thead><tr><th>#{ERB::Util.h(left_label)}</th><th>#{ERB::Util.h(right_label)}</th></tr></thead>)
+      html << %(<tbody>) << rows.join << %(</tbody>)
+      html << %(</table>)
+      html.respond_to?(:html_safe) ? html.html_safe : html
+    end
+
+    # Convenience for diffing two tag arrays / hashes as JSON.
+    def render_json_diff(left_obj, right_obj, **opts)
+      render_text_diff(
+        JSON.pretty_generate(left_obj || []),
+        JSON.pretty_generate(right_obj || []),
+        **opts
+      )
+    end
+
+    private
+
+    def render_diff_row(op, l_line, r_line)
+      l_cell = l_line ? %(<pre>#{ERB::Util.h(l_line)}</pre>) : ''
+      r_cell = r_line ? %(<pre>#{ERB::Util.h(r_line)}</pre>) : ''
+      case op
+      when :equal
+        %(<tr><td>#{l_cell}</td><td>#{r_cell}</td></tr>)
+      when :del
+        %(<tr><td class="diff-del">#{l_cell}</td><td></td></tr>)
+      when :add
+        %(<tr><td></td><td class="diff-add">#{r_cell}</td></tr>)
+      when :change
+        %(<tr><td class="diff-del">#{l_cell}</td><td class="diff-add">#{r_cell}</td></tr>)
+      end
+    end
+
+    # Returns an array of [op, left_line, right_line] tuples using LCS.
+    # ops: :equal, :del, :add, :change.
+    def diff_ops(a, b)
+      lcs = lcs_table(a, b)
+      ops = []
+      i = a.length
+      j = b.length
+      while i > 0 && j > 0
+        if a[i - 1] == b[j - 1]
+          ops.unshift([:equal, a[i - 1], b[j - 1]])
+          i -= 1; j -= 1
+        elsif lcs[i - 1][j] >= lcs[i][j - 1]
+          ops.unshift([:del, a[i - 1], nil])
+          i -= 1
+        else
+          ops.unshift([:add, nil, b[j - 1]])
+          j -= 1
+        end
+      end
+      while i > 0
+        ops.unshift([:del, a[i - 1], nil])
+        i -= 1
+      end
+      while j > 0
+        ops.unshift([:add, nil, b[j - 1]])
+        j -= 1
+      end
+      # Collapse adjacent del+add (or add+del) into a single :change row for readability.
+      collapsed = []
+      idx = 0
+      while idx < ops.length
+        cur, nxt = ops[idx], ops[idx + 1]
+        if nxt && cur[0] == :del && nxt[0] == :add
+          collapsed << [:change, cur[1], nxt[2]]
+          idx += 2
+        elsif nxt && cur[0] == :add && nxt[0] == :del
+          collapsed << [:change, nxt[1], cur[2]]
+          idx += 2
+        else
+          collapsed << cur
+          idx += 1
+        end
+      end
+      collapsed
+    end
+
+    def lcs_table(a, b)
+      table = Array.new(a.length + 1) { Array.new(b.length + 1, 0) }
+      (1..a.length).each do |i|
+        (1..b.length).each do |j|
+          table[i][j] = if a[i - 1] == b[j - 1]
+                          table[i - 1][j - 1] + 1
+                        else
+                          [table[i - 1][j], table[i][j - 1]].max
+                        end
+        end
+      end
+      table
+    end
+  end
+end

data/app/models/rails_console_ai/agent.rb

@@ -0,0 +1,143 @@
+require 'rails_console_ai/agent_loader'
+
+module RailsConsoleAi
+  class Agent < ActiveRecord::Base
+    self.table_name = 'rails_console_ai_agents'
+
+    STATUS_PROPOSED = 'proposed'.freeze
+    STATUS_APPROVED = 'approved'.freeze
+    STATUSES = [STATUS_PROPOSED, STATUS_APPROVED].freeze
+
+    has_many :versions,
+             -> { order(created_at: :desc) },
+             class_name: 'RailsConsoleAi::AgentVersion',
+             foreign_key: :agent_id,
+             dependent: :nullify
+
+    validates :content, presence: true
+    validates :name, presence: true, uniqueness: { case_sensitive: false }
+    validates :status, inclusion: { in: STATUSES }
+    validate  :content_parses
+
+    before_validation :sync_name_from_content
+
+    scope :alphabetical, -> { order(Arel.sql('LOWER(name)')) }
+    scope :approved, -> { where(status: STATUS_APPROVED) }
+    scope :proposed, -> { where(status: STATUS_PROPOSED) }
+
+    def self.connection
+      klass = RailsConsoleAi.configuration.connection_class
+      if klass
+        klass = Object.const_get(klass) if klass.is_a?(String)
+        klass.connection
+      else
+        super
+      end
+    end
+
+    def parsed
+      @parsed ||= (RailsConsoleAi::AgentLoader.parse(content.to_s) || {})
+    end
+
+    def content=(value)
+      @parsed = nil
+      super
+    end
+
+    def description; parsed['description']; end
+    def body;        parsed['body']; end
+    def max_rounds;  parsed['max_rounds']; end
+    def model;       parsed['model']; end
+    def tools;       Array(parsed['tools']); end
+
+    def proposed?; status.to_s == STATUS_PROPOSED; end
+    def approved?; status.to_s == STATUS_APPROVED; end
+
+    def self.record_use!(id)
+      where(id: id).update_all([
+        'use_count = COALESCE(use_count, 0) + 1, last_used_at = ?',
+        Time.now.utc
+      ])
+      true
+    rescue ::ActiveRecord::ActiveRecordError => e
+      RailsConsoleAi.logger.warn("RailsConsoleAi::Agent.record_use!(#{id.inspect}) failed: #{e.message}")
+      false
+    end
+
+    def to_hash
+      {
+        'id'           => id,
+        'name'         => name,
+        'description'  => description,
+        'body'         => body,
+        'max_rounds'   => max_rounds,
+        'model'        => model,
+        'tools'        => tools,
+        'content'      => content,
+        'status'       => status,
+        'approved_by'  => approved_by,
+        'approved_at'  => approved_at,
+        'use_count'    => use_count,
+        'last_used_at' => last_used_at,
+        'source'       => :db,
+        'updated_at'   => updated_at
+      }
+    end
+
+    def update_with_version!(attrs, edited_by: nil, change_note: nil, preserve_approval: false)
+      transaction do
+        assign_attributes(attrs)
+
+        if !preserve_approval && approved? && changes.key?('content')
+          self.status      = STATUS_PROPOSED
+          self.approved_by = nil
+          self.approved_at = nil
+        end
+
+        save!
+        RailsConsoleAi::AgentVersion.create!(
+          agent_id:    id,
+          name:        name,
+          content:     content,
+          status:      status,
+          edited_by:   edited_by,
+          change_note: change_note
+        )
+      end
+      self
+    end
+
+    def approve!(approved_by:)
+      raise ArgumentError, 'approved_by is required' if approved_by.to_s.strip.empty?
+
+      update_with_version!(
+        {
+          status:      STATUS_APPROVED,
+          approved_by: approved_by,
+          approved_at: Time.now.utc
+        },
+        edited_by: approved_by,
+        change_note: "Approved by #{approved_by}",
+        preserve_approval: true
+      )
+    end
+
+    private
+
+    def sync_name_from_content
+      return if content.to_s.strip.empty?
+      parsed_name = parsed['name'].to_s.strip
+      self.name = parsed_name unless parsed_name.empty?
+    end
+
+    def content_parses
+      return if content.to_s.strip.empty?
+      hash = RailsConsoleAi::AgentLoader.parse(content.to_s)
+      if hash.nil?
+        errors.add(:content, "could not be parsed — expected YAML frontmatter between `---` lines followed by a markdown body")
+      elsif hash['name'].to_s.strip.empty?
+        errors.add(:content, "frontmatter is missing a `name:` field")
+      end
+    end
+  end
+end

data/app/models/rails_console_ai/agent_version.rb

@@ -0,0 +1,34 @@
+require 'rails_console_ai/agent_loader'
+
+module RailsConsoleAi
+  class AgentVersion < ActiveRecord::Base
+    self.table_name = 'rails_console_ai_agent_versions'
+
+    belongs_to :agent,
+               class_name: 'RailsConsoleAi::Agent',
+               foreign_key: :agent_id,
+               optional: true
+
+    scope :recent, -> { order(created_at: :desc) }
+
+    def self.connection
+      klass = RailsConsoleAi.configuration.connection_class
+      if klass
+        klass = Object.const_get(klass) if klass.is_a?(String)
+        klass.connection
+      else
+        super
+      end
+    end
+
+    def parsed
+      @parsed ||= (RailsConsoleAi::AgentLoader.parse(content.to_s) || {})
+    end
+
+    def description; parsed['description']; end
+    def body;        parsed['body']; end
+    def max_rounds;  parsed['max_rounds']; end
+    def model;       parsed['model']; end
+    def tools;       Array(parsed['tools']); end
+  end
+end

data/app/models/rails_console_ai/memory.rb

@@ -0,0 +1,103 @@
+require 'rails_console_ai/tools/memory_tools'
+
+module RailsConsoleAi
+  class Memory < ActiveRecord::Base
+    self.table_name = 'rails_console_ai_memories'
+
+    has_many :versions,
+             -> { order(created_at: :desc) },
+             class_name: 'RailsConsoleAi::MemoryVersion',
+             foreign_key: :memory_id,
+             dependent: :nullify
+
+    validates :content, presence: true
+    validates :name, presence: true, uniqueness: { case_sensitive: false }
+    validate  :content_parses
+
+    before_validation :sync_name_from_content
+
+    scope :alphabetical, -> { order(Arel.sql('LOWER(name)')) }
+
+    def self.connection
+      klass = RailsConsoleAi.configuration.connection_class
+      if klass
+        klass = Object.const_get(klass) if klass.is_a?(String)
+        klass.connection
+      else
+        super
+      end
+    end
+
+    def parsed
+      @parsed ||= (RailsConsoleAi::Tools::MemoryTools.parse(content.to_s) || {})
+    end
+
+    def content=(value)
+      @parsed = nil
+      super
+    end
+
+    # Memories don't have a separate description vs body — the markdown body
+    # IS the memory. Parser exposes it under 'description'.
+    def description; parsed['description']; end
+    def tags;        Array(parsed['tags']); end
+
+    def self.record_use!(id)
+      where(id: id).update_all([
+        'use_count = COALESCE(use_count, 0) + 1, last_used_at = ?',
+        Time.now.utc
+      ])
+      true
+    rescue ::ActiveRecord::ActiveRecordError => e
+      RailsConsoleAi.logger.warn("RailsConsoleAi::Memory.record_use!(#{id.inspect}) failed: #{e.message}")
+      false
+    end
+
+    def to_hash
+      {
+        'id'           => id,
+        'name'         => name,
+        'description'  => description,
+        'tags'         => tags,
+        'content'      => content,
+        'use_count'    => use_count,
+        'last_used_at' => last_used_at,
+        'source'       => :db,
+        'updated_at'   => updated_at
+      }
+    end
+
+    def update_with_version!(attrs, edited_by: nil, change_note: nil)
+      transaction do
+        assign_attributes(attrs)
+        save!
+        RailsConsoleAi::MemoryVersion.create!(
+          memory_id:   id,
+          name:        name,
+          content:     content,
+          edited_by:   edited_by,
+          change_note: change_note
+        )
+      end
+      self
+    end
+
+    private
+
+    def sync_name_from_content
+      return if content.to_s.strip.empty?
+      parsed_name = parsed['name'].to_s.strip
+      self.name = parsed_name unless parsed_name.empty?
+    end
+
+    def content_parses
+      return if content.to_s.strip.empty?
+      hash = RailsConsoleAi::Tools::MemoryTools.parse(content.to_s)
+      if hash.nil?
+        errors.add(:content, "could not be parsed — expected YAML frontmatter between `---` lines followed by a markdown body")
+      elsif hash['name'].to_s.strip.empty?
+        errors.add(:content, "frontmatter is missing a `name:` field")
+      end
+    end
+  end
+end

data/app/models/rails_console_ai/memory_version.rb

@@ -0,0 +1,31 @@
+require 'rails_console_ai/tools/memory_tools'
+
+module RailsConsoleAi
+  class MemoryVersion < ActiveRecord::Base
+    self.table_name = 'rails_console_ai_memory_versions'
+
+    belongs_to :memory,
+               class_name: 'RailsConsoleAi::Memory',
+               foreign_key: :memory_id,
+               optional: true
+
+    scope :recent, -> { order(created_at: :desc) }
+
+    def self.connection
+      klass = RailsConsoleAi.configuration.connection_class
+      if klass
+        klass = Object.const_get(klass) if klass.is_a?(String)
+        klass.connection
+      else
+        super
+      end
+    end
+
+    def parsed
+      @parsed ||= (RailsConsoleAi::Tools::MemoryTools.parse(content.to_s) || {})
+    end
+
+    def description; parsed['description']; end
+    def tags;        Array(parsed['tags']); end
+  end
+end

data/app/models/rails_console_ai/session.rb

@@ -4,7 +4,7 @@ module RailsConsoleAi
 
     validates :query, presence: true
     validates :conversation, presence: true
-    validates :mode, presence: true, inclusion: { in: %w[one_shot interactive explain slack] }
+    validates :mode, presence: true, inclusion: { in: %w[one_shot interactive explain slack agent_api] }
 
     scope :recent, -> { order(created_at: :desc) }
     scope :named, ->(name) { where(name: name) }