rubyn-code 0.5.1 → 0.7.0

data/lib/rubyn_code/cli/mention_expander.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    # Expands `@path/to/file` mentions in user input into inline file content,
+    # mirroring Claude Code / Codex `@`-mentions. The original text is kept and
+    # the referenced files are appended as labeled, fenced blocks so the agent
+    # sees both the request and the files it points at.
+    #
+    # Conservative by design: only existing, readable, reasonably-sized regular
+    # files inside the project are expanded. Unresolved mentions (and things
+    # that merely look like mentions, e.g. email addresses) are left untouched.
+    class MentionExpander
+      # A mention is an "@" that doesn't follow a word char or another "@"
+      # (so emails like foo@bar.com don't match), followed by a path-ish run.
+      MENTION = /(?<![\w@])@([^\s@]+)/
+      TRAILING_PUNCT = /[).,;:!?'"]+\z/
+      MAX_FILE_BYTES = 64 * 1024
+      MAX_FILES = 10
+
+      # @param project_root [String]
+      def initialize(project_root:)
+        @project_root = project_root
+      end
+
+      # @param input [String] raw user input
+      # @return [Array(String, Array<String>)] expanded text + resolved rel paths
+      def expand(input)
+        return [input, []] unless input.is_a?(String) && input.include?('@')
+
+        resolved = scan(input)
+        return [input, []] if resolved.empty?
+
+        blocks = resolved.map { |rel, abs| file_block(rel, abs) }
+        ["#{input}\n\n#{blocks.join("\n\n")}", resolved.map(&:first)]
+      end
+
+      private
+
+      # @return [Array<Array(String, String)>] unique [rel, abs] pairs, in order
+      def scan(input)
+        seen = {}
+        input.scan(MENTION).each do |(raw)|
+          rel = raw.sub(TRAILING_PUNCT, '')
+          next if rel.empty?
+
+          abs = resolve(rel)
+          next unless abs && !seen.key?(abs)
+
+          seen[abs] = rel
+          break if seen.size >= MAX_FILES
+        end
+        seen.map { |abs, rel| [rel, abs] }
+      end
+
+      # Resolve a mention to an absolute path inside the project, or nil.
+      def resolve(rel)
+        abs = File.expand_path(rel, @project_root)
+        return nil unless inside_project?(abs)
+        return nil unless File.file?(abs)
+
+        abs
+      rescue StandardError
+        nil
+      end
+
+      def inside_project?(abs)
+        root = File.expand_path(@project_root)
+        abs == root || abs.start_with?("#{root}#{File::SEPARATOR}")
+      end
+
+      def file_block(rel, abs)
+        body = read_truncated(abs)
+        <<~BLOCK.strip
+          @#{rel}:
+          ```
+          #{body}
+          ```
+        BLOCK
+      end
+
+      def read_truncated(abs)
+        content = File.read(abs, MAX_FILE_BYTES + 1)
+        return content if content.bytesize <= MAX_FILE_BYTES
+
+        "#{content.byteslice(0, MAX_FILE_BYTES)}\n… [truncated]"
+      rescue StandardError => e
+        "[could not read file: #{e.message}]"
+      end
+    end
+  end
+end

data/lib/rubyn_code/cli/renderer.rb

@@ -1,14 +1,12 @@
 # frozen_string_literal: true
 
 require 'pastel'
-require 'rouge'
 
 module RubynCode
   module CLI
     class Renderer
       def initialize
         @pastel = Pastel.new
-        @rouge_formatter = Rouge::Formatters::Terminal256.new(theme: Rouge::Themes::Monokai.new)
       end
 
       attr_writer :yolo
@@ -177,6 +175,9 @@ module RubynCode
       end
 
       def render_code_block(code, lang)
+        # 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(lang) || Rouge::Lexers::PlainText.new
         highlighted = @rouge_formatter.format(lexer.lex(code))
         border = @pastel.dim('  │ ')

data/lib/rubyn_code/cli/repl.rb

@@ -31,10 +31,10 @@ module RubynCode
       def run
         @version_check = VersionCheck.new(renderer: @renderer)
         @version_check.start
+        @auto_suggest = Skills::AutoSuggest.new(project_root: @project_root)
+        @auto_suggest.start
 
         @renderer.welcome
-        @version_check.notify
-        check_skill_suggestions!
 
         at_exit { shutdown! }
 
@@ -45,17 +45,20 @@ module RubynCode
 
       private
 
-      def check_skill_suggestions!
-        suggest = Skills::AutoSuggest.new(project_root: @project_root)
-        message = suggest.check
+      # Surface results of the background startup checks (version, skill
+      # suggestions) between prompts — never blocking input on the network.
+      def flush_startup_notices!
+        @version_check&.notify
+        message = @auto_suggest&.pending_message
         @renderer.info(message) if message
       rescue StandardError
-        # Never block session start on suggestion failure
+        # Never block the prompt on startup notices
       end
 
       def run_input_loop
         while @running
           begin
+            flush_startup_notices!
             input = read_input
             break if input.nil?
 
@@ -109,26 +112,26 @@ module RubynCode
 
       # -- sequential steps with interrupt rescue
       def handle_message(input)
+        # Checkpoint before the turn (raw input as label), then expand
+        # @-mentions so the agent sees referenced file contents.
+        @checkpoint_manager&.checkpoint!(label: input, conversation: @conversation)
+        input = expand_mentions(input)
         @spinner.start
         @streaming_first_chunk = true
 
         response = @agent_loop.send_message(input)
 
         @spinner.stop
-        if @streaming_first_chunk
-          @renderer.display(response)
-        else
-          @stream_formatter&.flush
-          @stream_formatter = nil
-          puts
-        end
-
+        render_response(response)
         save_session!
+        response
       rescue Interrupt
         @spinner.stop
         puts
         @renderer.warning('Interrupted — session state preserved')
+        @current_loop&.stop! # Ctrl-C during a /loop iteration stops the loop
         save_session!
+        nil
       rescue BudgetExceededError => e
         @spinner.error
         @renderer.error("Budget exceeded: #{e.message}")
@@ -137,6 +140,26 @@ module RubynCode
         @renderer.error("Error: #{e.message}")
       end
 
+      def render_response(response)
+        if @streaming_first_chunk
+          @renderer.display(response)
+        else
+          @stream_formatter&.flush
+          @stream_formatter = nil
+          puts
+        end
+      end
+
+      # Expand @path file mentions into inline content before the agent sees
+      # the message. Surfaces what was attached so the user knows.
+      def expand_mentions(input)
+        expanded, paths = @mention_expander.expand(input)
+        @renderer.info("📎 Attached: #{paths.join(', ')}") unless paths.empty?
+        expanded
+      rescue StandardError
+        input
+      end
+
       def setup_readline!
         completions = @command_registry.completions
 

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
         ].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

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