rubyn-code 0.7.0 → 0.8.0

data/skills/rubyn_self_test.md

@@ -449,6 +449,146 @@ fast and need no API calls.
   '
   ```
 
+#### 17k. Extended thinking + `/think` toggle (PRs #132, #138)
+- **bash**: confirms `LLM::ThinkingBlock` is defined, the Anthropic adapter
+  translates `thinking: {budget_tokens}` into the request body, and `/think`
+  toggles state on `LLM::Client`. PASS if the final line is `THINKING: PASS`.
+
+  ```bash
+  bundle exec ruby -Ilib -rrubyn_code -rrubyn_code/llm/message_builder -e '
+    tb = RubynCode::LLM::ThinkingBlock.new(text: "plan")
+    adapter = RubynCode::LLM::Adapters::Anthropic.allocate
+    body = {}
+    adapter.send(:apply_thinking, body, budget_tokens: 4096)
+    client = RubynCode::LLM::Client.allocate
+    client.thinking_budget_tokens = 4096
+    ok = (tb.type == "thinking") &&
+         (body[:thinking] == { type: "enabled", budget_tokens: 4096 }) &&
+         (client.thinking_budget_tokens == 4096)
+    puts(ok ? "THINKING: PASS" : "THINKING: FAIL")
+  '
+  ```
+
+#### 17l. Image / vision input (`@image.png`) (PRs #133, #140, #141)
+- **bash**: confirms `LLM::ImageBlock`, `LLM::ImageReader`, and
+  `MentionExpander#expand_images` are wired and base64-encode PNGs.
+  PASS if the final line is `IMAGES: PASS`.
+
+  ```bash
+  bundle exec ruby -Ilib -rrubyn_code -rrubyn_code/llm/message_builder -e '
+    require "tmpdir"
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "p.png")
+      File.binwrite(path, "\x89PNG\r\n\x1a\n".dup)
+      block = RubynCode::LLM::ImageReader.for_path(path)
+      ex = RubynCode::CLI::MentionExpander.new(project_root: dir).expand_images("look @p.png")
+      ok = (block.is_a?(RubynCode::LLM::ImageBlock)) &&
+           (block.media_type == "image/png") &&
+           (ex.size == 1)
+      puts(ok ? "IMAGES: PASS" : "IMAGES: FAIL")
+    end
+  '
+  ```
+
+#### 17m. TodoWrite live checklist (PR #134)
+- **bash**: confirms `Tools::TodoWrite` is registered and mutates a shared
+  `Tools::TodoStore`. PASS if the final line is `TODOWRITE: PASS`.
+
+  ```bash
+  bundle exec ruby -Ilib -rrubyn_code -rrubyn_code/tools/todo_write -rrubyn_code/tools/todo_store -e '
+    store = RubynCode::Tools::TodoStore.new
+    tool  = RubynCode::Tools::TodoWrite.new(project_root: Dir.pwd, store: store)
+    out   = tool.execute(todos: [{ "content" => "a", "status" => "in_progress", "active_form" => "A" }])
+    ok = (out.include?("[~] a")) && (store.current.first[:status] == "in_progress") &&
+         (RubynCode::Tools::Registry.get("TodoWrite") == RubynCode::Tools::TodoWrite)
+    puts(ok ? "TODOWRITE: PASS" : "TODOWRITE: FAIL")
+  '
+  ```
+
+#### 17n. Custom-command frontmatter (argument-hint, allowed-tools, model:) (PRs #135, #138)
+- **bash**: confirms `CustomCommand` exposes all three frontmatter keys and
+  `Agent::Loop` honors the per-prompt override setters.
+  PASS if the final line is `FRONTMATTER: PASS`.
+
+  ```bash
+  bundle exec ruby -Ilib -rrubyn_code -rrubyn_code/agent/loop -e '
+    loop = RubynCode::Agent::Loop.allocate
+    loop.allowed_tools_override = %w[bash read]
+    loop.model_override = "claude-opus-4-8"
+    at = loop.instance_variable_get(:@allowed_tools_override)
+    mo = loop.instance_variable_get(:@model_override)
+    cmd = RubynCode::CLI::Commands::CustomCommand.new(
+      name: "d", description: "d", body: "b",
+      argument_hint: "[env]", allowed_tools: %w[bash read], model: "claude-opus-4-8"
+    )
+    ok = (at == %w[bash read]) && (mo == "claude-opus-4-8") &&
+         (cmd.argument_hint == "[env]") && (cmd.allowed_tools == %w[bash read]) &&
+         (cmd.model == "claude-opus-4-8")
+    puts(ok ? "FRONTMATTER: PASS" : "FRONTMATTER: FAIL")
+  '
+  ```
+
+#### 17o. `.mcp.json` auto-discovery (PRs #136, #138, #139)
+- **bash**: writes a project-root `.mcp.json`, calls `MCP::Discovery.discover`,
+  and asserts the entry is tagged `:project`.
+  PASS if the final line is `MCP-DISCOVERY: PASS`.
+
+  ```bash
+  bundle exec ruby -Ilib -rrubyn_code -rrubyn_code/mcp/discovery -e '
+    require "tmpdir"; require "json"
+    Dir.mktmpdir do |dir|
+      File.write(File.join(dir, ".mcp.json"),
+                 JSON.generate(mcpServers: { "p" => { command: "p" } }))
+      entries = RubynCode::MCP::Discovery.discover(dir)
+      ok = (entries.any? { |e| e.name == "p" && e.source == :project })
+      puts(ok ? "MCP-DISCOVERY: PASS" : "MCP-DISCOVERY: FAIL")
+    end
+  '
+  ```
+
+#### 17p. `/export` transcript (markdown / jsonl) (PR #137)
+- **bash**: drives `Commands::Export` against a synthetic conversation with
+  a `thinking` block and a `tool_use`. Writes a markdown file and asserts
+  the file contains role sections, the thinking `<details>`, and the
+  fenced-JSON tool_use. PASS if the final line is `EXPORT: PASS`.
+
+  ```bash
+  bundle exec ruby -Ilib -rrubyn_code -rrubyn_code/cli/commands/export -e '
+    require "tmpdir"
+    Dir.mktmpdir do |dir|
+      msgs = [
+        { role: "user", content: "hi" },
+        { role: "assistant", content: [
+          { type: "thinking", text: "plan" },
+          { type: "text",     text: "ok" },
+          { type: "tool_use", name: "bash", input: { cmd: "ls" } }
+        ] }
+      ]
+      conv = Object.new
+      conv.define_singleton_method(:to_a) { msgs }
+      renderer = Object.new
+      renderer.define_singleton_method(:info)    { |*_| nil }
+      renderer.define_singleton_method(:warning) { |*_| nil }
+      renderer.define_singleton_method(:ask)     { |*_| true }
+      ctx = RubynCode::CLI::Commands::Context.new(
+        renderer: renderer, conversation: conv, agent_loop: nil,
+        context_manager: nil, budget_enforcer: nil, llm_client: nil,
+        db: nil, session_id: nil, project_root: nil, skill_loader: nil,
+        session_persistence: nil, background_worker: nil, permission_tier: nil,
+        plan_mode: false, message_handler: nil, hook_registry: nil,
+        checkpoint_manager: nil
+      )
+      path = File.join(dir, "x.md")
+      RubynCode::CLI::Commands::Export.new.execute([path], ctx)
+      body = File.read(path)
+      ok = body.include?("## User") &&
+           body.include?("<details><summary>thinking</summary>") &&
+           body.include?("[tool: bash]")
+      puts(ok ? "EXPORT: PASS" : "EXPORT: FAIL")
+    end
+  '
+  ```
+
 ### 18. Chisel — Minimal-Code Enforcement (opt-in)
 
 Chisel is rubyn-code's "write the minimum that works" layer. It is **off by

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubyn-code
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - fadedmaturity
@@ -240,6 +240,8 @@ files:
 - lib/rubyn_code/cli/commands/custom_loader.rb
 - lib/rubyn_code/cli/commands/diff.rb
 - lib/rubyn_code/cli/commands/doctor.rb
