rubyn-code 0.7.0 → 0.9.0

data/lib/rubyn_code/llm/message_builder.rb

@@ -6,6 +6,14 @@ module RubynCode
       def type = 'text'
     end
 
+    ThinkingBlock = Data.define(:text) do
+      def type = 'thinking'
+    end
+
+    ImageBlock = Data.define(:media_type, :data) do
+      def type = 'image'
+    end
+
     ToolUseBlock = Data.define(:id, :name, :input) do
       def type = 'tool_use'
     end
@@ -24,7 +32,11 @@ module RubynCode
       end
     end
 
-    Response = Data.define(:id, :content, :stop_reason, :usage) do
+    Response = Data.define(:id, :content, :stop_reason, :stop_details, :usage) do
+      def initialize(id:, content:, stop_reason:, usage:, stop_details: nil)
+        super
+      end
+
       def text
         content.select { |b| b.type == 'text' }.map(&:text).join
       end
@@ -36,6 +48,10 @@ module RubynCode
       def tool_use?
         stop_reason == 'tool_use'
       end
+
+      def refusal?
+        stop_reason == 'refusal'
+      end
     end
 
     class MessageBuilder
@@ -102,6 +118,10 @@ module RubynCode
           case block
           when TextBlock
             { type: 'text', text: block.text }
+          when ThinkingBlock
+            { type: 'thinking', text: block.text }
+          when ImageBlock
+            { type: 'image', source: { type: 'base64', media_type: block.media_type, data: block.data } }
           when ToolUseBlock
             { type: 'tool_use', id: block.id, name: block.name, input: block.input }
           when ToolResultBlock

data/lib/rubyn_code/llm/model_router.rb

@@ -13,8 +13,8 @@ module RubynCode
     #       env_key: ANTHROPIC_API_KEY
     #       models:
     #         cheap: claude-haiku-4-5
-    #         mid: claude-sonnet-4-6
-    #         top: claude-opus-4-8
+    #         mid: claude-sonnet-5
+    #         top: claude-opus-5
     #     openai:
     #       env_key: OPENAI_API_KEY
     #       models:
@@ -46,11 +46,11 @@ module RubynCode
           %w[openai gpt-5.4-nano]
         ].freeze,
         mid: [
-          %w[anthropic claude-sonnet-4-6],
+          %w[anthropic claude-sonnet-5],
           %w[openai gpt-5.4-mini]
         ].freeze,
         top: [
-          %w[anthropic claude-opus-4-8],
+          %w[anthropic claude-opus-5],
           %w[openai gpt-5.4]
         ].freeze
       }.freeze

