rubyn-code 0.5.1 → 0.8.0

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

@@ -1,48 +1,119 @@
 # frozen_string_literal: true
 
+require 'time'
+
 module RubynCode
   module CLI
     module Commands
+      # List saved sessions or restore one into the current conversation.
+      #
+      #   /resume                # list sessions, recent first
+      #   /resume <id>           # load session <id> (prompts before clobber)
+      #   /resume <id> --force   # skip the confirm prompt
       class Resume < Base
         def self.command_name = '/resume'
-        def self.description = 'Resume a session or list recent sessions'
+        def self.description = 'List saved sessions or restore one into the current conversation'
+
+        MAX_LIST_ENTRIES = 10
 
         def execute(args, ctx)
-          session_id = args.first
+          persistence = ctx.session_persistence
+          if persistence.nil?
+            ctx.renderer.error('No session persistence wired in. Run a prompt first.')
+            return
+          end
 
-          if session_id
-            resume_session(session_id, ctx)
-          else
-            list_sessions(ctx)
+          opts = parse_args(args)
+
+          if opts[:id].nil?
+            list_sessions(persistence, ctx)
+            return
           end
+
+          restore_session(persistence, opts, ctx)
         end
 
         private
 
-        def resume_session(session_id, ctx)
-          data = ctx.session_persistence.load_session(session_id)
+        def parse_args(args)
+          args.delete('--force')
+          force = args.delete('-y')
+          { id: args.first, force: force }
+        end
+
+        def list_sessions(persistence, ctx)
+          rows = persistence.list_sessions
+          if rows.empty?
+            ctx.renderer.info('No saved sessions yet.')
+            return
+          end
+
+          ctx.renderer.info("Saved sessions (most recent first, up to #{MAX_LIST_ENTRIES}):")
+          rows.first(MAX_LIST_ENTRIES).each do |row|
+            count = row[:message_count].to_i
+            time  = row[:last_activity]
+            title = row[:title].to_s.empty? ? '(untitled)' : row[:title]
+            sid   = row[:session_id]
+            ctx.renderer.info("  #{sid}  #{count} msg  · #{format_time(time)}  · #{title}")
+          end
+        end
+
+        def restore_session(persistence, opts, ctx)
+          loaded = persistence.load_session(opts[:id])
+          if loaded.nil?
+            ctx.renderer.error("Session not found: #{opts[:id]}")
+            return
+          end
+
+          messages = loaded[:messages] || []
+          if messages.empty?
+            ctx.renderer.warning("Session #{opts[:id]} has no messages — nothing to restore.")
+            return
+          end
 
-          if data
-            ctx.conversation.replace!(data[:messages])
-            ctx.renderer.info("Resumed session #{session_id[0..7]}")
-            { action: :set_session_id, session_id: session_id }
-          else
-            ctx.renderer.error("Session not found: #{session_id}")
+          unless confirm_replace(ctx, opts, loaded, messages)
+            ctx.renderer.info('Resume cancelled.')
+            return
           end
+
+          ctx.conversation.replace!(messages)
+          title = loaded[:title].to_s.empty? ? '(untitled)' : loaded[:title]
+          ctx.renderer.info("✓ Resumed session #{opts[:id]} — #{messages.size} messages from '#{title}'")
+        end
+
+        def confirm_replace(ctx, opts, loaded, messages)
+          return true if opts[:force]
+          return true if ctx.conversation.nil?
+          return true if ctx.conversation.messages.empty?
+
+          current = ctx.conversation.messages.size
+          target  = messages.size
+          title   = loaded[:title].to_s.empty? ? '(untitled)' : loaded[:title]
+          prompt  = "Replace current conversation (#{current} messages) " \
+                    "with session #{opts[:id]} '#{title}' (#{target} messages)? [y/N]"
+
+          return false unless ctx.renderer.respond_to?(:ask)
+
+          ctx.renderer.ask(prompt, default: false)
         end
 
