rubyn-code 0.7.0 → 0.8.0

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.
+33 built-in tools that Claude can invoke. The extensibility surface of the system.
 
 ## Core Classes
 
@@ -20,7 +20,7 @@
 
 | 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` |

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

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

data/lib/rubyn_code/tools/todo_write.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative 'registry'
+
+module RubynCode
+  module Tools
+    # Update the in-turn task checklist. The model uses this to keep the user
+    # informed of progress while it works. The store is shared between the
+    # Agent::Loop (which exposes it for the renderer) and this tool.
+    class TodoWrite < Base
+      TOOL_NAME = 'TodoWrite'
+      DESCRIPTION = 'Update the in-turn task checklist. ' \
+                    'Use this to keep the user informed of what you plan to do, ' \
+                    'what you are currently working on, and what you have finished.'
+      PARAMETERS = {
+        todos: { type: :array, required: true,
+                 description: 'The full set of tasks currently on the checklist. ' \
+                              'Replace the existing list with this. Each task is ' \
+                              '{ "content": "...", "status": "pending|in_progress|completed", ' \
+                              '"active_form": "..." }.' }
+      }.freeze
+      RISK_LEVEL = :read
+      REQUIRES_CONFIRMATION = false
+
+      VALID_STATUS = %w[pending in_progress completed].freeze
+
+      def initialize(project_root:, store: nil)
+        super(project_root: project_root)
+        @store = store
+      end
+
+      def execute(todos:)
+        items = Array(todos)
+        validated = []
+
+        items.each_with_index do |item, i|
+          return "TodoWrite: item #{i} is not a hash — got #{item.class}" unless item.is_a?(Hash)
+
+          content = item[:content] || item['content']
+          status  = (item[:status] || item['status']).to_s
+          active_form = item[:active_form] || item['active_form']
+
+          return "TodoWrite: item #{i} missing 'content'" if content.to_s.empty?
+          unless VALID_STATUS.include?(status)
+            return "TodoWrite: item #{i} status must be one of #{VALID_STATUS.join('/')} (got #{status.inspect})"
+          end
+
+          validated << {
+            'content' => content.to_s,
+            'status' => status,
+            'active_form' => active_form.to_s.empty? ? content.to_s : active_form.to_s
+          }
+        end
+
+        @store&.replace(validated)
+        format(validated)
+      end
+
+      def self.summarize(_output, args)
+        count = Array(args[:todos] || args['todos']).size
+        if count.zero?
+          'cleared checklist'
+        else
+          "checklist: #{count} item#{'s' unless count == 1}"
+        end
+      end
+
+      private
+
+      def format(items)
+        return 'Checklist cleared.' if items.empty?
+
+        items.map do |item|
+          mark =
+            case item['status']
+            when 'completed' then '[x]'
+            when 'in_progress' then '[~]'
+            else '[ ]'
+            end
+          "#{mark} #{item['content']}"
+        end.join("\n")
+      end
+    end
+
+    Registry.register(TodoWrite)
+  end
+end

data/lib/rubyn_code/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubynCode
-  VERSION = '0.7.0'
+  VERSION = '0.8.0'
 end

data/lib/rubyn_code.rb

@@ -47,6 +47,11 @@ module RubynCode
   module LLM
     autoload :Client, 'rubyn_code/llm/client'
     autoload :MessageBuilder, 'rubyn_code/llm/message_builder'
+    autoload :TextBlock,     'rubyn_code/llm/message_builder'
+    autoload :ThinkingBlock, 'rubyn_code/llm/message_builder'
+    autoload :ImageBlock,    'rubyn_code/llm/message_builder'
+    autoload :ToolUseBlock,  'rubyn_code/llm/message_builder'
+    autoload :ImageReader, 'rubyn_code/llm/image_reader'
     autoload :ModelRouter, 'rubyn_code/llm/model_router'
 
     # Adapters (provider-specific implementations)
@@ -54,7 +59,6 @@ module RubynCode
       autoload :Base, 'rubyn_code/llm/adapters/base'
       autoload :JsonParsing, 'rubyn_code/llm/adapters/json_parsing'
       autoload :PromptCaching, 'rubyn_code/llm/adapters/prompt_caching'
-      autoload :TokenCaching, 'rubyn_code/llm/adapters/token_caching'
       autoload :Anthropic, 'rubyn_code/llm/adapters/anthropic'
       autoload :AnthropicCompatible, 'rubyn_code/llm/adapters/anthropic_compatible'
       autoload :AnthropicStreaming, 'rubyn_code/llm/adapters/anthropic_streaming'
@@ -63,9 +67,6 @@ module RubynCode
       autoload :OpenAICompatible, 'rubyn_code/llm/adapters/openai_compatible'
       autoload :OpenAIMessageTranslator, 'rubyn_code/llm/adapters/openai_message_translator'
     end
-
-    # Backward-compat: LLM::Streaming → Adapters::AnthropicStreaming
-    autoload :Streaming, 'rubyn_code/llm/streaming'
   end
 
   # Layer 1: Agent Loop
@@ -81,6 +82,7 @@ module RubynCode
   module Tools
     autoload :Base, 'rubyn_code/tools/base'
     autoload :Registry, 'rubyn_code/tools/registry'
+    autoload :TodoStore, 'rubyn_code/tools/todo_store'
     autoload :Schema, 'rubyn_code/tools/schema'
     autoload :Executor, 'rubyn_code/tools/executor'
     autoload :ReadFile, 'rubyn_code/tools/read_file'
@@ -88,6 +90,7 @@ module RubynCode
     autoload :EditFile, 'rubyn_code/tools/edit_file'
     autoload :Glob, 'rubyn_code/tools/glob'
     autoload :Grep, 'rubyn_code/tools/grep'
+    autoload :CodeGraph, 'rubyn_code/tools/code_graph'
     autoload :Bash, 'rubyn_code/tools/bash'
     autoload :RailsGenerate, 'rubyn_code/tools/rails_generate'
     autoload :DbMigrate, 'rubyn_code/tools/db_migrate'
@@ -95,6 +98,7 @@ module RubynCode
     autoload :BundleInstall, 'rubyn_code/tools/bundle_install'
     autoload :BundleAdd, 'rubyn_code/tools/bundle_add'
     autoload :Compact, 'rubyn_code/tools/compact'
+    autoload :TodoWrite, 'rubyn_code/tools/todo_write'
     autoload :LoadSkill, 'rubyn_code/tools/load_skill'
     autoload :Task, 'rubyn_code/tools/task'
     autoload :MemorySearch, 'rubyn_code/tools/memory_search'
@@ -133,8 +137,6 @@ module RubynCode
     autoload :AutoCompact, 'rubyn_code/context/auto_compact'
     autoload :ManualCompact, 'rubyn_code/context/manual_compact'
     autoload :ContextCollapse, 'rubyn_code/context/context_collapse'
-    autoload :ContextBudget, 'rubyn_code/context/context_budget'
-    autoload :SchemaFilter, 'rubyn_code/context/schema_filter'
     autoload :DecisionCompactor, 'rubyn_code/context/decision_compactor'
   end
 
@@ -201,7 +203,6 @@ module RubynCode
   # Layer 10: Protocols
   module Protocols
     autoload :ShutdownHandshake, 'rubyn_code/protocols/shutdown_handshake'
-    autoload :PlanApproval, 'rubyn_code/protocols/plan_approval'
     autoload :InterruptHandler, 'rubyn_code/protocols/interrupt_handler'
   end
 
@@ -258,6 +259,7 @@ module RubynCode
     autoload :ToolBridge, 'rubyn_code/mcp/tool_bridge'
     autoload :ServerExtrasBridge, 'rubyn_code/mcp/server_extras_bridge'
     autoload :Config, 'rubyn_code/mcp/config'
+    autoload :Discovery, 'rubyn_code/mcp/discovery'
   end
 
   # Layer 16: Learning
@@ -266,7 +268,6 @@ module RubynCode
     autoload :Instinct, 'rubyn_code/learning/instinct'
     autoload :InstinctMethods, 'rubyn_code/learning/instinct'
     autoload :Injector, 'rubyn_code/learning/injector'
-    autoload :Shortcut, 'rubyn_code/learning/shortcut'
     autoload :Porter, 'rubyn_code/learning/porter'
   end
 
@@ -286,6 +287,7 @@ module RubynCode
   # Codebase Index
   module Index
     autoload :CodebaseIndex, 'rubyn_code/index/codebase_index'
+    autoload :PrismExtractor, 'rubyn_code/index/prism_extractor'
   end
 
   # CLI
@@ -347,6 +349,9 @@ module RubynCode
       autoload :ChiselAudit, 'rubyn_code/cli/commands/chisel_audit'
       autoload :ChiselDebt, 'rubyn_code/cli/commands/chisel_debt'
       autoload :ChiselGain, 'rubyn_code/cli/commands/chisel_gain'
+      autoload :Think, 'rubyn_code/cli/commands/think'
+      autoload :Effort, 'rubyn_code/cli/commands/effort'
+      autoload :Export, 'rubyn_code/cli/commands/export'
     end
   end