rubyn-code 0.7.0 → 0.9.0

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

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'json'
+
+module RubynCode
+  module CLI
+    module Commands
+      # Export the current conversation transcript to a file.
+      #
+      #   /export path/to/transcript.md              # markdown (default)
+      #   /export --format jsonl path/to/transcript.jsonl
+      #   /export path/to/transcript.md --force      # overwrite existing
+      class Export < Base
+        def self.command_name = '/export'
+        def self.description = 'Export conversation transcript to markdown or JSONL'
+
+        MAX_LINE_LENGTH = 100
+
+        # -- CLI arg parsing is intrinsically procedural
+        def execute(args, ctx)
+          opts = parse_args(args)
+          return unless opts
+
+          messages = ctx.conversation.to_a
+          if messages.empty?
+            ctx.renderer.warning('No messages to export.')
+            return
+          end
+
+          path = File.expand_path(opts[:path])
+          dir  = File.dirname(path)
+          FileUtils.mkdir_p(dir) unless File.directory?(dir)
+
+          if File.exist?(path) && !opts[:force] && !tty_yes?(ctx, "File exists at #{path}. Overwrite? [y/N]")
+            ctx.renderer.info('Export cancelled.')
+            return
+          end
+
+          body = opts[:format] == 'jsonl' ? render_jsonl(messages) : render_markdown(messages)
+          File.write(path, body)
+          plural = messages.size == 1 ? '' : 's'
+          ctx.renderer.info("Exported #{messages.size} message#{plural} to #{path}")
+        end
+
+        private
+
+        # @return [Hash{Symbol=>Object}, nil] nil on bad input
+        # -- arg parsing is intrinsically branchy
+        def parse_args(args) # rubocop:disable Metrics/MethodLength -- arg parsing is intrinsically procedural
+          format = 'markdown'
+          force  = false
+          path   = nil
+
+          if (idx = args.index('--format') || args.index('-f'))
+            format = args[idx + 1].to_s
+          end
+          format = case format
+                   when 'md' then 'markdown'
+                   else format
+                   end
+
+          args.each do |a|
+            case a
+            when '--jsonl'
+              format = 'jsonl'
+            when '--markdown', '--md'
+              format = 'markdown'
+            when '--format', '-f'
+              # already handled above
+            when '--force', '-y'
+              force = true
+            when /\A--.+/
+              next
+            else
+              path ||= a
+            end
+          end
+
+          return nil if path.to_s.empty?
+
+          { path: path, format: format, force: force }
+        end
+
+        def render_markdown(messages)
+          title  = 'Rubyn transcript'
+          buffer = String.new
+          buffer << "# #{title}\n\n"
+          buffer << "_Exported at #{Time.now.strftime('%Y-%m-%d %H:%M:%S')}_\n\n"
+          messages.each { |msg| render_markdown_message(buffer, msg) }
+          buffer
+        end
+
+        def render_markdown_message(buffer, msg)
+          role = msg[:role] || msg['role']
+          case role
+          when 'user'
+            text = render_user_text(msg[:content] || msg['content'])
+            buffer << "## User\n\n#{text}\n\n"
+          when 'assistant'
+            render_assistant_blocks(buffer, msg[:content] || msg['content'])
+          when 'tool'
+            buffer << "### tool result\n\n```\n#{msg[:content] || msg['content']}\n```\n\n"
+          end
+        end
+
+        def render_user_text(content)
+          blocks = normalize_content(content)
+          if blocks.any? { |b| block_type(b) == 'image' }
+            blocks.map { |b| block_type(b) == 'image' ? '_(image attachment)_' : text_of(b) }.join("\n")
+          else
+            blocks.map { |b| text_of(b) }.join("\n")
+          end
+        end
+
+        def render_assistant_blocks(buffer, content)
+          blocks = normalize_content(content)
+          if blocks.empty?
+            buffer << "## Assistant\n\n_(empty response)_\n\n"
+            return
+          end
+          blocks.each do |b|
+            render_assistant_block(buffer, b)
+          end
+        end
+
+        def render_assistant_block(buffer, b) # rubocop:disable Naming/MethodParameterName -- short names are clearer here than "block"
+          case block_type(b)
+          when 'text'
+            buffer << "## Assistant\n\n#{text_of(b)}\n\n"
+          when 'thinking'
+            buffer << "<details><summary>thinking</summary>\n\n#{text_of(b)}\n\n</details>\n\n"
+          when 'tool_use'
+            buffer << "[tool: #{b[:name] || b['name']}]\n\n```json\n#{JSON.pretty_generate(input_of(b))}\n```\n\n"
+          end
+        end
+
+        def render_jsonl(messages)
+          lines = messages.map do |msg|
+            role    = msg[:role] || msg['role']
+            raw     = msg[:content] || msg['content']
+            content = raw.is_a?(String) ? raw : normalize_content(raw)
+            "#{JSON.generate(role: role, content: content, timestamp: Time.now.utc.iso8601)}\n"
+          end
+          lines.join
+        end
+
+        # Wrap a String content into a single text block so we can render uniformly.
+        def normalize_content(content)
+          return [{ type: 'text', text: content.to_s }] if content.is_a?(String)
+          return [{ type: 'text', text: '' }] if content.nil?
+
+          content
+        end
+
+        def block_type(block)
+          block[:type] || block['type']
+        end
+
+        def text_of(block)
+          (block[:text] || block['text']).to_s
+        end
+
+        def input_of(block)
+          (block[:input] || block['input']) || {}
+        end
+
+        def tty_yes?(ctx, prompt)
+          ctx.renderer.respond_to?(:ask) ? ctx.renderer.ask(prompt, default: false) : true
+        end
+      end
+    end
+  end
+end

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

