rubyn-code 0.5.0 → 0.7.0

data/lib/rubyn_code/cli/commands/loop.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      # `/loop` — run a prompt or slash command repeatedly, mirroring Claude
+      # Code's /loop. Either on a fixed interval, or self-paced (the agent
+      # decides when the recurring task is done).
+      #
+      #   /loop 5m /review            run /review every 5 minutes
+      #   /loop 30s check the deploy  send a prompt every 30 seconds
+      #   /loop x10 5m /babysit-prs   ...at most 10 times
+      #   /loop keep triaging issues  self-paced (until the agent emits LOOP_DONE)
+      #
+      # Returns a :run_loop action; the REPL owns the actual loop so Ctrl-C
+      # stops it cleanly and slash payloads can be re-dispatched.
+      class Loop < Base
+        def self.command_name = '/loop'
+        def self.description  = 'Repeat a prompt or slash command on an interval (/loop 5m /review)'
+
+        MAX_TOKEN = /\Ax(\d+)\z/i
+
+        def execute(args, ctx)
+          return usage(ctx) if args.empty?
+
+          max, rest = extract_max(args)
+          interval = LoopRunner.parse_interval(rest.first)
+          payload = (interval ? rest[1..] : rest).join(' ').strip
+          return usage(ctx) if payload.empty?
+
+          { action: :run_loop, interval: interval, max: max, payload: payload }
+        end
+
+        private
+
+        # Pull an optional leading "xN" max-iterations token from anywhere in
+        # the first two positions (so both `/loop x5 5m ...` and `/loop 5m ...`
+        # read naturally).
+        def extract_max(args)
+          idx = args[0, 2].index { |a| a.match?(MAX_TOKEN) }
+          return [LoopRunner::DEFAULT_MAX_ITERATIONS, args] unless idx
+
+          max = args[idx][MAX_TOKEN, 1].to_i
+          [max.positive? ? max : LoopRunner::DEFAULT_MAX_ITERATIONS, args[0...idx] + args[(idx + 1)..]]
+        end
+
+        def usage(ctx)
+          ctx.renderer.info('Usage: /loop [xN] [interval] <prompt-or-/command>')
+          ctx.renderer.info('  /loop 5m /review        — run /review every 5 minutes')
+          ctx.renderer.info('  /loop 30s check status  — send a prompt every 30s')
+          ctx.renderer.info('  /loop x3 1m /babysit    — at most 3 times')
+          ctx.renderer.info('  /loop keep triaging     — self-paced (Ctrl-C to stop)')
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/cli/commands/mcp.rb

@@ -30,24 +30,37 @@ module RubynCode
 
         def render_server(cfg)
           client = build_client(cfg)
-          status, tool_count = probe_server(client)
+          status, counts = probe_server(client)
           icon = status_icon(status)
-          tools_label = tool_count ? " (#{tool_count} tools)" : ''
 
-          puts "  #{icon} #{cfg[:name]} [#{status}]#{tools_label}"
+          puts "  #{icon} #{cfg[:name]} [#{status}]#{capability_label(counts)}"
           render_transport_info(cfg)
         ensure
           client&.disconnect! if client&.connected?
         end
 
+        def capability_label(counts)
+          return '' unless counts
+
+          parts = []
+          parts << "#{counts[:tools]} tools"
+          parts << "#{counts[:resources]} resources" if counts[:resources].positive?
+          parts << "#{counts[:prompts]} prompts" if counts[:prompts].positive?
+          " (#{parts.join(', ')})"
+        end
+
         def build_client(cfg)
           MCP::Client.from_config(cfg)
         end
 
         def probe_server(client)
           client.connect!
-          tool_count = client.tools.size
-          [:connected, tool_count]
+          counts = {
+            tools: client.tools.size,
+            resources: client.resources.size,
+            prompts: client.prompts.size
+          }
+          [:connected, counts]
         rescue StandardError
           [:error, nil]
         end

