rubyn-code 0.2.2 → 0.4.0

data/lib/rubyn_code/learning/instinct.rb

@@ -38,7 +38,7 @@ module RubynCode
       end
     end
 
-    module InstinctMethods
+    module InstinctMethods # rubocop:disable Metrics/ModuleLength -- instinct CRUD + decay logic with DB operations
       # The minimum confidence threshold below which instincts are considered stale.
       MIN_CONFIDENCE = 0.05
 
@@ -75,26 +75,26 @@ module RubynCode
         # @param helpful [Boolean] whether the instinct was helpful this time
         # @return [Instinct] a new instinct with updated confidence and counters
         def reinforce(instinct, helpful: true)
-          new_applied = instinct.times_applied + 1
-
-          if helpful
-            new_helpful = instinct.times_helpful + 1
-            boost = 0.1 * (1.0 - instinct.confidence) # Diminishing returns
-            new_confidence = (instinct.confidence + boost).clamp(0.0, 1.0)
-          else
-            new_helpful = instinct.times_helpful
-            penalty = 0.15 * instinct.confidence # Proportional penalty
-            new_confidence = (instinct.confidence - penalty).clamp(MIN_CONFIDENCE, 1.0)
-          end
+          new_confidence, new_helpful = compute_reinforcement(instinct, helpful)
 
           instinct.with(
             confidence: new_confidence,
-            times_applied: new_applied,
+            times_applied: instinct.times_applied + 1,
             times_helpful: new_helpful,
             updated_at: Time.now
           )
         end
 
+        def compute_reinforcement(instinct, helpful)
+          if helpful
+            boost = 0.1 * (1.0 - instinct.confidence)
+            [(instinct.confidence + boost).clamp(0.0, 1.0), instinct.times_helpful + 1]
+          else
+            penalty = 0.15 * instinct.confidence
+            [(instinct.confidence - penalty).clamp(MIN_CONFIDENCE, 1.0), instinct.times_helpful]
+          end
+        end
+
         # Returns a human-readable label for a confidence score.
         #
         # @param score [Float] the confidence score (0.0 to 1.0)
@@ -119,20 +119,41 @@ module RubynCode
           now = Time.now.utc.strftime('%Y-%m-%dT%H:%M:%SZ')
 
           if helpful
-            db.execute(
-              'UPDATE instincts SET confidence = MIN(1.0, confidence + 0.1 * (1.0 - confidence)), times_applied = times_applied + 1, times_helpful = times_helpful + 1, updated_at = ? WHERE id = ?',
-              [now, instinct_id]
-            )
+            reinforce_positive(db, instinct_id, now)
           else
-            db.execute(
-              "UPDATE instincts SET confidence = MAX(#{MIN_CONFIDENCE}, confidence - 0.15 * confidence), times_applied = times_applied + 1, updated_at = ? WHERE id = ?",
-              [now, instinct_id]
-            )
+            reinforce_negative(db, instinct_id, now)
           end
         rescue StandardError => e
           warn "[Learning::InstinctMethods] Failed to reinforce instinct #{instinct_id}: #{e.message}"
         end
 
+        def reinforce_positive(db, instinct_id, now)
+          db.execute(
+            <<~SQL.tr("\n", ' ').strip,
+              UPDATE instincts
+              SET confidence = MIN(1.0, confidence + 0.1 * (1.0 - confidence)),
+                  times_applied = times_applied + 1,
+                  times_helpful = times_helpful + 1,
+                  updated_at = ?
+              WHERE id = ?
+            SQL
+            [now, instinct_id]
+          )
+        end
+
+        def reinforce_negative(db, instinct_id, now)
+          db.execute(
+            <<~SQL.tr("\n", ' ').strip,
+              UPDATE instincts
+              SET confidence = MAX(#{MIN_CONFIDENCE}, confidence - 0.15 * confidence),
+                  times_applied = times_applied + 1,
+                  updated_at = ?
+              WHERE id = ?
+            SQL
+            [now, instinct_id]
+          )
+        end
+
         # Applies time-based decay to all instincts in the database for a given
         # project, removing any that fall below minimum confidence.
         #
@@ -146,30 +167,38 @@ module RubynCode
           ).to_a
 
           now = Time.now