+- lib/rubyn_code/cli/commands/effort.rb
+- lib/rubyn_code/cli/commands/export.rb
 - lib/rubyn_code/cli/commands/goal.rb
 - lib/rubyn_code/cli/commands/help.rb
 - lib/rubyn_code/cli/commands/install_skills.rb
@@ -262,6 +264,7 @@ files:
 - lib/rubyn_code/cli/commands/skills.rb
 - lib/rubyn_code/cli/commands/spawn.rb
 - lib/rubyn_code/cli/commands/tasks.rb
+- lib/rubyn_code/cli/commands/think.rb
 - lib/rubyn_code/cli/commands/tokens.rb
 - lib/rubyn_code/cli/commands/undo.rb
 - lib/rubyn_code/cli/commands/version.rb
@@ -289,13 +292,11 @@ files:
 - lib/rubyn_code/context/RUBYN.md
 - lib/rubyn_code/context/auto_compact.rb
 - lib/rubyn_code/context/compactor.rb
-- lib/rubyn_code/context/context_budget.rb
 - lib/rubyn_code/context/context_collapse.rb
 - lib/rubyn_code/context/decision_compactor.rb
 - lib/rubyn_code/context/manager.rb
 - lib/rubyn_code/context/manual_compact.rb
 - lib/rubyn_code/context/micro_compact.rb
