rubyn-code 0.5.1 → 0.8.0

data/lib/rubyn_code/cli/repl_commands.rb

@@ -24,8 +24,25 @@ module RubynCode
           Commands::Model, Commands::NewSession, Commands::Mcp,
           Commands::Provider, Commands::InstallSkills,
           Commands::RemoveSkills, Commands::Skills,
-          Commands::Megaplan
+          Commands::Megaplan, Commands::Goal, Commands::Loop,
+          Commands::Agents, Commands::Learning, Commands::Rewind,
+          Commands::Chisel, Commands::ChiselReview, Commands::ChiselAudit,
+          Commands::ChiselDebt, Commands::ChiselGain, Commands::Think, Commands::Effort, Commands::Export
         ].each { |cmd| @command_registry.register(cmd) }
+        register_custom_commands!
+      end
+
+      # Load user-defined slash commands from .rubyn-code/commands/*.md and
+      # ~/.rubyn-code/commands/*.md. Built-in commands always win — a custom
+      # file can't shadow /help, /quit, etc.
+      def register_custom_commands!
+        Commands::CustomLoader.load_all(project_root: @project_root).each do |cmd|
+          next if @command_registry.known?(cmd.command_name)
+
+          @command_registry.register(cmd)
+        end
+      rescue StandardError => e
+        RubynCode::Debug.warn("Custom command load failed: #{e.message}")
       end
 
       def handle_command(command)
@@ -67,7 +84,9 @@ module RubynCode
           background_worker: @background_worker,
           permission_tier: @permission_tier,
           plan_mode: @plan_mode,
-          message_handler: method(:handle_message)
+          message_handler: method(:handle_message),
+          hook_registry: @hook_registry,
+          checkpoint_manager: @checkpoint_manager
         )
       end
 
@@ -85,11 +104,66 @@ module RubynCode
           apply_provider(provider, rest[:model])
         in { action: :spawn_teammate, name: String => name, role: String => role }
           spawn_teammate(name, role)
+        in { action: :run_loop, interval:, max: Integer => max, payload: String => payload }
+          run_loop(interval, max, payload)
+        in { action: :rewound }
+          save_session!
         else
           # Unknown result hash — ignore
         end
       end
 
+      # Drive a /loop. Owned by the REPL so it runs on the main thread (Ctrl-C
+      # stops it) and can re-dispatch slash-command payloads.
+      def run_loop(interval, max, payload)
+        announce_loop(interval, max)
+        payload = decorate_self_paced(payload) unless interval
+        @current_loop = CLI::LoopRunner.new(
+          interval: interval, max_iterations: max,
+          runner: ->(_i) { run_loop_payload(payload) },
+          on_iteration: ->(n, total) { @renderer.system_message("🔁 loop #{n}/#{total}") }
+        )
+        completed = @current_loop.run
+        @renderer.info("🔁 Loop finished after #{completed} iteration#{'s' unless completed == 1}.")
+      rescue Interrupt
+        @renderer.warning('Loop interrupted.')
+      ensure
+        @current_loop = nil
+      end
+
+      def announce_loop(interval, max)
+        cadence = interval ? "every #{format_interval(interval)}" : 'self-paced'
+        @renderer.info("🔁 Looping #{cadence} (up to #{max}×). Press Ctrl-C to stop.")
+      end
+
+      # Execute one iteration. Slash-command payloads are re-dispatched; plain
+      # prompts go through the agent. Returns the agent's text so self-paced
+      # loops can detect the LOOP_DONE sentinel.
+      def run_loop_payload(payload)
+        if payload.start_with?('/')
+          name, *rest = payload.split
+          dispatch_slash_command(name, rest)
+          ''
+        else
+          handle_message(payload).to_s
+        end
+      end
+
+      def decorate_self_paced(payload)
+        return payload if payload.start_with?('/')
+
+        "#{payload}\n\n(You are in a self-paced loop. Keep handling this " \
+          'recurring task. When it no longer needs to run, end your reply ' \
+          "with #{CLI::LoopRunner::DONE_SENTINEL}.)"
+      end
+
+      def format_interval(seconds)
+        return "#{seconds / 3600}h" if (seconds % 3600).zero? && seconds >= 3600
+        return "#{seconds / 60}m" if (seconds % 60).zero? && seconds >= 60
+
+        "#{seconds}s"
+      end
+
       def start_new_session(new_id)
         @session_id = new_id
         @skills_injected = false # re-inject skills on next message