@@ -8,37 +8,61 @@ module RubynCode
         def self.description = 'MCP server status'
 
         def execute(_args, ctx)
-          configs = load_configs(ctx.project_root)
+          entries = load_entries(ctx.project_root)
 
-          if configs.empty?
+          if entries.empty?
             ctx.renderer.info('No MCP servers configured.')
             puts '  Add servers to .rubyn-code/mcp.json — see docs/MCP.md for details.'
             return
           end
 
-          ctx.renderer.info("MCP servers (#{configs.size}):")
+          ctx.renderer.info("MCP servers (#{entries.size}):")
           puts
 
-          configs.each { |cfg| render_server(cfg) }
+          entries.each { |entry| render_server(entry) }
         end
 
         private
 
-        def load_configs(project_root)
-          MCP::Config.load(project_root)
+        # Load merged user + project entries via MCP::Discovery so the
+        # output can show which servers came from `~/.rubyn-code/mcp.json`
+        # vs the project-root `.mcp.json`.
+        def load_entries(project_root)
+          MCP::Discovery.discover(project_root)
         end
 
-        def render_server(cfg)
+        def source_label(source)
+          case source
+          when :project then '[project]'
+          when :user    then '[user]'
+          else               '[-]'
+          end
+        end
+
+        def render_server(entry)
+          cfg = entry_to_config(entry)
           client = build_client(cfg)
           status, counts = probe_server(client)
           icon = status_icon(status)
+          label = source_label(entry.respond_to?(:source) ? entry.source : :user)
 
-          puts "  #{icon} #{cfg[:name]} [#{status}]#{capability_label(counts)}"
+          puts "  #{icon} #{entry.name} #{label} [#{status}]#{capability_label(counts)}"
           render_transport_info(cfg)
         ensure
           client&.disconnect! if client&.connected?
         end
 
+        # Discovery::Entry → Config hash shape so existing renderers work.
+        def entry_to_config(entry)
+          {
+            name: entry.name,
+            command: entry.command,
+            args: entry.args,
+            env: entry.env,
+            url: entry.url
+          }
+        end
+
         def capability_label(counts)
           return '' unless counts
 

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/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-8'
+        'claude-opus-5'
       end
 
       def display_summary

data/lib/rubyn_code/cli/mention_expander.rb

@@ -1,5 +1,7 @@
 # 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,
@@ -35,6 +37,23 @@ module RubynCode
         ["#{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

data/lib/rubyn_code/cli/repl.rb

@@ -97,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
@@ -115,11 +128,12 @@ module RubynCode
         # 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
         render_response(response)
@@ -160,6 +174,22 @@ module RubynCode
         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
 

data/lib/rubyn_code/cli/repl_commands.rb

@@ -27,7 +27,7 @@ module RubynCode
           Commands::Megaplan, Commands::Goal, Commands::Loop,
           Commands::Agents, Commands::Learning, Commands::Rewind,
           Commands::Chisel, Commands::ChiselReview, Commands::ChiselAudit,
-          Commands::ChiselDebt, Commands::ChiselGain
+          Commands::ChiselDebt, Commands::ChiselGain, Commands::Think, Commands::Effort, Commands::Export
         ].each { |cmd| @command_registry.register(cmd) }
         register_custom_commands!
       end

data/lib/rubyn_code/cli/repl_setup.rb

@@ -29,6 +29,7 @@ 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)
@@ -191,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) }
@@ -206,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/config/defaults.rb

@@ -11,7 +11,7 @@ module RubynCode
       MEMORIES_DIR = File.join(HOME_DIR, 'memories')
 
       DEFAULT_PROVIDER = 'anthropic'
-      DEFAULT_MODEL = 'claude-opus-4-8'
+      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
@@ -41,6 +41,7 @@ module RubynCode
       # 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

data/lib/rubyn_code/config/schema.json

@@ -47,6 +47,11 @@
     "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

@@ -19,6 +19,7 @@ module RubynCode
         oauth_token_url oauth_scopes
         skills_autoload
         chisel_mode
+        thinking_budget_tokens
       ].freeze
 
       DEFAULT_MAP = {
@@ -40,7 +41,8 @@ module RubynCode
         oauth_token_url: Defaults::OAUTH_TOKEN_URL,
         oauth_scopes: Defaults::OAUTH_SCOPES,
         skills_autoload: Defaults::SKILLS_AUTOLOAD,
-        chisel_mode: Defaults::CHISEL_MODE
+        chisel_mode: Defaults::CHISEL_MODE,
+        thinking_budget_tokens: Defaults::THINKING_BUDGET_TOKENS
       }.freeze
 
       attr_reader :config_path, :data
@@ -156,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-8' }
+          '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/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)