data/lib/rubyn_code/cli/commands/megaplan.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      # `/megaplan` REPL command — mirrors the VS Code chat's chat-resident
+      # megaplan entry. Loads the megaplan skill (from the shared
+      # skills catalog) into the conversation, flips plan mode ON so the
+      # agent is restricted to read-only tools, and kicks off a
+      # conversational interview.
+      #
+      # The interview itself is chat-style here (multi-turn natural-
+      # language Q&A), not the structured question-card UI the VS Code
+      # extension uses. Same skill content driving both surfaces.
+      class Megaplan < Base
+        def self.command_name = '/megaplan'
+        def self.description  = 'Plan a feature in phases (interview, then numbered phase docs)'
+        def self.aliases      = ['/mega-plan'].freeze
+
+        def execute(args, ctx)
+          content = ctx.skill_loader.load('megaplan')
+          ctx.conversation.add_user_message("<skill>#{content}</skill>")
+          ctx.renderer.info('Megaplan mode — interviewer with read-only tools 🧠')
+
+          ctx.send_message(build_prompt(args.join(' ').strip))
+
+          { action: :set_plan_mode, enabled: true }
+        rescue StandardError => e
+          ctx.renderer.error("Megaplan error: #{e.message}")
+          nil
+        end
+
+        private
+
+        def build_prompt(feature)
+          base = <<~PROMPT.strip
+            Conduct a megaplan interview, following the megaplan skill loaded above.
+            Stay strictly read-only: you may inspect files, search code, and check
+            git state, but do NOT edit, write, run shell mutations, or call any
+            destructive tool. Ask ONE question at a time. When you have enough,
+            output the final phase breakdown as a numbered outline.
+          PROMPT
+          return base if feature.empty?
+
+          "#{base}\n\nThe feature to plan: #{feature}"
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/cli/commands/registry.rb

@@ -13,14 +13,16 @@ module RubynCode
           @classes = []
         end
 
-        # Register a command class.
+        # Register a command. Accepts either a command class (built-ins, which
+        # are instantiated per dispatch) or a ready command instance
+        # (user-defined; see Commands::CustomCommand).
         #
-        # @param command_class [Class<Commands::Base>]
+        # @param command [Class<Commands::Base>, #execute]
         # @return [void]
-        def register(command_class)
-          @classes << command_class
-          command_class.all_names.each do |name|
-            @commands[name] = command_class
+        def register(command)
+          @classes << command
+          command.all_names.each do |name|
+            @commands[name] = command
           end
         end
 
@@ -31,10 +33,13 @@ module RubynCode
         # @param ctx [Commands::Context] shared context
         # @return [Symbol, nil] :quit if the command signals exit, nil otherwise
         def dispatch(name, args, ctx)
-          command_class = @commands[name]
-          return :unknown unless command_class
+          command = @commands[name]
+          return :unknown unless command
 
-          command_class.new.execute(args, ctx)
+          # Built-ins are registered as classes (instantiate per call);
+          # user-defined commands are registered as ready instances.
+          instance = command.respond_to?(:new) ? command.new : command
+          instance.execute(args, ctx)
         end
 
         # All registered command names (for tab completion).

data/lib/rubyn_code/cli/commands/rewind.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      # `/rewind` — restore the session to an earlier checkpoint, mirroring
+      # Claude Code's /rewind. A checkpoint is taken at the start of each user
+      # turn, capturing the conversation and the original contents of any files
+      # changed that turn.
+      #
+      #   /rewind                list checkpoints
+      #   /rewind <id>           restore code + conversation to checkpoint <id>
+      #   /rewind <id> code      restore only the files
+      #   /rewind <id> chat      restore only the conversation
+      class Rewind < Base
+        def self.command_name = '/rewind'
+        def self.description  = 'Rewind to an earlier checkpoint (/rewind to list)'
+
+        SCOPES = { 'code' => :code, 'chat' => :chat, 'both' => :both }.freeze
+
+        def execute(args, ctx)
+          manager = ctx.checkpoint_manager
+          return ctx.renderer.info('Checkpoints are not available in this session.') unless manager
+
+          id = args.first
+          return list(manager, ctx) if id.nil?
+
+          restore(manager, ctx, id, args[1])
+        end
+
+        private
+
+        def list(manager, ctx)
+          checkpoints = manager.list
+          return ctx.renderer.info('No checkpoints yet — they are created as you work.') if checkpoints.empty?
+
+          ctx.renderer.info('Checkpoints (newest last):')
+          checkpoints.each do |cp|
+            puts "  #{cp[:id].to_s.rjust(3)}  #{cp[:files]} file(s)  — #{cp[:label]}"
+          end
+          puts
+          ctx.renderer.info('Restore with: /rewind <id> [code|chat]')
+          nil
+        end
+
+        def restore(manager, ctx, id_arg, scope_arg)
+          scope = SCOPES.fetch(scope_arg.to_s, :both)
+          result = manager.restore(id_arg.to_i, ctx.conversation, scope: scope)
+          return ctx.renderer.warning("No checkpoint ##{id_arg}.") unless result
+
+          ctx.renderer.info(restored_message(result, scope))
+          { action: :rewound }
+        end
+
+        def restored_message(result, scope)
+          case scope
+          when :code then "⏪ Restored #{result[:files_restored]} file(s) to checkpoint ##{result[:id]}."
+          when :chat then "⏪ Restored conversation to checkpoint ##{result[:id]}."
+          else "⏪ Rewound to checkpoint ##{result[:id]} (#{result[:files_restored]} file(s) + conversation)."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/cli/first_run.rb