-        def list_sessions(ctx)
-          sessions = ctx.session_persistence.list_sessions(
-            project_path: ctx.project_root,
-            limit: 10
-          )
-
-          if sessions.empty?
-            ctx.renderer.info('No previous sessions.')
-          else
-            sessions.each do |s|
-              puts "  #{s[:id][0..7]} | #{s[:title] || 'untitled'} | #{s[:created_at]}"
-            end
+        def format_time(time)
+          return 'never' if time.nil?
+
+          t = begin
+            time.is_a?(Time) ? time : Time.parse(time.to_s)
+          rescue StandardError
+            nil
+          end
+          return 'never' if t.nil?
+
+          delta = Time.now - t
+          case delta
+          when 0...60          then 'just now'
+          when 60...3600       then "#{delta.to_i / 60} min ago"
+          when 3600...86_400   then "#{delta.to_i / 3600} hr ago"
+          when 86_400...604_800 then "#{delta.to_i / 86_400} d ago"
+          else t.strftime('%Y-%m-%d')
           end
         end
       end

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/commands/think.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      # Toggle extended thinking on/off and optionally set the budget.
+      #
+      #   /think             # show current budget
+      #   /think off         # disable
+      #   /think <budget>    # enable with <budget> tokens (e.g. /think 8192)
+      class Think < Base
+        DEFAULT_BUDGET = 8_192
+
+        def self.command_name = '/think'
+        def self.description = 'Toggle or set extended thinking budget (tokens)'
+
+        def execute(args, ctx)
+          arg = args.first
+
+          current = ctx.llm_client.respond_to?(:thinking_budget_tokens) ? ctx.llm_client.thinking_budget_tokens : 0
+
+          case arg
+          when nil
+            show_status(current, ctx)
+          when 'off', '0'
+            ctx.llm_client.thinking_budget_tokens = 0
+            ctx.renderer.info('Extended thinking OFF 🧠✋')
+          when /\A\d+\z/
+            budget = arg.to_i
+            ctx.llm_client.thinking_budget_tokens = budget
+            ctx.renderer.info("Extended thinking ON — budget: #{budget} tokens 🧠")
+          else
+            ctx.renderer.warning("Usage: /think [off|<budget>]. Got: #{arg}")
+          end
+        end
+
+        private
+
+        def show_status(current, ctx)
+          state = current.to_i.positive? ? "ON (#{current} tokens)" : 'OFF'
+          ctx.renderer.info("Extended thinking: #{state}")
+          ctx.renderer.info('Usage: /think <budget>  e.g. /think 8192   (or /think off)')
+        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-5'
       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,111 @@
+# frozen_string_literal: true
+
+require 'rubyn_code/llm/image_reader'
+
+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
+
+      # Extract image references from input and return them as a list of
+      # LLM::ImageBlock instances. Image files (.png/.jpg/.jpeg/.gif/.webp)
+      # are NOT included in `expand` because they're sent as image content
+      # blocks, not as text fances. Non-image files are returned as nil.
+      #
+      # @param input [String]
+      # @return [Array<LLM::ImageBlock>] resolved image blocks (in order)
+      def expand_images(input)
+        return [] unless input.is_a?(String) && input.include?('@')
+
+        scan(input).filter_map do |rel, abs|
+          next unless LLM::ImageReader.image_extension?(rel)
+
+          LLM::ImageReader.for_path(abs)
+        end
+      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?
 
@@ -94,9 +97,22 @@ module RubynCode
 
       def handle_on_tool_result(name, result)
         @renderer.tool_result(name, result)
+        render_todo_checklist
         @spinner.start
       end
 
+      # Refresh the in-turn checklist above the spinner after every tool call.
+      # Only printed if the TodoWrite tool has been used in this turn.
+      def render_todo_checklist
+        return unless @agent_loop.respond_to?(:todo_store)
+
+        store = @agent_loop.todo_store
+        return if store.nil? || store.empty?
+        return if @spinner.done
+
+        @renderer.info("☐ Checklist:\n#{store.render}")
+      end
+
       def handle_on_text(text)
         @spinner.stop
         if @streaming_first_chunk
@@ -109,26 +125,27 @@ 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)
+        image_blocks = expand_image_mentions(input)
+        input = expand_mentions(input)
         @spinner.start
         @streaming_first_chunk = true
 
-        response = @agent_loop.send_message(input)
+        response = @agent_loop.send_message(input, blocks: image_blocks.empty? ? nil : image_blocks)
 
         @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 +154,42 @@ 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
+
+      # Collect image references from @path/to/image.png style mentions and
+      # return them as a list of LLM::ImageBlock hashes ready for the
+      # Agent::Loop. Falls back to [] when no images are attached.
+      def expand_image_mentions(input)
+        blocks = @mention_expander.expand_images(input)
+        if blocks.empty?
+          []
+        else
+          @renderer.info("🖼  Attached images: #{blocks.size}")
+          # Translate via MessageBuilder for adapter-aware shape
+          RubynCode::LLM::MessageBuilder.new.format_content_blocks(blocks)
+        end
+      rescue StandardError
+        []
+      end
+
       def setup_readline!
         completions = @command_registry.completions