rubyn-code 0.7.0 → 0.8.0

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)
 

data/lib/rubyn_code/index/codebase_index.rb

@@ -14,6 +14,9 @@ module RubynCode
       INDEX_DIR = '.rubyn-code'
       INDEX_FILE = 'codebase_index.json'
       CHARS_PER_TOKEN = 4
+      # Bump when the stored shape changes so stale indexes rebuild instead
+      # of silently serving degraded data. 2 = Prism spans + call edges.
+      FORMAT_VERSION = 2
 
       attr_reader :nodes, :edges, :index_path
 
@@ -33,6 +36,7 @@ module RubynCode
 
         ruby_files.each { |file| index_file(file) }
         extract_rails_edges
+        prune_call_edges!
         save!
         self
       end
@@ -42,6 +46,8 @@ module RubynCode
         return nil unless File.exist?(@index_path)
 
         data = JSON.parse(File.read(@index_path))
+        return nil unless data['format_version'] == FORMAT_VERSION
+
         @nodes = data['nodes'] || []
         # uniq drops duplicate edges accumulated by older versions, which
         # appended tests edges on every update! without dedup.
@@ -68,6 +74,7 @@ module RubynCode
         end
 
         extract_rails_edges
+        prune_call_edges!
         save!
         self
       end
@@ -81,6 +88,7 @@ module RubynCode
         remove_nodes_for(absolute)
         index_file(absolute) if File.exist?(absolute)
         extract_rails_edges
+        prune_call_edges!
         save!
         self
       end
@@ -237,14 +245,66 @@ module RubynCode
         content = File.read(file)
         @file_mtimes[relative] = File.mtime(file).to_i
 
-        extract_classes(content, relative)
-        extract_methods(content, relative)
+        extract_symbols(content, relative)
         extract_associations(content, relative)
         extract_rails_patterns(content, relative)
       rescue StandardError => e
         RubynCode::Debug.warn("Index: failed to parse #{file}: #{e.message}")
       end
 
+      # Prism gives real line spans (needed for verbatim source in code_graph)
+      # and call edges. Files that don't parse fall back to the regex pass,
+      # which produces the same node shapes minus end_line/owner/calls.
+      def extract_symbols(content, file)
+        extracted = PrismExtractor.extract(content)
+        unless extracted
+          extract_classes(content, file)
+          extract_methods(content, file)
+          return
+        end
+
+        add_class_nodes(extracted.classes, file)
+        add_method_nodes(extracted.defs, file)
+        add_call_edges(extracted.calls, file)
+      end
+
+      def add_class_nodes(classes, file)
+        classes.each do |c|
+          @nodes << {
+            'type' => classify_node(file, c[:kind]), 'name' => c[:name],
+            'file' => file, 'line' => c[:line], 'end_line' => c[:end_line]
+          }
+        end
+      end
+
+      def add_method_nodes(methods, file)
+        methods.each do |m|
+          @nodes << {
+            'type' => 'method', 'name' => m[:name], 'file' => file,
+            'line' => m[:line], 'end_line' => m[:end_line],
+            'owner' => m[:owner], 'params' => m[:params], 'visibility' => 'public'
+          }
+        end
+      end
+
+      # `from` stays the file path so remove_nodes_for's from-based cleanup
+      # applies to call edges too; the calling method rides in from_method.
+      def add_call_edges(calls, file)
+        calls.each do |c|
+          @edges << {
+            'from' => file, 'from_method' => c[:from], 'to' => c[:to],
+            'relationship' => 'calls', 'line' => c[:line]
+          }
+        end
+      end
+
+      # Drop call edges whose target isn't defined in the project — filters
+      # out stdlib/gem calls (puts, map, ...) that would swamp the graph.
+      def prune_call_edges!
+        defined_methods = @nodes.filter_map { |n| n['name'] if n['type'] == 'method' }.to_set
+        @edges.reject! { |e| e['relationship'] == 'calls' && !defined_methods.include?(e['to']) }
+      end
+
       def extract_classes(content, file)
         content.scan(/^\s*(class|module)\s+(\S+)/).each do |type, name|
           node_type = classify_node(file, type)
@@ -342,7 +402,8 @@ module RubynCode
 
       def save!
         FileUtils.mkdir_p(File.dirname(@index_path))
-        data = { 'nodes' => @nodes, 'edges' => @edges, 'file_mtimes' => @file_mtimes }
+        data = { 'format_version' => FORMAT_VERSION, 'nodes' => @nodes, 'edges' => @edges,
+                 'file_mtimes' => @file_mtimes }
         File.write(@index_path, JSON.generate(data))
       end
     end