rails_console_ai 0.29.0 → 0.31.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30c7955113bc3e4ce45989fcc0e93034185fbabc0e95acfa01df56ec397900b5
-  data.tar.gz: 87b0399d973e448404b234820067ed2f20d4148f78613963904c9e288a17d87a
+  metadata.gz: '083adc4ffd8b69f950fbc4ab18f2ac056e8642c6946c8ba46e67e19e4299e0f2'
+  data.tar.gz: a01fef0fe45dfa157d638a7d4edb1ee5c8d9753be3a79956b3ebde220d3ee939
 SHA512:
-  metadata.gz: ad1091c711239e286408f0133378c3597c83075b3f9435a40f43bf2df4fa279cf459cf3af84c58027842d2da4c8bccc5d11bfbec616c6e3ec1212784ad59b764
-  data.tar.gz: 61ea9cc3afd50b35ec3d0740b723a076175731d1289c4a98ee5727aaec78c993abb0b78637cb6ac7ef4b550b81b473ff287d83c32405c8fbd345dbf05b0b3b72
+  metadata.gz: 56b8fdcd0cf445d9480d4e56e252271241af017c8ca51e2a11af36d2158ce4a3a1fdf9670685f931b8cbd0994e6828e6bac08d10247e8bec1af8c66ad83c47f4
+  data.tar.gz: 6ccb72b8b8e9b157b28722d1e532d2abf5df8037f4ba4f1f3635bb37ad8a3441e48d832d903f6f92b6dce80106082215368dde15626eb0fc41d93da60100f261

data/CHANGELOG.md