-          rows.each do |row|
-            updated_at = begin
-              Time.parse(row['updated_at'].to_s)
-            rescue StandardError
-              Time.now
-            end
-            elapsed_days = (now - updated_at).to_f / 86_400
-            next if elapsed_days <= 0
-
-            decay_factor = Math.exp(-row['decay_rate'].to_f * elapsed_days)
-            new_confidence = (row['confidence'].to_f * decay_factor).clamp(MIN_CONFIDENCE, 1.0)
-
-            if new_confidence <= MIN_CONFIDENCE
-              db.execute('DELETE FROM instincts WHERE id = ?', [row['id']])
-            else
-              db.execute(
-                'UPDATE instincts SET confidence = ? WHERE id = ?',
-                [new_confidence, row['id']]
-              )
-            end
-          end
+          rows.each { |row| decay_single_row(db, row, now) }
         rescue StandardError => e
           warn "[Learning::InstinctMethods] Failed to decay instincts: #{e.message}"
         end
+
+        def decay_single_row(db, row, now)
+          elapsed_days = compute_elapsed_days(row, now)
+          return if elapsed_days <= 0
+
+          new_confidence = compute_decayed_confidence(row, elapsed_days)
+          apply_decay_to_db(db, row['id'], new_confidence)
+        end
+
+        def compute_elapsed_days(row, now)
+          updated_at = Time.parse(row['updated_at'].to_s)
+          (now - updated_at).to_f / 86_400
+        rescue StandardError
+          0
+        end
+
+        def compute_decayed_confidence(row, elapsed_days)
+          decay_factor = Math.exp(-row['decay_rate'].to_f * elapsed_days)
+          (row['confidence'].to_f * decay_factor).clamp(MIN_CONFIDENCE, 1.0)
+        end
+
+        def apply_decay_to_db(db, instinct_id, new_confidence)
+          if new_confidence <= MIN_CONFIDENCE
+            db.execute('DELETE FROM instincts WHERE id = ?', [instinct_id])
+          else
+            db.execute('UPDATE instincts SET confidence = ? WHERE id = ?', [new_confidence, instinct_id])
+          end
+        end
       end
     end
   end

data/lib/rubyn_code/learning/shortcut.rb

@@ -0,0 +1,95 @@
+# 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/anthropic.rb