data/lib/rubyn_code/cli/repl_setup.rb

@@ -29,11 +29,16 @@ module RubynCode
 
       def setup_core_services!
         @llm_client = LLM::Client.new
+        @llm_client.thinking_budget_tokens = Config::Settings.new.get('thinking_budget_tokens', 0).to_i
         @conversation = Agent::Conversation.new
         @tool_executor = Tools::Executor.new(project_root: @project_root)
         @context_manager = Context::Manager.new(llm_client: @llm_client)
         @hook_registry = Hooks::Registry.new
-        @hook_runner = Hooks::Runner.new(registry: @hook_registry)
+        @external_hook_dispatcher = Hooks::ExternalDispatcher.new(project_root: @project_root)
+        @hook_runner = Hooks::Runner.new(
+          registry: @hook_registry,
+          external_dispatcher: @external_hook_dispatcher
+        )
         @stall_detector = Agent::LoopDetector.new
       end
 
@@ -45,6 +50,8 @@ module RubynCode
         @skill_matcher = build_skill_matcher
         @web_skill_autoload = build_web_skill_autoload
         @session_persistence = Memory::SessionPersistence.new(@db)
+        @mention_expander = MentionExpander.new(project_root: @project_root)
+        @checkpoint_manager = Checkpoint::Manager.new(project_root: @project_root)
       end
 
       def build_skill_matcher
@@ -127,6 +134,8 @@ module RubynCode
       def setup_hooks!
         Hooks::BuiltIn.register_all!(@hook_registry)
         Hooks::UserHooks.load!(@hook_registry, project_root: @project_root)
+        # Snapshot files before they are mutated so /rewind can restore them.
+        @hook_registry.on(:pre_tool_use, Checkpoint::Hook.new(manager: @checkpoint_manager), priority: 5)
       end
 
       def setup_agent_loop!
@@ -183,11 +192,11 @@ module RubynCode
 
       def setup_mcp_servers!
         @mcp_clients = []
-        server_configs = MCP::Config.load(@project_root)
-        return if server_configs.empty?
+        entries = MCP::Discovery.discover(@project_root)
+        return if entries.empty?
 
-        server_configs.each do |config|
-          connect_mcp_server(config)
+        entries.each do |entry|
+          connect_mcp_server(entry)
         end
 
         at_exit { disconnect_mcp_clients! unless defined?(RSpec) }
@@ -198,9 +207,10 @@ module RubynCode
         client.connect!
         MCP::ToolBridge.bridge(client)
         @mcp_clients << client
-        @renderer.info("MCP server '#{config[:name]}' connected (#{client.tools.size} tools)")
+        source_tag = config.respond_to?(:source) && config.source == :project ? ' [project]' : ' [user]'
+        @renderer.info("MCP server '#{config.name}' connected#{source_tag} (#{client.tools.size} tools)")
       rescue StandardError => e
-        warn "[MCP] Failed to connect '#{config[:name]}': #{e.message}"
+        warn "[MCP] Failed to connect '#{config.name}': #{e.message}"
       end
 
       def disconnect_mcp_clients!

data/lib/rubyn_code/cli/stream_formatter.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'pastel'
-require 'rouge'
 
 module RubynCode
   module CLI
@@ -11,7 +10,6 @@ module RubynCode
     class StreamFormatter
       def initialize(_renderer = nil)
         @pastel = Pastel.new
-        @rouge_formatter = Rouge::Formatters::Terminal256.new(theme: Rouge::Themes::Monokai.new)
         @buffer = +''
         @in_code_block = false
         @code_lang = nil
@@ -98,6 +96,9 @@ module RubynCode
       end
 
       def output_highlighted_code
+        # Lazy so REPL boot never pays for rouge until a code block is rendered.
+        require 'rouge'
+        @rouge_formatter ||= Rouge::Formatters::Terminal256.new(theme: Rouge::Themes::Monokai.new)
         lexer = Rouge::Lexer.find(@code_lang || 'ruby') || Rouge::Lexers::PlainText.new
         highlighted = @rouge_formatter.format(lexer.lex(@code_buffer))
         border = @pastel.dim('  │ ')