@@ -2,6 +2,52 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.31.0]
+
+- Simplify DB-backed skills, sub-agents, and memories to a single content field per record, replacing the separate frontmatter/body columns and streamlining the models, controllers, and forms
+- Add options for running agents
+- Fix the `/script/release` script
+
+## [0.30.0]
+
+- Add background agent support — new `run_agent` mechanism to launch agents asynchronously alongside an HTTP API channel
+- Store skills and memories in the database with versioning, side-by-side diff, and restore, in addition to on-disk files
+- Store sub-agents in the database with the same versioned workflow as skills
+- Require human approval before the AI can use DB-backed skills or sub-agents; editing reverts them to proposed
+- Track per-record usage (`use_count`, `last_used_at`) for DB-backed skills, memories, and sub-agents, surfaced in the web UI
+- Add web UI sections for skills, memories, and agents with list / view / create / edit / delete / approve / version history
+- Add `save_agent`, `delete_agent` AI tools and a `target` parameter on `save_skill` / `save_memory` for DB vs file
+- Add a "Paste a .md file" import box on new skill / memory / agent pages that prefills the form from frontmatter
+- Make `RailsConsoleAi.migrate!` re-run column probes on upgrades so new columns are added on existing installs
+- Harden `Skill` / `Agent` model accessors to return safe defaults when newly added columns are not yet present
+- Fix built-in agent `.md` files with UTF-8 characters failing to load under US-ASCII locales
+
+## [Unreleased]
+
+- New skill / memory / agent pages now have a "Paste a .md file" textarea at the top. Paste the contents of a Markdown file with YAML frontmatter (same format used by `.rails_console_ai/{skills,memories,agents}/*.md` and the gem's built-in agents), click "Parse pasted content ↓", and the form fields below are prefilled from the parse. You still click Create to actually save, so the normal proposed-status + version-row flow applies — and you can tweak the parsed content before saving. Useful for moving an existing on-disk record into the versioned DB store
+- `RailsConsoleAi::SkillLoader.parse`, `RailsConsoleAi::AgentLoader.parse`, and `RailsConsoleAi::Tools::MemoryTools.parse` are now public class methods. They return a parsed frontmatter+body hash, or `nil` on malformed input
+
+- Usage tracking for DB-backed skills, memories, and agents. New `use_count` and `last_used_at` columns are bumped atomically (one SQL `UPDATE … SET use_count = use_count + 1, last_used_at = NOW()`, no callbacks, no `updated_at` change) when:
+  - `activate_skill` resolves a DB skill
+  - `recall_memory` resolves a DB memory, or `recall_memories` returns a DB memory in its result set
+  - `delegate_task` resolves a DB sub-agent
+  File / built-in records have no DB row so they're not tracked (the web UI shows `—` for them). System-prompt summary inclusion does **not** count — counters only move when the AI actively invokes/loads the record. Surfaced in the index tables (with a "Sort: most used" toggle) and on each show page (Times activated / Times recalled / Times invoked, plus Last used)
+- Bugfix: `RailsConsoleAi.migrate!` now always re-runs the `setup_*_tables!` methods so column-add probes execute on upgrades. Previously, when the base table already existed, the outer `unless table_exists?` guard skipped column probes entirely, leaving new columns un-added and causing `NameError: undefined local variable or method 'status'` from `Skill#proposed?` on host apps that hadn't fully migrated
+- Bugfix: `Skill` / `Agent` model accessors for `status` / `approved_by` / `approved_at` / `use_count` / `last_used_at` are now defensive — they return safe defaults via `has_attribute?` rather than raising NameError when the column hasn't been added yet. The `status` inclusion validation is also gated on the column being present
+
+- Sub-agents can now be stored in the database, versioned, and approved through the web UI — same workflow as skills. DB-backed agents start as `proposed` and are invisible to `delegate_task` until a human clicks Approve at `/rails_console_ai/agents`; editing an approved agent reverts it to proposed. Built-in (gem-shipped) and file-based agents are pre-approved and continue working unchanged
+- New AI tools `save_agent` and `delete_agent` — the AI can now draft a sub-agent definition (lands as proposed, awaits human approval) and request deletion. `delegate_task` now emits a specific "awaiting human approval" error when the AI references a proposed DB agent
+- New web UI section at `/rails_console_ai/agents` with three-source listing (DB / FILE / BUILTIN badges) plus the full skills-style CRUD + version history + diff + restore + approve. Built-in agents are read-only with a "Create DB override" link that prefills the new-agent form
+- `ai_db_setup` / `ai_db_migrate` now also create `rails_console_ai_agents` and `rails_console_ai_agent_versions` tables idempotently
+- Fix: built-in agent .md files containing UTF-8 (em-dashes, smart quotes) now load correctly. `safe_load_builtin_agents` was using `File.read`'s locale-default encoding, which silently swallowed `Encoding::CompatibilityError` on US-ASCII locales
+
+- Skills and memories can now be stored in the database (in addition to the existing on-disk `.rails_console_ai/skills` and `.rails_console_ai/memories` files). DB-backed records are versioned — every save creates a `SkillVersion` / `MemoryVersion` row with `edited_by` and an optional change note
+- DB-backed skills start in a **proposed** state and cannot be activated by the AI until a human approves them in the web UI. Editing an approved skill reverts it to proposed. File-backed skills are unaffected (already git-tracked, considered pre-approved). Memories are not gated
+- `SkillLoader#load_all_skills` and `MemoryTools#load_all_memories` now return the union of DB and file records (DB wins on name collision). `SkillLoader#find_skill` / `skill_summaries` filter out proposed skills so the AI never sees them
+- `save_skill` / `save_memory` AI tools accept an optional `target` parameter (`"db"` default, `"file"` to write to disk) plus `change_note`. When the AI saves a DB skill, the tool response tells it the skill is awaiting human approval
+- New web UI sections at `/rails_console_ai/skills` and `/rails_console_ai/memories` provide list, view, create, edit, delete, version history, side-by-side diff, and restore. Skills also have an Approve button and PROPOSED / APPROVED badges. File-sourced records are surfaced but read-only in the UI
+- `ai_db_setup` / `ai_db_migrate` now create the new `rails_console_ai_skills`, `rails_console_ai_skill_versions`, `rails_console_ai_memories`, and `rails_console_ai_memory_versions` tables idempotently, plus the `status` / `approved_by` / `approved_at` columns on skills
+
 ## [0.29.0]
 
 - Allow steering Slack conversations mid-run by sending follow-up messages that are folded in as user guidance at the next tool-loop boundary

data/README.md

@@ -504,6 +504,71 @@ This starts a long-running process (run it separately from your web server). The
 - **Channels** — the bot only responds when @mentioned. @mention it in any channel message or thread to start a session. The person who first @mentions the bot owns the session — only they can continue the conversation, and they must @mention the bot on each message. Exception: when the bot asks a question, the owner can reply without @mentioning.
 - **Joining threads** — when @mentioned mid-thread, the bot reads the thread history for context so it understands what's already been discussed.
 
+## Background Agents
+
+Fire off agent runs from your application code and pick up the result later. Useful when you want to delegate a question (or a multi-step task) to the AI from a controller action, a job, a webhook handler, or any place where blocking on an LLM round-trip is undesirable.
+
+```ruby
+id = RailsConsoleAi.run_agent("How many users signed up yesterday?", name: 'daily-stats', user_name: 'cron')
+# => 4821 (Integer session id, returned immediately)
+
+RailsConsoleAi.check_agent(id)
+# => 'queued' | 'running' | 'ready' | 'failed' | nil
+
+RailsConsoleAi.get_agent_response(id)
+# => { status: 'ready', result: "1,432 users signed up yesterday.\n", error: nil }
+```
+
+`run_agent` enqueues a row in the sessions table with `mode='agent_api'` and `status='queued'`. A separate long-running rake task picks them up and runs each in its own thread using the same engine that powers `ai "..."` in the console.
+
+### Per-run options
+
+`run_agent` accepts two extra keyword arguments to tune individual runs:
+
+```ruby
+RailsConsoleAi.run_agent(
+  "Trace why nightly billing is double-charging some accounts",
+  use_thinking_model: true,        # run on the thinking-tier model (e.g. Opus)
+  max_wall_clock_seconds: 1800     # hard kill after 30 minutes; pass nil for no cap
+)
+```
+
+- `use_thinking_model:` (default `false`) — switches the run to `config.thinking_model` (or the provider default thinking model) for the duration of the agent. Useful for harder, multi-step problems.
+- `max_wall_clock_seconds:` (default `600`) — hard ceiling on wall-clock time. If the run exceeds the cap, the worker thread is killed and the session is marked `status='failed'` with `error_message: "exceeded max_wall_clock_seconds (Ns)"`. Pass `nil` to opt out of any cap.
+
+These (along with any future per-run options) are stored in a JSON `options` column on the session row, so they survive the handoff to the background runner.
+
+### Running the background runner
+
+```bash
+bundle exec rake rails_console_ai:agents
+# AGENT_CONCURRENCY=3 by default; bump it for more parallelism
+AGENT_CONCURRENCY=8 bundle exec rake rails_console_ai:agents
+```
+
+The background runner polls every 2 seconds, claims queued rows atomically (only one worker wins a row), and updates each row to `status='ready'` with the result, or `status='failed'` with an error message. SIGINT/SIGTERM triggers a graceful drain — up to 60 seconds for in-flight jobs, then any stragglers are marked `failed`.
+
+Run it separately from your web server, alongside (or instead of) the Slack bot. If the process crashes mid-job, rows stuck in `status='running'` are left as-is — no built-in reaper yet.
+
+### Requirements
+
+- `RailsConsoleAi.setup!` must have been run so the sessions table has the `status`, `result`, `error_message`, and `options` columns. `ai_db_setup` (or `ai_db_migrate` on existing installs) handles this.
+- `session_logging` must be enabled (it is by default).
+
+### Behavior notes
+
+- The agent runs with `Channel::Api`, a non-interactive channel — `prompt` returns `''` and `confirm` auto-yes, so the agent never blocks waiting for human input. Safety guards are always on (`supports_danger?` is `false`), and `bypass_guards_for_methods` still applies as usual.
+- `result` is composed from the agent's prose answer plus the inspected return value of any code it executed:
+
+  ```
+  Let me query the users table for signups from yesterday.
+
+  Result: 1432
+  ```
+
+  If the agent answers without running code, you get just the prose. The raw code, its stdout, and the raw return value also live on the session row as `code_executed` / `code_output` / `code_result` if you need them.
+- The queue row and the result row are the same row, so the existing session viewer at `/rails_console_ai` shows background runs alongside REPL and Slack sessions.
+
 ## Requirements
 
 Ruby >= 2.5, Rails >= 5.0, Faraday >= 1.0. For Bedrock: `aws-sdk-bedrockruntime` (loaded lazily, not a hard dependency).

data/app/controllers/rails_console_ai/agent_versions_controller.rb

@@ -0,0 +1,29 @@
+module RailsConsoleAi
+  class AgentVersionsController < ApplicationController
+    before_action :load_agent
+
+    def index
+      @versions = @agent.versions
+    end
+
+    def show
+      @version = @agent.versions.find(params[:id])
+    end
+
+    def restore
+      version = @agent.versions.find(params[:id])
+      @agent.update_with_version!(
+        { content: version.content },
+        edited_by: params[:edited_by].presence || 'web',
+        change_note: "Restored from version ##{version.id}"
+      )
+      redirect_to agent_path(@agent), notice: "Restored version ##{version.id}."
+    end
+
+    private
+
+    def load_agent
+      @agent = Agent.find(params[:agent_id])
+    end
+  end
+end

data/app/controllers/rails_console_ai/agents_controller.rb

@@ -0,0 +1,176 @@
+require 'rails_console_ai/agent_loader'
+
+module RailsConsoleAi
+  class AgentsController < ApplicationController
+    before_action :load_agent, only: [:show, :edit, :update, :destroy, :approve]
+
+    def index
+      @agents = AgentLoader.new.load_all_agents
+      @q = params[:q].to_s.strip
+      unless @q.empty?
+        needle = @q.downcase
+        @agents = @agents.select { |a|
+          [a['name'], a['description'], Array(a['tools']).join(' ')].compact.join(' ').downcase.include?(needle)
+        }
+      end
+
+      @sort = params[:sort].to_s
+      if @sort == 'used'
+        @agents = @agents.sort_by { |a| [-(a['use_count'].to_i), a['name'].to_s.downcase] }
+      end
+    end
+
+    def show
+      @versions = @agent.versions if @agent.is_a?(RailsConsoleAi::Agent)
+    end
+
+    def new
+      # Allow prefilling from a built-in (the "Create override" action on the show page).
+      @agent = Agent.new
+      if params[:from_builtin].present?
+        builtin = AgentLoader.new.load_all_agents.find { |a|
+          a['source'] == :builtin && a['name'].to_s.downcase == params[:from_builtin].to_s.downcase
+        }
+        if builtin
+          @agent.content = AgentLoader.dump(
+            name: builtin['name'],
+            description: builtin['description'],
+            body: builtin['body'],
+            max_rounds: builtin['max_rounds'],
+            model: builtin['model'],
+            tools: Array(builtin['tools'])
+          )
+        end
+      end
+      @agent.content ||= new_agent_template
+    end
+
+    def create
+      @agent = Agent.new
+      begin
+        @agent.update_with_version!(
+          agent_params,
+          edited_by: edited_by_param,
+          change_note: params[:change_note].presence
+        )
+        redirect_to agent_path(@agent), notice: 'Agent created.'
+      rescue ActiveRecord::RecordInvalid => e
+        flash.now[:alert] = e.message
+        render :new
+      end
+    end
+
+    def edit
+      redirect_to agents_path, alert: read_only_message and return unless @agent.is_a?(RailsConsoleAi::Agent)
+    end
+
+    def update
+      redirect_to agents_path, alert: read_only_message and return unless @agent.is_a?(RailsConsoleAi::Agent)
+
+      begin
+        @agent.update_with_version!(
+          agent_params,
+          edited_by: edited_by_param,
+          change_note: params[:change_note].presence
+        )
+        redirect_to agent_path(@agent), notice: 'Agent updated.'
+      rescue ActiveRecord::RecordInvalid => e
+        flash.now[:alert] = e.message
+        render :edit
+      end
+    end
+
+    def destroy
+      if @agent.is_a?(RailsConsoleAi::Agent)
+        @agent.destroy
+        redirect_to agents_path, notice: 'Agent deleted. Past versions remain in history.'
+      else
+        redirect_to agents_path, alert: read_only_message
+      end
+    end
+
+    def approve
+      redirect_to agents_path, alert: read_only_message and return unless @agent.is_a?(RailsConsoleAi::Agent)
+
+      approver = params[:approved_by].presence || 'web'
+
+      if @agent.approved?
+        redirect_to agent_path(@agent), notice: 'Agent is already approved.'
+        return
+      end
+
+      begin
+        @agent.approve!(approved_by: approver)
+        redirect_to agent_path(@agent), notice: "Approved by #{approver}. The AI can now invoke this agent via delegate_task."
+      rescue ArgumentError, ActiveRecord::RecordInvalid => e
+        redirect_to agent_path(@agent), alert: "Could not approve: #{e.message}"
+      end
+    end
+
+    def diff
+      @agent = Agent.find(params[:agent_id])
+      @from = @agent.versions.find(params[:from])
+      @to   = params[:to].present? ? @agent.versions.find(params[:to]) : nil
+      @to_label   = @to ? "Version ##{@to.id}" : 'Current'
+      @to_content = @to ? @to.content : @agent.content
+    end
+
+    private
+
+    def load_agent
+      if params[:id].to_s =~ /\A\d+\z/
+        @agent = Agent.find(params[:id])
+        return
+      end
+
+      # Non-numeric :id — prefer the AR record if a DB row matches by name or slug.
+      ar = Agent.where('LOWER(name) = ?', params[:id].to_s.downcase).first
+      ar ||= Agent.all.find { |a| slugify(a.name) == params[:id] }
+      if ar
+        @agent = ar
+        return
+      end
+
+      all = AgentLoader.new.load_all_agents
+      @agent = all.find { |a| slugify(a['name']) == params[:id] || a['name'] == params[:id] }
+      raise ActiveRecord::RecordNotFound, "Agent not found: #{params[:id]}" unless @agent
+    end
+
+    def agent_params
+      { content: params.require(:agent)[:content].to_s }
+    end
+
+    def edited_by_param
+      params[:edited_by].presence || 'web'
+    end
+
+    def new_agent_template
+      <<~MD
+        ---
+        name:
+        description:
+        max_rounds:
+        model:
+        tools: []
+        ---
+
+        Persona, strategy, rules…
+      MD
+    end
+
+    def slugify(name)
+      name.to_s.downcase.strip
+        .gsub(/[^a-z0-9\s-]/, '')
+        .gsub(/[\s]+/, '-')
+        .gsub(/-+/, '-')
+    end
+
+    def read_only_message
+      if @agent.is_a?(Hash) && @agent['source'] == :builtin
+        'This is a built-in agent shipped with the gem. To customize it, create a same-named DB agent override.'
+      else
+        'This agent lives on disk under .rails_console_ai/agents/. Edit the file directly to change it.'
+      end
+    end
+  end
+end

data/app/controllers/rails_console_ai/application_controller.rb

@@ -1,5 +1,10 @@
 module RailsConsoleAi
   class ApplicationController < ActionController::Base
+    # Pin to the engine's layout. Without this, Rails layout auto-resolution can
+    # fall back to the host app's `layouts/application` (which usually references
+    # host-only helpers like `logout_url`).
+    layout 'rails_console_ai/application'
+
     protect_from_forgery with: :exception
 
     before_action :rails_console_ai_authenticate!

data/app/controllers/rails_console_ai/memories_controller.rb

@@ -0,0 +1,136 @@
+require 'rails_console_ai/tools/memory_tools'
+
+module RailsConsoleAi
+  class MemoriesController < ApplicationController
+    before_action :load_memory, only: [:show, :edit, :update, :destroy]
+
+    def index
+      @memories = Tools::MemoryTools.new.load_all_memories
+      @q = params[:q].to_s.strip
+      unless @q.empty?
+        needle = @q.downcase
+        @memories = @memories.select { |m|
+          [m['name'], m['description'], Array(m['tags']).join(' ')].compact.join(' ').downcase.include?(needle)
+        }
+      end
+
+      @sort = params[:sort].to_s
+      if @sort == 'used'
+        @memories = @memories.sort_by { |m| [-(m['use_count'].to_i), m['name'].to_s.downcase] }
+      end
+    end
+
+    def show
+      @versions = @memory.versions if @memory.is_a?(RailsConsoleAi::Memory)
+    end
+
+    def new
+      @memory = Memory.new(content: new_memory_template)
+    end
+
+    def create
+      @memory = Memory.new
+      attrs = memory_params
+      begin
+        @memory.update_with_version!(
+          attrs,
+          edited_by: edited_by_param,
+          change_note: params[:change_note].presence
+        )
+        redirect_to memory_path(@memory), notice: 'Memory created.'
+      rescue ActiveRecord::RecordInvalid => e
+        flash.now[:alert] = e.message
+        render :new
+      end
+    end
+
+    def edit
+      redirect_to memories_path, alert: file_memory_message and return unless @memory.is_a?(RailsConsoleAi::Memory)
+    end
+
+    def update
+      redirect_to memories_path, alert: file_memory_message and return unless @memory.is_a?(RailsConsoleAi::Memory)
+
+      begin
+        @memory.update_with_version!(
+          memory_params,
+          edited_by: edited_by_param,
+          change_note: params[:change_note].presence
+        )
+        redirect_to memory_path(@memory), notice: 'Memory updated.'
+      rescue ActiveRecord::RecordInvalid => e
+        flash.now[:alert] = e.message
+        render :edit
+      end
+    end
+
+    def destroy
+      if @memory.is_a?(RailsConsoleAi::Memory)
+        @memory.destroy
+        redirect_to memories_path, notice: 'Memory deleted. Past versions remain in history.'
+      else
+        redirect_to memories_path, alert: file_memory_message
+      end
+    end
+
+    def diff
+      @memory = Memory.find(params[:memory_id])
+      @from = @memory.versions.find(params[:from])
+      @to   = params[:to].present? ? @memory.versions.find(params[:to]) : nil
+      @to_label   = @to ? "Version ##{@to.id}" : 'Current'
+      @to_content = @to ? @to.content : @memory.content
+    end
+
+    private
+
+    def load_memory
+      if params[:id].to_s =~ /\A\d+\z/
+        @memory = Memory.find(params[:id])
+        return
+      end
+
+      # Non-numeric :id — prefer the AR record if a DB row matches by name or slug,
+      # so write actions (update/destroy) get the AR object, not a read-only Hash.
+      ar = Memory.where('LOWER(name) = ?', params[:id].to_s.downcase).first
+      ar ||= Memory.all.find { |m| slugify(m.name) == params[:id] }
+      if ar
+        @memory = ar
+        return
+      end
+
+      all = Tools::MemoryTools.new.load_all_memories
+      @memory = all.find { |m| slugify(m['name']) == params[:id] || m['name'] == params[:id] }
+      raise ActiveRecord::RecordNotFound, "Memory not found: #{params[:id]}" unless @memory
+    end
+
+    def memory_params
+      { content: params.require(:memory)[:content].to_s }
+    end
+
+    def edited_by_param
+      params[:edited_by].presence || 'web'
+    end
+
+    def new_memory_template
+      <<~MD
+        ---
+        name:
+        tags: []
+        ---
+
+        The fact or pattern you're persisting.
+      MD
+    end
+
+    def slugify(name)
+      name.to_s.downcase.strip
+        .gsub(/[^a-z0-9\s-]/, '')
+        .gsub(/[\s]+/, '-')
+        .gsub(/-+/, '-')
+    end
+
+    def file_memory_message
+      'This memory lives on disk under .rails_console_ai/memories/. Edit the file directly to change it.'
+    end
+  end
+end

data/app/controllers/rails_console_ai/memory_versions_controller.rb

@@ -0,0 +1,29 @@
+module RailsConsoleAi
+  class MemoryVersionsController < ApplicationController
+    before_action :load_memory
+
+    def index
+      @versions = @memory.versions
+    end
+
+    def show
+      @version = @memory.versions.find(params[:id])
+    end
+
+    def restore
+      version = @memory.versions.find(params[:id])
+      @memory.update_with_version!(
+        { content: version.content },
+        edited_by: params[:edited_by].presence || 'web',
+        change_note: "Restored from version ##{version.id}"
+      )
+      redirect_to memory_path(@memory), notice: "Restored version ##{version.id}."
+    end
+
+    private
+
+    def load_memory
+      @memory = Memory.find(params[:memory_id])
+    end
+  end
+end

data/app/controllers/rails_console_ai/skill_versions_controller.rb

@@ -0,0 +1,29 @@
+module RailsConsoleAi
+  class SkillVersionsController < ApplicationController
+    before_action :load_skill
+
+    def index
+      @versions = @skill.versions
+    end
+
+    def show
+      @version = @skill.versions.find(params[:id])
+    end
+
+    def restore
+      version = @skill.versions.find(params[:id])
+      @skill.update_with_version!(
+        { content: version.content },
+        edited_by: params[:edited_by].presence || 'web',
+        change_note: "Restored from version ##{version.id}"
+      )
+      redirect_to skill_path(@skill), notice: "Restored version ##{version.id}."
+    end
+
+    private
+
+    def load_skill
+      @skill = Skill.find(params[:skill_id])
+    end
+  end
+end