@@ -136,7 +136,7 @@ module RubynCode
       def default_model(provider)
         return 'gpt-5.4' if provider == 'openai'
 
-        'claude-opus-4-6'
+        'claude-opus-4-8'
       end
 
       def display_summary

data/lib/rubyn_code/cli/loop_runner.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    # Drives a repeating execution of a payload (a prompt or slash command).
+    #
+    # Pure orchestration with injected dependencies so it can be unit-tested
+    # without a REPL: the caller supplies a `runner` callable that performs one
+    # iteration and a `sleeper` for the wait between iterations.
+    #
+    # Two modes:
+    #   - interval mode (interval is a positive number of seconds): run, wait,
+    #     run, ... until max_iterations or stopped.
+    #   - self-paced mode (interval is nil): run back-to-back until the runner
+    #     returns :stop, emits the DONE_SENTINEL, or max_iterations is hit.
+    class LoopRunner
+      DEFAULT_MAX_ITERATIONS = 50
+      DONE_SENTINEL = 'LOOP_DONE'
+      UNITS = { 's' => 1, 'm' => 60, 'h' => 3600 }.freeze
+
+      # Parse an interval token like "30s", "5m", "2h", or a bare "45"
+      # (seconds). Returns nil when the token is not a valid interval.
+      #
+      # @param token [String, nil]
+      # @return [Integer, nil] seconds, or nil
+      def self.parse_interval(token)
+        return nil if token.nil?
+
+        match = token.strip.match(/\A(\d+)\s*([smh]?)\z/i)
+        return nil unless match
+
+        amount = match[1].to_i
+        return nil if amount <= 0
+
+        amount * UNITS.fetch(match[2].downcase, 1)
+      end
+
+      # @param interval [Integer, nil] seconds between runs; nil => self-paced
+      # @param runner [#call] ->(iteration_index) => String|:stop
+      # @param max_iterations [Integer] hard cap on iterations
+      # @param sleeper [#call, nil] ->(seconds); defaults to Kernel#sleep
+      # @param on_iteration [#call, nil] ->(n, total) UI callback before each run
+      def initialize(runner:, interval: nil, max_iterations: DEFAULT_MAX_ITERATIONS,
+                     sleeper: nil, on_iteration: nil)
+        @interval = interval
+        @runner = runner
+        @max_iterations = max_iterations
+        @sleeper = sleeper || ->(seconds) { sleep(seconds) }
+        @on_iteration = on_iteration
+        @stopped = false
+      end
+
+      # Request the loop to stop after the current iteration.
+      # @return [void]
+      def stop!
+        @stopped = true
+      end
+
+      # @return [Boolean]
+      def stopped? = @stopped
+
+      # Run the loop.
+      #
+      # @return [Integer] number of iterations completed
+      def run
+        completed = 0
+        @max_iterations.times do |index|
+          break if @stopped
+
+          @on_iteration&.call(index + 1, @max_iterations)
+          result = @runner.call(index)
+          completed += 1
+
+          break if @stopped || done?(result)
+
+          wait_before_next(index)
+        end
+        completed
+      rescue Interrupt
+        completed
+      end
+
+      private
+
+      def wait_before_next(index)
+        return unless @interval && index < @max_iterations - 1
+
+        @sleeper.call(@interval)
+      end
+
+      def done?(result)
+        return true if result == :stop
+
+        result.is_a?(String) && result.include?(DONE_SENTINEL)
+      end
+    end
+  end
+end

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

@@ -23,8 +23,26 @@ module RubynCode
           Commands::Plan, Commands::ContextInfo, Commands::Diff,
           Commands::Model, Commands::NewSession, Commands::Mcp,
           Commands::Provider, Commands::InstallSkills,
-          Commands::RemoveSkills, Commands::Skills
+          Commands::RemoveSkills, Commands::Skills,
+          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)
@@ -66,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
 
@@ -84,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