data/lib/rubyn_code/mcp/discovery.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'rubyn_code/mcp/config'
+
+module RubynCode
+  module MCP
+    # Discovers MCP server definitions from a project's `.mcp.json` file
+    # (the Claude Code–style layout at the project root) and merges them
+    # with the user-level `.rubyn-code/mcp.json` definitions parsed by
+    # `MCP::Config`.
+    #
+    # Project-level entries are tagged `source: :project` so /mcp can
+    # distinguish them from user-level entries.
+    module Discovery
+      PROJECT_CONFIG_FILENAME = '.mcp.json'
+
+      Entry = Data.define(:name, :command, :args, :env, :url, :source)
+
+      module_function
+
+      # @param project_root [String, nil] project root (nil => nothing discovered)
+      # @return [Array<Entry>]
+      def discover(project_root)
+        user  = MCP::Config.load(project_root.to_s).map { |cfg| to_entry(cfg, :user) }
+        proj  = load_project(project_root)
+        user + proj
+      end
+
+      # @param project_root [String, nil]
+      # @return [Array<Entry>]
+      def load_project(project_root)
+        return [] if project_root.to_s.empty?
+
+        path = File.join(project_root, PROJECT_CONFIG_FILENAME)
+        return [] unless File.exist?(path)
+
+        data = JSON.parse(File.read(path))
+        Array(data['mcpServers']).filter_map do |name, server_def|
+          build_entry(name, server_def, :project)
+        end
+      rescue JSON::ParserError => e
+        RubynCode::Debug.warn("[MCP::Discovery] Failed to parse #{path}: #{e.message}")
+        []
+      rescue SystemCallError => e
+        RubynCode::Debug.warn("[MCP::Discovery] Could not read #{path}: #{e.message}")
+        []
+      end
+
+      # @return [Array<Entry>] entries that the local runner can start right now
+      def stdio_servers(entries)
+        entries.reject { |e| e.command.to_s.empty? }
+      end
+
+      # @return [Array<Entry>] entries that need a network protocol (deferred)
+      def remote_servers(entries)
+        entries.select { |e| e.command.to_s.empty? && !e.url.to_s.empty? }
+      end
+
+      def to_entry(cfg, source)
+        Entry.new(
+          name: cfg[:name],
+          command: cfg[:command],
+          args: cfg[:args],
+          env: cfg[:env],
+          url: cfg[:url],
+          source: source
+        )
+      end
+
+      def build_entry(name, server_def, source)
+        return nil unless server_def.is_a?(Hash)
+
+        command = server_def['command'].to_s
+        url     = server_def['url'].to_s
+
+        if command.empty? && url.empty?
+          RubynCode::Debug.warn("[MCP::Discovery] Skipping #{name}: no command or url")
+          return nil
+        end
+
+        Entry.new(
+          name: name,
+          command: command,
+          args: Array(server_def['args']),
+          env: server_def['env'].is_a?(Hash) ? server_def['env'].transform_keys(&:to_s) : {},
+          url: url,
+          source: source
+        )
+      end
+    end
+  end
+end

data/lib/rubyn_code/memory/session_persistence.rb