-- lib/rubyn_code/context/schema_filter.rb
 - lib/rubyn_code/db/RUBYN.md
 - lib/rubyn_code/db/connection.rb
 - lib/rubyn_code/db/migrator.rb
@@ -338,12 +339,12 @@ files:
 - lib/rubyn_code/ide/protocol.rb
 - lib/rubyn_code/ide/server.rb
 - lib/rubyn_code/index/codebase_index.rb
+- lib/rubyn_code/index/prism_extractor.rb
 - lib/rubyn_code/learning/RUBYN.md
 - lib/rubyn_code/learning/extractor.rb
 - lib/rubyn_code/learning/injector.rb
 - lib/rubyn_code/learning/instinct.rb
 - lib/rubyn_code/learning/porter.rb
-- lib/rubyn_code/learning/shortcut.rb
 - lib/rubyn_code/llm/RUBYN.md
 - lib/rubyn_code/llm/adapters/anthropic.rb
 - lib/rubyn_code/llm/adapters/anthropic_compatible.rb
@@ -355,14 +356,14 @@ files:
 - lib/rubyn_code/llm/adapters/openai_message_translator.rb
 - lib/rubyn_code/llm/adapters/openai_streaming.rb
 - lib/rubyn_code/llm/adapters/prompt_caching.rb
-- lib/rubyn_code/llm/adapters/token_caching.rb
 - lib/rubyn_code/llm/client.rb
+- lib/rubyn_code/llm/image_reader.rb
 - lib/rubyn_code/llm/message_builder.rb
 - lib/rubyn_code/llm/model_router.rb
-- lib/rubyn_code/llm/streaming.rb
 - lib/rubyn_code/mcp/RUBYN.md
 - lib/rubyn_code/mcp/client.rb
 - lib/rubyn_code/mcp/config.rb
+- lib/rubyn_code/mcp/discovery.rb
 - lib/rubyn_code/mcp/server_extras_bridge.rb
 - lib/rubyn_code/mcp/sse_transport.rb
 - lib/rubyn_code/mcp/stdio_transport.rb
@@ -393,7 +394,6 @@ files:
 - lib/rubyn_code/permissions/tier.rb
 - lib/rubyn_code/protocols/RUBYN.md
 - lib/rubyn_code/protocols/interrupt_handler.rb
-- lib/rubyn_code/protocols/plan_approval.rb
 - lib/rubyn_code/protocols/shutdown_handshake.rb
 - lib/rubyn_code/self_test.rb
 - lib/rubyn_code/skills/RUBYN.md
@@ -430,6 +430,7 @@ files:
 - lib/rubyn_code/tools/bash.rb
 - lib/rubyn_code/tools/bundle_add.rb
 - lib/rubyn_code/tools/bundle_install.rb
+- lib/rubyn_code/tools/code_graph.rb
 - lib/rubyn_code/tools/compact.rb
 - lib/rubyn_code/tools/db_migrate.rb
 - lib/rubyn_code/tools/edit_file.rb
@@ -459,6 +460,8 @@ files:
 - lib/rubyn_code/tools/spawn_teammate.rb
 - lib/rubyn_code/tools/spec_output_parser.rb
 - lib/rubyn_code/tools/task.rb
+- lib/rubyn_code/tools/todo_store.rb
+- lib/rubyn_code/tools/todo_write.rb
 - lib/rubyn_code/tools/web_fetch.rb
 - lib/rubyn_code/tools/web_search.rb
 - lib/rubyn_code/tools/write_file.rb