data/lib/rubyn_code/cli/version_check.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'faraday'
 require 'json'
 
 module RubynCode
@@ -16,6 +15,7 @@ module RubynCode
       def initialize(renderer:)
         @renderer = renderer
         @thread = nil
+        @notified = false
       end
 
       # Kicks off a background check. Call `notify` later to display results.
@@ -26,11 +26,17 @@ module RubynCode
         @thread.abort_on_exception = false
       end
 
-      # Waits briefly for the check to finish and prints a message if outdated.
-      def notify(timeout: 2)
+      # Prints a message if outdated. Non-blocking by default: if the check
+      # hasn't finished yet, returns immediately so it can be retried before
+      # the next prompt. Notifies at most once.
+      def notify(timeout: 0)
+        return if @notified
         return unless @thread
 
         @thread.join(timeout)
+        return if @thread.alive?
+
+        @notified = true
         return unless @result
 
         return unless newer?(@result, RubynCode::VERSION)
@@ -60,6 +66,7 @@ module RubynCode
       end
 
       def fetch_latest_version
+        require 'faraday'
         conn = Faraday.new do |f|
           f.options.timeout = 5
           f.options.open_timeout = 3

data/lib/rubyn_code/config/defaults.rb

@@ -11,9 +11,14 @@ module RubynCode
       MEMORIES_DIR = File.join(HOME_DIR, 'memories')
 
       DEFAULT_PROVIDER = 'anthropic'
-      DEFAULT_MODEL = 'claude-opus-4-6'
+      DEFAULT_MODEL = 'claude-opus-5'
       MODEL_MODE = 'auto' # 'auto' or 'manual'
       MAX_ITERATIONS = 200
+      # Hard ceiling when a Stop hook (e.g. an active /goal) keeps the agent
+      # working past MAX_ITERATIONS. A goal can legitimately need more tool
+      # turns than a single request; the GoalHook's own max-attempts valve is
+      # the real terminator — this only guards against a runaway loop.
+      GOAL_MAX_ITERATIONS = 2_000
       MAX_SUB_AGENT_ITERATIONS = 200
       MAX_EXPLORE_AGENT_ITERATIONS = 200
 
@@ -33,9 +38,17 @@ module RubynCode
 
       SKILLS_AUTOLOAD = true
 
+      # Chisel: opt-in "write the minimum that works" enforcement. Off by
+      # default — only changes agent behavior once the user turns it on.
+      CHISEL_MODE = 'off'
+      THINKING_BUDGET_TOKENS = 0
+
       SESSION_BUDGET_USD = 5.00
       DAILY_BUDGET_USD = 10.00
 
+      # Claude Code's credentials file (Linux/other — no system keychain)
+      CLAUDE_CREDENTIALS_FILE = File.expand_path('~/.claude/.credentials.json')
+
       OAUTH_CLIENT_ID = 'rubyn-code'
       OAUTH_REDIRECT_URI = 'http://localhost:19275/callback'
       OAUTH_AUTHORIZE_URL = 'https://claude.ai/oauth/authorize'

data/lib/rubyn_code/config/schema.json

@@ -43,6 +43,15 @@
       "type": "number",
       "minimum": 0.5,
       "maximum": 500
+    },
+    "chisel_mode": {
+      "type": "string",
+      "enum": ["off", "lite", "full", "ultra"]
+    },
+    "thinking_budget_tokens": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 200000
     }
   },
   "additionalProperties": true

data/lib/rubyn_code/config/settings.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'yaml'
+require 'tmpdir'
 require 'fileutils'
 require_relative 'defaults'
 
@@ -17,6 +18,8 @@ module RubynCode
         oauth_client_id oauth_redirect_uri oauth_authorize_url
         oauth_token_url oauth_scopes
         skills_autoload