@@ -0,0 +1,274 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'json'
+require 'securerandom'
+require_relative '../message_builder'
+
+module RubynCode
+  module LLM
+    module Adapters
+      class Anthropic < Base
+        include JsonParsing
+        include PromptCaching
+
+        API_URL = 'https://api.anthropic.com/v1/messages'
+        ANTHROPIC_VERSION = '2023-06-01'
+        MAX_RETRIES = 3
+        RETRY_DELAYS = [2, 5, 10].freeze
+
+        AVAILABLE_MODELS = %w[
+          claude-sonnet-4-20250514
+          claude-opus-4-6
+          claude-haiku-4-20250506
+        ].freeze
+
+        def provider_name
+          'anthropic'
+        end
+
+        def models
+          AVAILABLE_MODELS
+        end
+
+        def chat(messages:, model:, max_tokens:, tools: nil, system: nil, on_text: nil, task_budget: nil) # rubocop:disable Metrics/ParameterLists -- mirrors LLM adapter interface
+          ensure_valid_token!
+          use_streaming = on_text && oauth_token?
+
+          body = build_request_body(
+            messages: messages, tools: tools, system: system,
+            model: model, max_tokens: max_tokens,
+            stream: use_streaming, task_budget: task_budget
+          )
+
+          return stream_request(body, on_text) if use_streaming
+
+          execute_with_retries(body, on_text)
+        end
+
+        private
+
+        def api_url
+          API_URL
+        end
+
+        # -- Auth ---------------------------------------------------------
+
+        def oauth_token?
+          access_token.include?('sk-ant-oat')
+        end
+
+        def ensure_valid_token!
+          return if Auth::TokenStore.valid?
+
+          raise Client::AuthExpiredError,
+                'No valid authentication. Run `rubyn-code --auth` or set ANTHROPIC_API_KEY.'
+        end
+
+        def access_token
+          tokens = Auth::TokenStore.load
+          raise Client::AuthExpiredError, 'No stored access token' unless tokens&.dig(:access_token)
+
+          tokens[:access_token]
+        end
+
+        # -- Request execution --------------------------------------------
+
+        def execute_with_retries(body, on_text)
+          retries = 0
+          loop do
+            response = post_request(body)
+
+            if response.status == 429 && retries < MAX_RETRIES
+              delay = RETRY_DELAYS[retries] || 10
+              RubynCode::Debug.llm("Rate limited, retrying in #{delay}s (#{retries + 1}/#{MAX_RETRIES})...")
+              sleep delay
+              retries += 1
+              next
+            end
+
+            return finalize_response(response, on_text)
+          end
+        end
+
+        def post_request(body)
+          connection.post(api_url) do |req|
+            apply_headers(req)
+            req.body = JSON.generate(body)
+          end
+        end
+
+        def finalize_response(response, on_text)
+          resp = handle_api_response(response)
+          emit_full_text(resp, on_text)
+          resp
+        end
+
+        def emit_full_text(resp, on_text)
+          return unless on_text
+
+          text = resp.content.select { |b| b.respond_to?(:text) }.map(&:text).join
+          on_text.call(text) unless text.empty?
+        end
+
+        # -- Streaming ----------------------------------------------------
+
+        def stream_request(body, on_text)
+          streamer = build_streamer(on_text)
+          error_chunks = []
+
+          response = streaming_connection.post(api_url) do |req|
+            apply_headers(req)
+            req.body = JSON.generate(body)
+            req.options.on_data = on_data_proc(streamer, error_chunks)
+          end
+
+          handle_stream_errors(response, error_chunks)
+          streamer.finalize
+        end
+
+        def build_streamer(on_text)
+          AnthropicStreaming.new do |event|
+            on_text&.call(event.data[:text]) if event.type == :text_delta
+          end
+        end
+
+        def on_data_proc(streamer, error_chunks)
+          proc do |chunk, _bytes, env|
+            env.status == 200 ? streamer.feed(chunk) : error_chunks << chunk
+          end
+        end
+
+        def handle_stream_errors(response, error_chunks)
+          return if response.status == 200
+
+          error_msg = extract_error_message(error_chunks.join)
+
+          raise Client::AuthExpiredError, "Authentication expired: #{error_msg}" if response.status == 401
+          raise Client::PromptTooLongError, "Prompt too long: #{error_msg}" if response.status == 413
+
+          raise Client::RequestError,
+                "API streaming request failed (#{response.status}): #{error_msg}"
+        end
+
+        def extract_error_message(body_text)
+          parsed = parse_json(body_text)
+          parsed&.dig('error', 'message') || body_text[0..500]
+        end
+
+        # -- HTTP ---------------------------------------------------------
+
+        def connection
+          @connection ||= build_faraday_connection
+        end
+
+        def streaming_connection
+          @streaming_connection ||= build_faraday_connection
+        end
+
+        def build_faraday_connection
+          Faraday.new do |f|
+            f.options.timeout = 300
+            f.options.open_timeout = 30
+            f.adapter Faraday.default_adapter
+          end
+        end
+
+        # -- Headers ------------------------------------------------------
+
+        def apply_headers(req)
+          req.headers['Content-Type'] = 'application/json'
+          req.headers['anthropic-version'] = ANTHROPIC_VERSION
+          oauth_token? ? apply_oauth_headers(req) : apply_api_key_headers(req)
+        end
+
+        def apply_oauth_headers(req)
+          req.headers['Authorization'] = "Bearer #{access_token}"
+          req.headers['anthropic-beta'] = 'oauth-2025-04-20'
+          req.headers['x-app'] = 'cli'
+          req.headers['User-Agent'] = 'claude-code/2.1.79'
+          req.headers['X-Claude-Code-Session-Id'] = session_id
+          req.headers['anthropic-dangerous-direct-browser-access'] = 'true'
+        end
+
+        def apply_api_key_headers(req)
+          req.headers['x-api-key'] = access_token
+        end
+
+        def session_id
+          @session_id ||= SecureRandom.uuid
+        end
+
+        # -- Request body -------------------------------------------------
+
+        def build_request_body(messages:, tools:, system:, model:, max_tokens:, stream:, **_opts) # rubocop:disable Metrics/ParameterLists -- API request builder mirrors Claude API params
+          body = { model: model, max_tokens: max_tokens }
+          apply_system_blocks(body, system)
+          apply_tool_cache(body, tools)
+          body[:messages] = add_message_cache_breakpoint(messages)
+          body[:stream] = true if stream
+          body
+        end
+
+        # -- Response parsing ---------------------------------------------
+
+        def handle_api_response(response)
+          raise_on_error(response) unless response.success?
+
+          body = parse_json(response.body)
+          raise Client::RequestError, 'Invalid response from API' unless body
+
+          build_api_response(body)
+        end
+
+        def raise_on_error(response)
+          body = parse_json(response.body)
+          error_msg = body&.dig('error', 'message') || response.body[0..500]
+          error_type = body&.dig('error', 'type') || 'api_error'
+
+          log_api_error(response)
+          raise Client::AuthExpiredError, "Authentication expired: #{error_msg}" if response.status == 401
+          raise Client::PromptTooLongError, "Prompt too long: #{error_msg}" if response.status == 413
+
+          raise Client::RequestError, "API request failed (#{response.status} #{error_type}): #{error_msg}"
+        end
+
+        def log_api_error(response)
+          RubynCode::Debug.llm("API error #{response.status}: #{response.body[0..500]}")
+          return unless RubynCode::Debug.enabled?
+
+          response.headers.each do |k, v|
+            RubynCode::Debug.llm("  #{k}: #{v}") if k.match?(/rate|retry|limit|anthropic/i)
+          end
+        end
+
+        def build_api_response(body)
+          content = parse_content_blocks(body['content'])
+          usage = parse_usage(body['usage'])
+          Response.new(id: body['id'], content: content, stop_reason: body['stop_reason'], usage: usage)
+        end
+
+        def parse_content_blocks(blocks)
+          (blocks || []).filter_map do |block|
+            case block['type']
+            when 'text' then TextBlock.new(text: block['text'])
+            when 'tool_use'
+              ToolUseBlock.new(id: block['id'], name: block['name'], input: block['input'])
+            end
+          end
+        end
+
+        def parse_usage(data)
+          return Usage.new(input_tokens: 0, output_tokens: 0) unless data
+
+          Usage.new(
+            input_tokens: data['input_tokens'].to_i,
+            output_tokens: data['output_tokens'].to_i,
+            cache_creation_input_tokens: data['cache_creation_input_tokens'].to_i,
+            cache_read_input_tokens: data['cache_read_input_tokens'].to_i
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module LLM
+    module Adapters
+      # Adapter for Anthropic-compatible providers that use the Messages API format.
+      #
+      # Inherits all Anthropic logic but overrides the base URL, provider name,
+      # available models, and API key resolution.
+      class AnthropicCompatible < Anthropic
+        def initialize(provider:, base_url:, api_key: nil, available_models: [])
+          super()
+          @provider = provider
+          @base_url = base_url
+          @api_key = api_key
+          @available_models = available_models.freeze
+        end
+
+        def provider_name
+          @provider
+        end
+
+        def models
+          @available_models
+        end
+
+        private
+
+        def api_url
+          "#{@base_url}/messages"
+        end
+
+        def ensure_valid_token!
+          resolve_api_key # raises if missing
+        end
+
+        def oauth_token?
+          false
+        end
+
+        def access_token
+          resolve_api_key
+        end
+
+        def resolve_api_key
+          return @api_key if @api_key
+
+          stored = Auth::TokenStore.load_provider_key(@provider)
+          return stored if stored
+
+          env_key = "#{@provider.upcase.tr('-', '_')}_API_KEY"
+          ENV.fetch(env_key) do
+            raise Client::AuthExpiredError,
+                  "No #{@provider} API key configured. Set with: /provider set-key #{@provider} <key>"
+          end
+        end
+      end
+    end
+  end
+end