@@ -303,7 +303,7 @@ module RubynCode
           CREATE TABLE IF NOT EXISTS messages (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
             session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
-            role TEXT NOT NULL CHECK(role IN ('system','user','assistant')),
+            role TEXT NOT NULL CHECK(role IN ('system','user','assistant','tool','function')),
             content TEXT,
             tool_calls TEXT,
             tool_use_id TEXT,

data/lib/rubyn_code/observability/cost_calculator.rb

@@ -9,12 +9,15 @@ module RubynCode
     module CostCalculator
       # Per-million-token rates: { model_prefix => [input_rate, output_rate] }
       PRICING = {
-        # Anthropic — Claude 5 / 4.8 / 4.6
+        # Anthropic — Claude 5 / 4.8 / 4.7 / 4.6
         'claude-fable-5' => [10.00, 50.00],
+        'claude-opus-5' => [5.00, 25.00],
         'claude-opus-4-8' => [5.00, 25.00],
-        'claude-haiku-4-5' => [1.00, 5.00],
+        'claude-opus-4-7' => [5.00, 25.00],
+        'claude-opus-4-6' => [5.00, 25.00],
+        'claude-sonnet-5' => [3.00, 15.00],
         'claude-sonnet-4-6' => [3.00, 15.00],
-        'claude-opus-4-6' => [15.00, 75.00],
+        'claude-haiku-4-5' => [1.00, 5.00],
         # OpenAI — GPT-5.4
         'gpt-5.4' => [2.50, 10.00],
         'gpt-5.4-mini' => [0.15, 0.60],

data/lib/rubyn_code/protocols/RUBYN.md

@@ -7,8 +7,5 @@ Safety and coordination protocols for agent lifecycle.
 - **`ShutdownHandshake`** — Graceful shutdown. Waits for the current tool call to complete,
   saves conversation state, and cleans up resources.
 
-- **`PlanApproval`** — When the agent proposes a multi-step plan, this prompts the user
-  for approval before execution. Shows the plan, waits for yes/no/edit.
-
 - **`InterruptHandler`** — Traps SIGINT (Ctrl+C). First interrupt cancels the current
   operation. Second interrupt within 2 seconds triggers shutdown.

data/lib/rubyn_code/tasks/models.rb

@@ -11,22 +11,6 @@ module RubynCode
       def completed? = status == 'completed'
       def blocked? = status == 'blocked'
       def failed? = status == 'failed'
-
-      def to_h
-        {
-          id: id,
-          session_id: session_id,
-          title: title,
-          description: description,
-          status: status,
-          priority: priority,
-          owner: owner,
-          result: result,
-          metadata: metadata,
-          created_at: created_at,
-          updated_at: updated_at
-        }
-      end
     end
   end
 end

data/lib/rubyn_code/teams/teammate.rb

@@ -21,21 +21,6 @@ module RubynCode
 
       # @return [Boolean] true if this teammate was not spawned by another agent
       def root? = parent_agent_id.nil?
-
-      # @return [Hash]
-      def to_h
-        {
-          id: id,
-          name: name,
-          role: role,
-          persona: persona,
-          model: model,
-          status: status,
-          parent_agent_id: parent_agent_id,
-          metadata: metadata,
-          created_at: created_at
-        }
-      end
     end
   end
 end

data/lib/rubyn_code/tools/RUBYN.md

@@ -1,6 +1,6 @@
 # Layer 2: Tools
 
-32 built-in tools that Claude can invoke. The extensibility surface of the system.
+34 built-in tools that Claude can invoke. The extensibility surface of the system.
 
 ## Core Classes
 
@@ -20,13 +20,13 @@
 
 | Category | Tools |
 |----------|-------|
-| File I/O | `read_file`, `write_file`, `edit_file`, `glob`, `grep` |
+| File I/O | `read_file`, `write_file`, `edit_file`, `glob`, `grep`, `code_graph` |
 | Shell | `bash`, `background_run` |
 | Rails | `rails_generate`, `db_migrate`, `run_specs`, `bundle_install`, `bundle_add` |
 | Git | `git_commit`, `git_diff`, `git_log`, `git_status` |
 | Web | `web_search`, `web_fetch` |
 | Memory | `memory_search`, `memory_write` |
-| Agents | `spawn_agent`, `spawn_teammate`, `send_message`, `read_inbox` |
+| Agents | `spawn_agent`, `spawn_teammate`, `send_message`, `read_inbox`, `phone_a_friend` |
 | Meta | `compact`, `load_skill`, `task`, `review_pr` |
 
 ## Adding a Tool

data/lib/rubyn_code/tools/bash.rb

@@ -43,9 +43,9 @@ module RubynCode
         env = ENV.to_h.dup
 
         env.each_key do |key|
-          if Config::Defaults::SCRUB_ENV_VARS.any? { |sensitive| key.upcase.include?(sensitive) }
-            env[key] = '[SCRUBBED]'
-          end
+          # String#[] instead of #include?: Style/ArrayIntersect misfires on
+          # the any?+include? shape even though key is a String.
+          env[key] = '[SCRUBBED]' if Config::Defaults::SCRUB_ENV_VARS.any? { |sensitive| key.upcase[sensitive] }
         end
 
         env

data/lib/rubyn_code/tools/code_graph.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative 'registry'
+
+module RubynCode
+  module Tools
+    # Codegraph-style exploration over the persistent codebase index: one
+    # call answers "where is X and how is it wired?" with the verbatim
+    # line-numbered source of matching symbols plus their callers, callees,
+    # and affected files — replacing a grep + read_file loop.
+    class CodeGraph < Base
+      TOOL_NAME = 'code_graph'
+      DESCRIPTION = 'Explores the codebase knowledge graph. Given symbol names or keywords, returns the ' \
+                    'matching definitions with verbatim line-numbered source, the methods that call them, ' \
+                    'the methods they call, and the affected files (including specs). Prefer this over ' \
+                    'grep/read_file when locating or understanding code — one call replaces a search loop.'
+      PARAMETERS = {
+        query: { type: :string, required: true,
+                 description: 'Symbol names or keywords, e.g. "build_request_body" or "task budget"' },
+        max_symbols: { type: :integer, required: false, default: 5,
+                       description: 'Maximum matching symbols to expand (default 5)' }
+      }.freeze
+      RISK_LEVEL = :read
+      REQUIRES_CONFIRMATION = false
+
+      MAX_SOURCE_LINES = 60
+      MAX_RELATED = 15
+      MATCHABLE_TYPES = %w[class module model controller service concern method].freeze
+
+      def self.summarize(output, args)
+        query = args['query'] || args[:query] || ''
+        count = output.to_s.scan(/^## /).size
+        "code_graph #{query} (#{count} symbols)"
+      end
+
+      def execute(query:, max_symbols: 5)
+        index = Index::CodebaseIndex.new(project_root: project_root)
+        index.load_or_build!
+
+        matches = ranked_matches(index, query, max_symbols)
+        return "No symbols matching '#{query}' in the codebase index." if matches.empty?
+
+        sections = matches.map { |node| render_symbol(index, node) }
+        truncate(sections.join("\n\n"))
+      end
+
+      private
+
+      def ranked_matches(index, query, limit)
+        terms = query.to_s.downcase.split(/\W+/).reject(&:empty?)
+        return [] if terms.empty?
+
+        scored = index.nodes.filter_map do |node|
+          next unless MATCHABLE_TYPES.include?(node['type'])
+
+          score = score_node(node, terms)
+          [score, node] if score.positive?
+        end
+
+        scored.sort_by { |score, node| [-score, node['file'].to_s] }
+              .map(&:last)
+              .uniq { |n| [n['name'], n['file'], n['line']] }
+              .first(limit)
+      end
+
+      def score_node(node, terms)
+        name = node['name'].to_s.downcase
+        file = node['file'].to_s.downcase
+        score = terms.sum do |term|
+          if name == term then 100
+          elsif name.include?(term) then 40
+          elsif file.include?(term) then 10
+          else 0
+          end
+        end
+        # A name hitting every query term beats a single exact-term match.
+        score += 50 if terms.size > 1 && terms.all? { |t| name.include?(t) }
+        score
+      end
+
+      def render_symbol(index, node)
+        header = [node['owner'], node['name']].reject { |p| p.nil? || p.empty? }.join('#')
+        lines = ["## #{header} (#{node['file']}:#{node['line']})"]
+        lines << source_slice(node)
+        append_call_info(lines, index, node) if node['type'] == 'method'
+        append_affected_files(lines, index, node)
+        lines.join("\n")
+      end
+
+      def source_slice(node)
+        path = File.join(project_root, node['file'].to_s)
+        return '(source unavailable)' unless File.file?(path)
+
+        start = [node['line'].to_i, 1].max
+        finish = (node['end_line'] || (start + MAX_SOURCE_LINES)).to_i
+        truncated = finish > start + MAX_SOURCE_LINES
+        finish = start + MAX_SOURCE_LINES if truncated
+
+        slice = File.readlines(path)[(start - 1)..(finish - 1)] || []
+        rendered = slice.each_with_index.map { |line, i| "#{(start + i).to_s.rjust(5)}| #{line.rstrip}" }
+        rendered << "  ...| (truncated at #{MAX_SOURCE_LINES} lines)" if truncated
+        rendered.join("\n")
+      end
+
+      def append_call_info(lines, index, node)
+        callers = call_edges(index).select { |e| e['to'] == node['name'] }
+        callees = call_edges(index).select { |e| e['from'] == node['file'] && e['from_method'] == node['name'] }
+
+        unless callers.empty?
+          described = callers.first(MAX_RELATED).map { |e| "#{e['from_method']} (#{e['from']}:#{e['line']})" }
+          lines << "Called by: #{described.uniq.join(', ')}"
+        end
+        return if callees.empty?
+
+        lines << "Calls: #{callees.map { |e| e['to'] }.uniq.first(MAX_RELATED).join(', ')}"
+      end
+
+      def append_affected_files(lines, index, node)
+        caller_files = call_edges(index).select { |e| e['to'] == node['name'] }.map { |e| e['from'] }
+        spec_edges = index.edges.select { |e| e['relationship'] == 'tests' && e['to'] == node['file'] }
+        spec_files = spec_edges.map { |e| e['from'] }
+        affected = (caller_files + spec_files).uniq - [node['file']]
+        lines << "Affected files: #{affected.first(MAX_RELATED).join(', ')}" unless affected.empty?
+      end
+
+      def call_edges(index)
+        @call_edges ||= index.edges.select { |e| e['relationship'] == 'calls' }
+      end
+    end
+
+    Registry.register(CodeGraph)
+  end
+end

data/lib/rubyn_code/tools/executor.rb

@@ -5,7 +5,7 @@ module RubynCode
     class Executor
       attr_reader :project_root, :output_compressor, :file_cache
       attr_accessor :llm_client, :background_worker, :on_agent_status, :db, :ask_user_callback,
-                    :codebase_index, :ide_client
+                    :codebase_index, :ide_client, :todo_store
 
       def initialize(project_root:, ide_client: nil)
         @project_root = File.expand_path(project_root)
@@ -64,6 +64,9 @@ module RubynCode
         else
           tool = tool_class.new(project_root: project_root)
         end
+        if @todo_store && tool_class.instance_method(:initialize).parameters.any? { |_, name| name == :store }
+          tool.instance_variable_set(:@store, @todo_store)
+        end
         inject_dependencies(tool, tool_name)
         tool
       end
@@ -82,6 +85,8 @@ module RubynCode
         when 'spawn_agent', 'spawn_teammate'
           inject_agent_deps(tool)
           tool.db = @db if tool_name == 'spawn_teammate' && tool.respond_to?(:db=)
+        when 'phone_a_friend'
+          tool.llm_client = @llm_client if tool.respond_to?(:llm_client=)
         when 'background_run'
           tool.background_worker = @background_worker if tool.respond_to?(:background_worker=)
         when 'ask_user'

data/lib/rubyn_code/tools/phone_a_friend.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative 'registry'
+
+module RubynCode
+  module Tools
+    # Ask a different model for a second opinion. The "friend" is chosen to
+    # maximize perspective diversity: prefer the top-tier model of another
+    # configured provider (a genuinely different model family), and fall back
+    # to the active provider's top-tier model when no other provider has an
+    # API key available. One-shot, no tools, returns plain text.
+    class PhoneAFriend < Base
+      TOOL_NAME = 'phone_a_friend'
+      DESCRIPTION = 'Ask a different model for a second opinion when you are stuck, ' \
+                    'weighing two approaches, or want your reasoning sanity-checked. ' \
+                    'Sends one question (plus optional context) to another model — ' \
+                    'a different provider when one is configured, otherwise the ' \
+                    'top-tier model of the current provider — and returns its answer. ' \
+                    'The friend has no tools and sees nothing except what you send.'
+      PARAMETERS = {
+        question: {
+          type: :string,
+          required: true,
+          description: 'The question to ask. Be specific about what kind of answer you ' \
+                       'need (a decision, a review of reasoning, an alternative approach).'
+        },
+        context: {
+          type: :string,
+          required: false,
+          description: 'Relevant code, error output, or background. The friend sees ' \
+                       'only this — include everything needed to answer well.'
+        }
+      }.freeze
+      RISK_LEVEL = :external
+
+      SYSTEM_PROMPT = <<~PROMPT
+        You are giving a second opinion to another AI coding agent that is working
+        inside a project and has hit a question it wants an outside perspective on.
+        You cannot see the project — only what the agent sent you. Answer directly
+        and concretely: commit to a recommendation, explain the key reason, and
+        flag anything important the agent may have missed. If the provided context
+        is insufficient to answer well, say exactly what is missing.
+      PROMPT
+
+      # Injected by the Executor (active client) and overridable in tests.
+      attr_writer :llm_client, :client_factory
+
+      def execute(question:, context: nil)
+        return 'phone_a_friend: no LLM client available.' unless @llm_client
+
+        provider, model = pick_friend
+        response = call_friend(provider, model, build_message(question, context))
+        answer = extract_text(response)
+        return "phone_a_friend: #{provider}/#{model} returned no text." if answer.empty?
+
+        "## Second Opinion — #{provider}/#{model}\n\n#{answer}"
+      rescue StandardError => e
+        friend = provider ? "#{provider}/#{model}" : 'friend'
+        "phone_a_friend: call to #{friend} failed: #{e.message}"
+      end
+
+      def self.summarize(_output, _args)
+        'asked another model for a second opinion'
+      end
+
+      private
+
+      # Returns [provider, model]. Prefers another provider whose API key is
+      # present; otherwise escalates to the active provider's top tier.
+      def pick_friend
+        active = @llm_client.provider_name
+        other = (known_providers - [active]).find { |p| key_present?(p) }
+        provider = other || active
+        [provider, top_model_for(provider)]
+      end
+
+      def call_friend(provider, model, message)
+        client = provider == @llm_client.provider_name ? @llm_client : friend_client(provider, model)
+        client.chat(
+          messages: [{ role: 'user', content: message }],
+          tools: nil,
+          system: SYSTEM_PROMPT,
+          model: model
+        )
+      end
+
+      def friend_client(provider, model)
+        factory = @client_factory || ->(prov, mod) { LLM::Client.new(provider: prov, model: mod) }
+        factory.call(provider, model)
+      end
+
+      def build_message(question, context)
+        return question if context.to_s.empty?
+
+        "#{question}\n\n## Context\n\n#{context}"
+      end
+
+      def known_providers
+        configured = settings.to_h['providers']
+        names = configured.is_a?(Hash) ? configured.keys : []
+        (names + Config::Settings::DEFAULT_PROVIDER_MODELS.keys).uniq
+      end
+
+      def key_present?(provider)
+        env_key = provider_setting(provider, 'env_key')
+        env_key ? !ENV[env_key].to_s.empty? : false
+      end
+
+      def top_model_for(provider)
+        config_models = provider_setting(provider, 'models')
+        model = config_models['top'] || config_models.values.last if config_models.is_a?(Hash)
+        model || @llm_client.model
+      end
+
+      # Reads a provider key from config.yml, falling back to the built-in
+      # provider defaults for anthropic/openai.
+      def provider_setting(provider, key)
+        value = settings.provider_config(provider)&.fetch(key, nil)
+        value || Config::Settings::DEFAULT_PROVIDER_MODELS.dig(provider, key)
+      end
+
+      def settings
+        @settings ||= Config::Settings.new
+      end
+
+      def extract_text(response)
+        content = response.respond_to?(:content) ? Array(response.content) : []
+        content.select { |b| b.respond_to?(:type) && b.type == 'text' }.map(&:text).join("\n")
+      end
+    end
+
+    Registry.register(PhoneAFriend)
+  end
+end

data/lib/rubyn_code/tools/todo_store.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Tools
+    # Shared, thread-safe checklist store. The Agent::Loop owns one instance and
+    # exposes it to (a) the renderer so the user sees what's in flight, and
+    # (b) the TodoWrite tool so the model can mutate it.
+    class TodoStore
+      include MonitorMixin
+
+      Item = Data.define(:content, :status, :active_form)
+
+      def initialize
+        super
+        @items = []
+      end
+
+      def replace(items)
+        synchronize do
+          @items = items.map do |item|
+            Item.new(
+              content: item['content'] || item[:content],
+              status: item['status'] || item[:status],
+              active_form: (item['active_form'] || item[:active_form]).to_s
+            )
+          end
+        end
+      end
+
+      def current
+        synchronize { @items.map(&:to_h) }
+      end
+
+      def clear
+        synchronize { @items = [] }
+      end
+
+      def empty?
+        current.empty?
+      end
+
+      def render
+        current.map do |item|
+          mark =
+            case item[:status]
+            when 'completed' then '☑'
+            when 'in_progress' then '[~]'
+            else '[ ]'
+            end
+          "#{mark} #{item[:content]}"
+        end.join("\n")
+      end
+    end
+  end
+end