rails_console_ai 0.29.0 → 0.30.0

data/app/controllers/rails_console_ai/skills_controller.rb

@@ -0,0 +1,200 @@
+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
+    end
+
+    # POST /skills/import — accepts a pasted .md blob in params[:content], parses
+    # YAML frontmatter + body, and re-renders `new` with the fields pre-populated.
+    # The user reviews + clicks Create skill to actually persist (normal proposed-
+    # status + version-row flow applies).
+    def import
+      content = params[:content].to_s
+      if content.strip.empty?
+        redirect_to new_skill_path, alert: 'Nothing to parse — paste the .md content into the box first.'
+        return
+      end
+
+      parsed = SkillLoader.parse(content)
+      if parsed.nil? || parsed['name'].to_s.strip.empty?
+        redirect_to new_skill_path,
+                    alert: 'Could not parse. Expected YAML frontmatter (between `---` lines) with at least a `name` field, followed by a markdown body.'
+        return
+      end
+
+      @skill = Skill.new(
+        name: parsed['name'],
+        description: parsed['description'],
+        body: parsed['body']
+      )
+      @skill.tags = Array(parsed['tags'])
+      @skill.bypass_guards_for_methods = Array(parsed['bypass_guards_for_methods'])
+
+      flash.now[:notice] = "Parsed \"#{parsed['name']}\" from pasted content. Review the fields below and click Create skill to save to the DB."
+      render :new
+    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_body  = @to ? @to.body : @skill.body
+      @to_tags  = @to ? Array(@to.tags) : Array(@skill.tags)
+      @to_bypass = @to ? Array(@to.bypass_guards_for_methods) : Array(@skill.bypass_guards_for_methods)
+    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
+      {
+        name:                       params.require(:skill)[:name],
+        description:                params[:skill][:description],
+        body:                       params[:skill][:body],
+        tags:                       split_csv(params[:skill][:tags]),
+        bypass_guards_for_methods:  split_lines(params[:skill][:bypass_guards_for_methods])
+      }
+    end
+
+    def edited_by_param
+      params[:edited_by].presence || 'web'
+    end
+
+    def split_csv(str)
+      str.to_s.split(',').map(&:strip).reject(&:empty?)
+    end
+
+    def split_lines(str)
+      str.to_s.split(/[\r\n]+/).map(&:strip).reject(&:empty?)
+    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,175 @@
+require 'json'
+
+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
+
+    # Attributes that, if changed, invalidate the current approval and revert
+    # the agent back to "proposed". Status / approver columns are excluded so
+    # that an explicit approve! call doesn't reset its own approval.
+    CONTENT_ATTRIBUTES = %w[name description body max_rounds model tools].freeze
+
+    has_many :versions,
+             -> { order(created_at: :desc) },
+             class_name: 'RailsConsoleAi::AgentVersion',
+             foreign_key: :agent_id,
+             dependent: :nullify
+
+    validates :name, presence: true, uniqueness: { case_sensitive: false }
+    validates :status, inclusion: { in: STATUSES }, if: :has_attribute_status?
+
+    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
+
+    # Manual JSON accessor for `tools` — same approach we use for skill tags,
+    # avoids Rails-version-specific `serialize` API.
+    def tools
+      decode_json_array(read_attribute(:tools))
+    end
+
+    def tools=(value)
+      write_attribute(:tools, encode_json_array(value))
+    end
+
+    # Defensive accessors — if `ai_db_migrate` hasn't been run yet, the status
+    # / approval columns may be missing on an older table.
+    def status
+      has_attribute_status? ? read_attribute(:status) : STATUS_PROPOSED
+    end
+
+    def approved_by
+      has_attribute?(:approved_by) ? read_attribute(:approved_by) : nil
+    end
+
+    def approved_at
+      has_attribute?(:approved_at) ? read_attribute(:approved_at) : nil
+    end
+
+    def proposed?; status.to_s == STATUS_PROPOSED; end
+    def approved?; status.to_s == STATUS_APPROVED; end
+
+    def use_count
+      has_attribute?(:use_count) ? (read_attribute(:use_count) || 0) : 0
+    end
+
+    def last_used_at
+      has_attribute?(:last_used_at) ? read_attribute(:last_used_at) : nil
+    end
+
+    def self.record_use!(id)
+      return false unless connection.column_exists?(table_name, :use_count)
+      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,
+        '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 has_attribute_status?
+      has_attribute?(:status)
+    end
+
+    def self.decode_json_array(raw)
+      return [] if raw.nil? || (raw.respond_to?(:empty?) && raw.empty?)
+      return raw if raw.is_a?(Array)
+      JSON.parse(raw)
+    rescue JSON::ParserError
+      []
+    end
+
+    def self.encode_json_array(value)
+      JSON.dump(Array(value))
+    end
+
+    def decode_json_array(raw); self.class.decode_json_array(raw); end
+    def encode_json_array(value); self.class.encode_json_array(value); end
+
+    # Assigns attrs, saves, and records one AgentVersion snapshot of the post-save state.
+    # If `preserve_approval` is false (the default), any change to a content attribute
+    # reverts the agent back to "proposed" and clears the approver.
+    def update_with_version!(attrs, edited_by: nil, change_note: nil, preserve_approval: false)
+      transaction do
+        assign_attributes(attrs)
+
+        if !preserve_approval && approved? && content_dirty?
+          self.status      = STATUS_PROPOSED
+          self.approved_by = nil
+          self.approved_at = nil
+        end
+
+        save!
+        RailsConsoleAi::AgentVersion.create!(
+          agent_id:    id,
+          name:        name,
+          description: description,
+          body:        body,
+          max_rounds:  max_rounds,
+          model:       model,
+          tools:       tools,
+          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 content_dirty?
+      CONTENT_ATTRIBUTES.any? { |a| changes.key?(a) }
+    end
+  end
+end

data/app/models/rails_console_ai/agent_version.rb

@@ -0,0 +1,46 @@
+require 'json'
+
+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 tools
+      decode_json_array(read_attribute(:tools))
+    end
+
+    def tools=(value)
+      write_attribute(:tools, encode_json_array(value))
+    end
+
+    private
+
+    def decode_json_array(raw)
+      return [] if raw.nil? || (raw.respond_to?(:empty?) && raw.empty?)
+      return raw if raw.is_a?(Array)
+      JSON.parse(raw)
+    rescue JSON::ParserError
+      []
+    end
+
+    def encode_json_array(value)
+      JSON.dump(Array(value))
+    end
+  end
+end

data/app/models/rails_console_ai/memory.rb

@@ -0,0 +1,98 @@
+require 'json'
+
+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 :name, presence: true, uniqueness: { case_sensitive: false }
+
+    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 tags
+      decode_json_array(read_attribute(:tags))
+    end
+
+    def tags=(value)
+      write_attribute(:tags, encode_json_array(value))
+    end
+
+    def use_count
+      has_attribute?(:use_count) ? (read_attribute(:use_count) || 0) : 0
+    end
+
+    def last_used_at
+      has_attribute?(:last_used_at) ? read_attribute(:last_used_at) : nil
+    end
+
+    def self.record_use!(id)
+      return false unless connection.column_exists?(table_name, :use_count)
+      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,
+        '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,
+          description: description,
+          tags:        tags,
+          edited_by:   edited_by,
+          change_note: change_note
+        )
+      end
+      self
+    end
+
+    private
+
+    def decode_json_array(raw)
+      return [] if raw.nil? || (raw.respond_to?(:empty?) && raw.empty?)
+      return raw if raw.is_a?(Array)
+      JSON.parse(raw)
+    rescue JSON::ParserError
+      []
+    end
+
+    def encode_json_array(value)
+      JSON.dump(Array(value))
+    end
+  end
+end

data/app/models/rails_console_ai/memory_version.rb

@@ -0,0 +1,46 @@
+require 'json'
+
+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 tags
+      decode_json_array(read_attribute(:tags))
+    end
+
+    def tags=(value)
+      write_attribute(:tags, encode_json_array(value))
+    end
+
+    private
+
+    def decode_json_array(raw)
+      return [] if raw.nil? || (raw.respond_to?(:empty?) && raw.empty?)
+      return raw if raw.is_a?(Array)
+      JSON.parse(raw)
+    rescue JSON::ParserError
+      []
+    end
+
+    def encode_json_array(value)
+      JSON.dump(Array(value))
+    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) }