rubyn-code 0.7.0 → 0.9.0

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

data/lib/rubyn_code/protocols/plan_approval.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-require 'tty-prompt'
-require 'tty-reader'
-require 'pastel'
-
-module RubynCode
-  module Protocols
-    # Presents a plan to the user for approval before executing significant changes.
-    #
-    # This protocol ensures that destructive or wide-reaching operations are
-    # reviewed by a human before proceeding.
-    module PlanApproval
-      APPROVED = :approved
-      REJECTED = :rejected
-
-      class << self
-        # Displays a plan and asks the user to approve or reject it.
-        #
-        # @param plan_text [String] the plan description to display
-        # @param prompt [String, nil] optional custom prompt message
-        # @return [Symbol] :approved or :rejected
-        def request(plan_text, prompt: nil)
-          pastel = Pastel.new
-          display_plan(pastel, plan_text, prompt)
-
-          approved = build_prompt.yes?(
-            pastel.yellow.bold('Do you approve this plan?'),
-            default: false
-          )
-
-          approved ? approve(pastel) : reject(pastel)
-        rescue TTY::Reader::InputInterrupt
-          $stdout.puts pastel.red("\nPlan rejected (interrupted).")
-          REJECTED
-        end
-
-        private
-
-        def display_plan(pastel, plan_text, prompt)
-          $stdout.puts
-          $stdout.puts pastel.cyan.bold('Proposed Plan')
-          $stdout.puts pastel.cyan('=' * 60)
-          $stdout.puts plan_text
-          $stdout.puts pastel.cyan('=' * 60)
-          $stdout.puts
-          return unless prompt
-
-          $stdout.puts pastel.yellow(prompt)
-          $stdout.puts
-        end
-
-        def approve(pastel)
-          $stdout.puts pastel.green('Plan approved.')
-          APPROVED
-        end
-
-        def reject(pastel)
-          $stdout.puts pastel.red('Plan rejected.')
-          REJECTED
-        end
-
-        # Builds a TTY::Prompt instance configured for non-destructive interrupt handling.
-        #
-        # @return [TTY::Prompt]
-        def build_prompt
-          TTY::Prompt.new(interrupt: :noop)
-        end
-      end
-    end
-  end
-end