rubyn-code 0.5.0 → 0.7.0

data/lib/rubyn_code/cli/repl_setup.rb

@@ -33,7 +33,11 @@ module RubynCode
         @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 +49,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 +133,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!

data/lib/rubyn_code/cli/setup.rb

@@ -95,6 +95,19 @@ module RubynCode
           #
           # To regenerate: rubyn-code --setup
           # To remove:     rm #{path}
+          if [ ! -x "#{pinned_ruby}" ] || [ ! -f "#{gem_wrapper}" ]; then
+            echo "rubyn-code: launcher target missing" >&2
+            [ ! -x "#{pinned_ruby}" ] && echo "  pinned Ruby: #{pinned_ruby}" >&2
+            [ ! -f "#{gem_wrapper}" ] && echo "  gem wrapper: #{gem_wrapper}" >&2
+            echo >&2
+            echo "The Ruby that 'rubyn-code --setup' was pinned against (or the gem" >&2
+            echo "itself) was removed. To recover under your current Ruby:" >&2
+            echo >&2
+            echo "  rm '$0'" >&2
+            echo "  gem install rubyn-code" >&2
+            echo "  rubyn-code --setup" >&2
+            exit 127
+          fi
           exec "#{pinned_ruby}" "#{gem_wrapper}" "$@"
         BASH
       end

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-4-8'
       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,16 @@ 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'
+
       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,10 @@
       "type": "number",
       "minimum": 0.5,
       "maximum": 500
+    },
+    "chisel_mode": {
+      "type": "string",
+      "enum": ["off", "lite", "full", "ultra"]
     }
   },
   "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,7 @@ module RubynCode
         oauth_client_id oauth_redirect_uri oauth_authorize_url
         oauth_token_url oauth_scopes
         skills_autoload
+        chisel_mode
       ].freeze
 
       DEFAULT_MAP = {
@@ -37,12 +39,19 @@ 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
       }.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 +60,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 +156,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-4-6', 'top' => 'claude-opus-4-8' }
         },
         'openai' => {
           'env_key' => 'OPENAI_API_KEY',

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/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