+        chisel_mode
+        thinking_budget_tokens
       ].freeze
 
       DEFAULT_MAP = {
@@ -37,12 +40,20 @@ module RubynCode
         oauth_authorize_url: Defaults::OAUTH_AUTHORIZE_URL,
         oauth_token_url: Defaults::OAUTH_TOKEN_URL,
         oauth_scopes: Defaults::OAUTH_SCOPES,
-        skills_autoload: Defaults::SKILLS_AUTOLOAD
+        skills_autoload: Defaults::SKILLS_AUTOLOAD,
+        chisel_mode: Defaults::CHISEL_MODE,
+        thinking_budget_tokens: Defaults::THINKING_BUDGET_TOKENS
       }.freeze
 
       attr_reader :config_path, :data
 
       def initialize(config_path: Defaults::CONFIG_FILE)
+        # When tests run, isolate Settings from the developer's personal
+        # ~/.rubyn-code/config.yml so a stray `provider: minimax` can't
+        # shadow the test expectations.  The test config lives in
+        # tmpdir, is process-pid-scoped, and is harmless if it leaks.
+        config_path = self.class.test_config_path if config_path == Defaults::CONFIG_FILE && ENV['RUBYN_TESTING']
+
         @config_path = config_path
         @data = {}
         ensure_home_directory!
@@ -51,6 +62,12 @@ module RubynCode
         backfill_provider_models!
       end
 
+      # @return [String] a per-pid path under tmpdir used when
+      #   RUBYN_TESTING is set
+      def self.test_config_path
+        @test_config_path ||= File.join(Dir.tmpdir, "rubyn-test-config-#{Process.pid}.yml")
+      end
+
       # Define accessor methods for each configurable key
       CONFIGURABLE_KEYS.each do |key|
         define_method(key) do
@@ -141,7 +158,7 @@ module RubynCode
       DEFAULT_PROVIDER_MODELS = {
         'anthropic' => {
           'env_key' => 'ANTHROPIC_API_KEY',
-          'models' => { 'cheap' => 'claude-haiku-4-5', 'mid' => 'claude-sonnet-4-6', 'top' => 'claude-opus-4-6' }
+          'models' => { 'cheap' => 'claude-haiku-4-5', 'mid' => 'claude-sonnet-5', 'top' => 'claude-opus-5' }
         },
         'openai' => {
           'env_key' => 'OPENAI_API_KEY',

data/lib/rubyn_code/context/auto_compact.rb

@@ -63,7 +63,7 @@ module RubynCode
         ]
 
         options = {}
-        options[:model] = 'claude-sonnet-4-6' if llm_client.respond_to?(:chat)
+        options[:model] = 'claude-sonnet-5' if llm_client.respond_to?(:chat)
 
         response = llm_client.chat(messages: summary_messages, **options)
 

data/lib/rubyn_code/context/manager.rb

@@ -39,24 +39,30 @@ module RubynCode
         @total_output_tokens += usage.output_tokens.to_i
       end
 
-      # Rough estimate of token count for a set of messages based on their
-      # JSON-serialized character length (~4 chars per token).
+      # Rough estimate of token count based on JSON-serialized character
+      # length (~4 chars per token). Accepts either a raw messages array or
+      # an object exposing #estimated_json_chars (e.g. Agent::Conversation),
+      # which avoids re-serializing the whole history on every call.
       #
-      # @param messages [Array<Hash>] conversation messages
+      # @param source [Array<Hash>, #estimated_json_chars] conversation messages
       # @return [Integer] estimated token count
-      def estimated_tokens(messages)
-        json = JSON.generate(messages)
-        (json.length.to_f / CHARS_PER_TOKEN).ceil
+      def estimated_tokens(source)
+        chars = if source.respond_to?(:estimated_json_chars)
+                  source.estimated_json_chars
+                else
+                  JSON.generate(source).length
+                end
+        (chars.to_f / CHARS_PER_TOKEN).ceil
       rescue JSON::GeneratorError
         0
       end
 
       # Returns true if the estimated token count exceeds the threshold.
       #
-      # @param messages [Array<Hash>] conversation messages
+      # @param source [Array<Hash>, #estimated_json_chars] conversation messages
       # @return [Boolean]
-      def needs_compaction?(messages)
-        estimated_tokens(messages) > @threshold
+      def needs_compaction?(source)
+        estimated_tokens(source) > @threshold
       end
 
       # Runs micro-compaction every turn and auto-compaction when the context
@@ -78,14 +84,17 @@ module RubynCode
         return if @last_compaction_turn == @current_turn
 
         messages = conversation.messages
+        estimate_source = conversation.respond_to?(:estimated_json_chars) ? conversation : messages
 
         # Step 1: Zero-cost micro-compact — but only when we're approaching
         # the compaction threshold. Running it every turn mutates old messages,
         # which invalidates the prompt cache prefix and wastes tokens.
-        est = estimated_tokens(messages)
-        MicroCompact.call(messages) if est > (@threshold * micro_compact_ratio)
+        est = estimated_tokens(estimate_source)
+        if est > (@threshold * micro_compact_ratio) && MicroCompact.call(messages).to_i.positive?
+          refresh_conversation_estimate(conversation)
+        end
 
-        return unless needs_compaction?(messages)
+        return unless needs_compaction?(estimate_source)
 
         # Step 2: Try context collapse (snip old messages, no LLM call)
         collapsed = ContextCollapse.call(messages, threshold: @threshold)
@@ -138,6 +147,14 @@ module RubynCode
         elsif conversation.respond_to?(:messages=)
           conversation.messages = new_messages
         end
+        refresh_conversation_estimate(conversation)
+      end
+
+      # MicroCompact and the compaction strategies mutate or replace messages
+      # outside the conversation's own append path, so its incremental token
+      # bookkeeping must be invalidated afterwards.
+      def refresh_conversation_estimate(conversation)
+        conversation.refresh_derived_state! if conversation.respond_to?(:refresh_derived_state!)
       end
     end
   end

data/lib/rubyn_code/context/manual_compact.rb

@@ -68,7 +68,7 @@ module RubynCode
         ]
 
         options = {}