data/lib/rubyn_code/context/context_budget.rb

@@ -1,183 +0,0 @@
-# frozen_string_literal: true
-
-module RubynCode
-  module Context
-    # Budget-aware context loader that prioritizes which related files
-    # to load fully vs. as signatures-only. Prevents context bloat by
-    # capping auto-loaded context at a configurable token budget.
-    class ContextBudget
-      CHARS_PER_TOKEN = 4
-      DEFAULT_BUDGET = 4000 # tokens
-
-      # Rails convention-based priority for related files.
-      # Lower number = higher priority = loaded first.
-      PRIORITY_MAP = {
-        'spec' => 1, # tests for the file
-        'factory' => 2,  # FactoryBot factories
-        'service' => 3,  # service objects
-        'model' => 4, # related models
-        'controller' => 5,  # controllers
-        'serializer' => 6,  # serializers
-        'concern' => 7, # concerns/mixins
-        'helper' => 8, # helpers
-        'migration' => 9 # migrations
-      }.freeze
-
-      attr_reader :loaded_files, :signature_files, :tokens_used
-
-      def initialize(budget: DEFAULT_BUDGET, codebase_index: nil)
-        @budget = budget
-        @codebase_index = codebase_index
-        @loaded_files = []
-        @signature_files = []
-        @tokens_used = 0
-      end
-
-      # Load context for a primary file, filling budget with related files.
-      # Returns array of { file:, content:, mode: :full|:signatures }
-      #
-      # When a codebase_index is available and no related_files are supplied,
-      # uses impact_analysis to auto-discover related files (specs,
-      # associated models, controllers, etc.).
-      def load_for(file_path, related_files: [])
-        results = []
-
-        # Primary file always loads fully
-        primary_content = safe_read(file_path)
-        return results unless primary_content
-
-        primary_tokens = estimate_tokens(primary_content)
-        @tokens_used = primary_tokens
-        @loaded_files << file_path
-        results << { file: file_path, content: primary_content, mode: :full }
-
-        # Auto-discover related files from the index when none supplied
-        related_files = discover_related_files(file_path) if related_files.empty? && @codebase_index
-
-        # Sort related files by priority and fill remaining budget
-        sorted = prioritize(related_files)
-        remaining = @budget - @tokens_used
-        remaining = load_full_files(sorted, results, remaining)
-        load_signature_files(sorted, results, remaining)
-
-        results
-      end
-
-      # Extract method signatures and class structure without method bodies.
-      # Much more compact than full source — typically 10-20% of original size.
-      def extract_signatures(content)
-        signatures = []
-        indent_stack = []
-
-        content.lines.each do |line|
-          process_signature_line(line, signatures, indent_stack)
-        end
-
-        signatures.join
-      end
-
-      # Returns budget utilization stats.
-      def stats
-        {
-          budget: @budget,
-          tokens_used: @tokens_used,
-          utilization: @budget.positive? ? (@tokens_used.to_f / @budget).round(3) : 0.0,
-          full_files: @loaded_files.size,
-          signature_files: @signature_files.size
-        }
-      end
-
-      private
-
-      def discover_related_files(file_path)
-        analysis = @codebase_index.impact_analysis(file_path)
-        analysis[:affected_files].reject { |f| f == file_path }
-      rescue StandardError
-        []
-      end
-
-      def load_full_files(sorted, results, remaining)
-        sorted.each do |rel_path|
-          content = safe_read(rel_path)
-          next unless content
-
-          size = estimate_tokens(content)
-          next unless size <= remaining
-
-          results << { file: rel_path, content: content, mode: :full }
-          @loaded_files << rel_path
-          @tokens_used += size
-          remaining -= size
-        end
-        remaining
-      end
-
-      def load_signature_files(sorted, results, remaining)
-        sorted.each do |rel_path|
-          next if @loaded_files.include?(rel_path)
-
-          content = safe_read(rel_path)
-          next unless content
-
-          sigs = extract_signatures(content)
-          sig_size = estimate_tokens(sigs)
-          next unless sig_size <= remaining
-
-          results << { file: rel_path, content: sigs, mode: :signatures }
-          @signature_files << rel_path
-          @tokens_used += sig_size
-          remaining -= sig_size
-        end
-      end
-
-      # -- signature extraction dispatch
-      def process_signature_line(line, signatures, indent_stack)
-        stripped = line.strip
-        if signature_line?(stripped)
-          signatures << line
-          indent_stack << current_indent(line) if block_opener?(stripped)
-        elsif stripped == 'end' && indent_stack.any? && current_indent(line) <= indent_stack.last
-          signatures << line
-          indent_stack.pop
-        elsif class_or_module_line?(stripped)
-          signatures << line
-          indent_stack << current_indent(line)
-        end
-      end
-
-      def prioritize(files)
-        files.sort_by do |path|
-          basename = File.basename(path, '.*').downcase
-          priority = PRIORITY_MAP.find { |key, _| basename.include?(key) }&.last || 10
-          priority
-        end
-      end
-
-      def signature_line?(stripped)
-        stripped.match?(/\A\s*(def\s|attr_|include\s|extend\s|has_|belongs_|validates|scope\s|delegate\s)/)
-      end
-
-      def class_or_module_line?(stripped)
-        stripped.match?(/\A\s*(class|module)\s/)
-      end
-
-      def block_opener?(stripped)
-        stripped.match?(/\Adef\s/)
-      end
-
-      def current_indent(line)
-        line.match(/\A(\s*)/)[1].length
-      end
-
-      def safe_read(path)
-        File.read(path)
-      rescue StandardError
-        nil
-      end
-
-      def estimate_tokens(text)
-        (text.bytesize.to_f / CHARS_PER_TOKEN).ceil
-      end
-    end
-  end
-end