-        options[:model] = 'claude-sonnet-4-6' if llm_client.respond_to?(:chat)
+        options[:model] = 'claude-sonnet-5' if llm_client.respond_to?(:chat)
 
         response = llm_client.chat(messages: summary_messages, **options)
 

data/lib/rubyn_code/debug.rb

@@ -1,11 +1,7 @@
 # frozen_string_literal: true
 
-require 'pastel'
-
 module RubynCode
   module Debug
-    PASTEL = Pastel.new
-
     @enabled = false
     @output = $stderr
 
@@ -32,7 +28,7 @@ module RubynCode
         return unless enabled?
 
         timestamp = Time.now.strftime('%H:%M:%S.%L')
-        prefix = "#{PASTEL.dim("[#{timestamp}]")} #{PASTEL.send(color, "[#{tag}]")}"
+        prefix = "#{pastel.dim("[#{timestamp}]")} #{pastel.send(color, "[#{tag}]")}"
         @output.puts "#{prefix} #{message}"
       end
 
@@ -69,6 +65,16 @@ module RubynCode
       def error(message)
         log('error', message, color: :red)
       end
+
+      private
+
+      # Lazy so boot never pays for pastel when debug output is off.
+      def pastel
+        @pastel ||= begin
+          require 'pastel'
+          Pastel.new
+        end
+      end
     end
   end
 end

data/lib/rubyn_code/goal/evaluator.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module RubynCode
+  # Session goals: a goal is a plain-language condition the user wants
+  # satisfied before the agent stops working. The Goal::Evaluator judges,
+  # via a lightweight LLM call, whether the condition has been met based on
+  # the recent conversation. Used by Hooks::GoalHook on the :stop event.
+  module Goal
+    # Judges whether a goal condition has been satisfied.
+    #
+    # The evaluator is deliberately conservative: it returns true only when
+    # the model is confident the goal is genuinely complete. Any error or
+    # ambiguous answer is treated as "not met" so the agent keeps working
+    # rather than stopping prematurely.
+    class Evaluator
+      SYSTEM_PROMPT = <<~PROMPT
+        You are a strict completion judge. Given a GOAL and a transcript of an
+        AI coding agent's recent work, decide whether the goal is genuinely and
+        fully satisfied. Be conservative: if there is any doubt, or the work is
+        only partially done, answer NO. Answer with exactly one word on the
+        first line: YES or NO. Optionally add a short reason on the next line.
+      PROMPT
+
+      # Number of trailing conversation messages to show the judge.
+      TRANSCRIPT_WINDOW = 12
+
+      # @param llm_client [LLM::Client]
+      def initialize(llm_client:)
+        @llm_client = llm_client
+      end
+
+      # @param condition [String] the goal condition
+      # @param conversation [Agent::Conversation, nil] recent work to judge
+      # @return [Boolean] true only when the goal is confidently complete
+      def call(condition:, conversation: nil)
+        response = @llm_client.chat(
+          messages: [{ role: 'user', content: prompt(condition, conversation) }],
+          system: SYSTEM_PROMPT
+        )
+        verdict_yes?(answer_text(response))
+      rescue StandardError => e
+        RubynCode::Debug.warn("Goal evaluation failed: #{e.message}")
+        false
+      end
+
+      private
+
+      def prompt(condition, conversation)
+        <<~TEXT
+          GOAL:
+          #{condition}
+
+          RECENT WORK:
+          #{transcript(conversation)}
+
+          Is the goal genuinely and fully satisfied? Answer YES or NO.
+        TEXT
+      end
+
+      def transcript(conversation)
+        return '(no work recorded yet)' unless conversation.respond_to?(:messages)
+
+        Array(conversation.messages).last(TRANSCRIPT_WINDOW).map do |msg|
+          "#{msg[:role]}: #{message_text(msg[:content])}"
+        end.join("\n").slice(0, 6000)
+      end
+
+      def message_text(content)
+        case content
+        when String then content
+        when Array
+          content.filter_map { |b| b.is_a?(Hash) ? (b[:text] || b['text']) : nil }.join(' ')
+        else
+          content.to_s
+        end
+      end
+
+      def answer_text(response)
+        if response.respond_to?(:content)
+          Array(response.content).filter_map { |b| b.respond_to?(:text) ? b.text : nil }.join("\n")
+        elsif response.is_a?(Hash)
+          Array(response[:content] || response['content'])
+            .filter_map { |b| b.is_a?(Hash) ? (b[:text] || b['text']) : nil }.join("\n")
+        else
+          response.to_s
+        end
+      end
+
+      def verdict_yes?(text)
+        first = text.to_s.strip.split("\n").first.to_s.strip.upcase
+        first.start_with?('YES')
+      end
+    end
+  end
+end

data/lib/rubyn_code/hooks/event_map.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Hooks
+    # Maps between internal hook event names (snake_case symbols used by the
+    # in-process Hooks::Runner) and the Claude Code hook event names
+    # (CamelCase strings used by external hooks configured in settings.json).
+    #
+    # Internal hooks fire at these 7 sites:
+    #   :pre_tool_use       — agent/tool_processor.rb#execute_tool
+    #   :post_tool_use      — agent/tool_processor.rb#execute_tool
+    #   :pre_llm_call       — agent/llm_caller.rb
+    #   :post_llm_call      — agent/llm_caller.rb
+    #   :stop               — agent/loop.rb#stop_blocked?
+    #   :session_start      — ide/handlers/prompt_handler.rb (IDE)
+    #   :user_prompt_submit — ide/handlers/prompt_handler.rb (IDE)
+    #
+    # External hooks (Claude Code parity) consume these 9 event names:
+    #   PreToolUse, PostToolUse, UserPromptSubmit, SessionStart,
+    #   SessionEnd, Stop, SubagentStop, PreCompact, Notification
+    module EventMap
+      # Internal symbol => external string
+      TO_EXTERNAL = {
+        pre_tool_use: 'PreToolUse',
+        post_tool_use: 'PostToolUse',
+        pre_llm_call: 'PreCompact',
+        post_llm_call: 'Notification',
+        on_session_end: 'SessionEnd',
+        session_start: 'SessionStart',
+        user_prompt_submit: 'UserPromptSubmit',
+        stop: 'Stop',
+        on_subagent_stop: 'SubagentStop'
+      }.freeze
+
+      # External string => internal symbol
+      TO_INTERNAL = TO_EXTERNAL.invert.freeze
+
+      # Every external event name the dispatcher knows about.
+      EXTERNAL_EVENTS = TO_EXTERNAL.values.freeze
+
+      module_function
+
+      # @param internal [Symbol]
+      # @return [String, nil]
+      def external(internal)
+        TO_EXTERNAL[internal.to_sym]
+      end
+
+      # @param external [String, Symbol]
+      # @return [Symbol, nil]
+      def internal(external)
+        TO_INTERNAL[external.to_s]
+      end
+    end
+  end
+end