data/lib/rubyn_code/context/schema_filter.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-module RubynCode
-  module Context
-    # Extracts only the relevant table definitions from db/schema.rb
-    # based on which models are currently in context. Loading the full
-    # schema for a large Rails app can be 5-10K tokens; filtering to
-    # relevant tables typically reduces this to 200-500 tokens.
-    module SchemaFilter
-      TABLE_PATTERN = /create_table\s+"([^"]+)"/
-      END_PATTERN = /\A\s+end\s*\z/
-
-      class << self
-        # Returns schema definitions for only the specified table names.
-        #
-        # @param schema_path [String] path to db/schema.rb
-        # @param table_names [Array<String>] table names to include
-        # @return [String] filtered schema content
-        def filter(schema_path, table_names:)
-          return '' if table_names.empty?
-          return '' unless File.exist?(schema_path)
-
-          lines = File.readlines(schema_path)
-          extract_tables(lines, table_names.to_set(&:to_s))
-        end
-
-        # Derives table names from model class names using Rails conventions.
-        #
-        # @param model_names [Array<String>] e.g., ["User", "OrderItem"]
-        # @return [Array<String>] e.g., ["users", "order_items"]
-        def tableize(model_names)
-          model_names.map { |name| "#{name.gsub(/([a-z])([A-Z])/, '\1_\2').downcase}s" }
-        end
-
-        # Convenience: filter schema by model names instead of table names.
-        def filter_for_models(schema_path, model_names:)
-          tables = tableize(model_names)
-          filter(schema_path, table_names: tables)
-        end
-
-        private
-
-        def extract_tables(lines, table_set)
-          result = []
-          capturing = false
-
-          lines.each do |line|
-            match = TABLE_PATTERN.match(line)
-            capturing = true if match && table_set.include?(match[1])
-
-            result << line if capturing
-
-            if capturing && END_PATTERN.match?(line)
-              capturing = false
-              result << "\n"
-            end
-          end
-
-          result.join
-        end
-      end
-    end
-  end
-end

data/lib/rubyn_code/learning/shortcut.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-module RubynCode
-  module Learning
-    # Uses learned instincts to skip redundant discovery steps. For example,
-    # if we know the project uses FactoryBot, skip checking test_helper.rb
-    # and looking for factories/ — just generate FactoryBot-style specs.
-    class Shortcut
-      SHORTCUT_RULES = {
-        'uses_factory_bot' => {
-          skip: %w[test_helper factories_check],
-          apply: { spec_template: :factory_bot_rspec }
-        },
-        'uses_rspec' => {
-          skip: %w[framework_detection],
-          apply: { test_framework: :rspec }
-        },
-        'uses_minitest' => {
-          skip: %w[framework_detection],
-          apply: { test_framework: :minitest }
-        },
-        'uses_service_objects' => {
-          skip: %w[pattern_detection],
-          apply: { service_pattern: 'app/services/**/*_service.rb' }
-        },
-        'uses_devise' => {
-          skip: %w[auth_detection],
-          apply: { auth_framework: :devise }
-        },
-        'uses_grape' => {
-          skip: %w[api_detection],
-          apply: { api_framework: :grape }
-        },
-        'uses_sidekiq' => {
-          skip: %w[job_detection],
-          apply: { job_framework: :sidekiq }
-        }
-      }.freeze
-
-      attr_reader :applied_shortcuts, :tokens_saved_estimate
-
-      def initialize
-        @applied_shortcuts = []
-        @tokens_saved_estimate = 0
-      end
-
-      # Apply shortcuts based on instinct patterns.
-      #
-      # @param instinct_patterns [Array<String>] patterns from the instincts table
-      # @return [Hash] aggregated settings from applied shortcuts
-      def apply(instinct_patterns)
-        settings = {}
-
-        instinct_patterns.each do |pattern|
-          rule_key = match_rule(pattern)
-          next unless rule_key
-
-          rule = SHORTCUT_RULES[rule_key]
-          settings.merge!(rule[:apply])
-          @applied_shortcuts << { rule: rule_key, skipped: rule[:skip] }
-          @tokens_saved_estimate += rule[:skip].size * 500
-        end
-
-        settings
-      end
-
-      # Check if a discovery step should be skipped.
-      #
-      # @param step_name [String] the discovery step name
-      # @return [Boolean]
-      def skip?(step_name)
-        @applied_shortcuts.any? { |s| s[:skipped].include?(step_name.to_s) }
-      end
-
-      # Returns stats about shortcuts applied this session.
-      def stats
-        {
-          shortcuts_applied: @applied_shortcuts.size,
-          steps_skipped: @applied_shortcuts.sum { |s| s[:skipped].size },
-          tokens_saved_estimate: @tokens_saved_estimate
-        }
-      end
-
-      private
-
-      def match_rule(pattern)
-        normalized = pattern.to_s.downcase
-        SHORTCUT_RULES.each_key do |key|
-          return key if normalized.include?(key.tr('_', ' ')) || normalized.include?(key)
-        end
-        nil
-      end
-    end
-  end
-end

data/lib/rubyn_code/llm/adapters/token_caching.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-module RubynCode
-  module LLM
-    module Adapters
-      # Cached access to the Anthropic credential.
-      #
-      # TokenStore.load shells out to the macOS keychain, so the loaded
-      # tokens are cached per adapter instance. The cache drops itself once
-      # the token nears expiry (picking up an externally refreshed
-      # credential) and must be invalidated on 401 responses.
-      module TokenCaching
-        private
-
-        def oauth_token?
-          return @oauth_token unless @oauth_token.nil?
-
-          @oauth_token = access_token.include?('sk-ant-oat')
-        end
-
-        def ensure_valid_token!
-          return if Auth::TokenStore.valid_tokens?(tokens)
-
-          raise Client::AuthExpiredError,
-                'No valid authentication. Run `rubyn-code --auth` or set ANTHROPIC_API_KEY.'
-        end
-
-        def access_token
-          token = tokens&.fetch(:access_token, nil)
-          raise Client::AuthExpiredError, 'No stored access token' unless token
-
-          token
-        end
-
-        def tokens
-          invalidate_token_cache! if token_cache_stale?
-          @tokens ||= Auth::TokenStore.load
-        end
-
-        def token_cache_stale?
-          expires_at = @tokens&.fetch(:expires_at, nil)
-          return false unless expires_at
-
-          expires_at <= Time.now + Auth::TokenStore::EXPIRY_BUFFER_SECONDS
-        end
-
-        def invalidate_token_cache!
-          @tokens = nil
-          @oauth_token = nil
-        end
-      end
-    end
-  end
-end

data/lib/rubyn_code/llm/streaming.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module RubynCode
-  module LLM
-    # Backward-compatibility shim.
-    # Delegates to Adapters::AnthropicStreaming so existing references
-    # to LLM::Streaming keep working during the migration.
-    Streaming = Adapters::AnthropicStreaming
-  end
-end