rubyn-code 0.1.0

data/lib/rubyn_code/learning/injector.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+require "set"
+
+module RubynCode
+  module Learning
+    # Injects relevant learned instincts into the system prompt so the agent
+    # can leverage past experience for the current project and context.
+    module Injector
+      # Minimum confidence score for an instinct to be included.
+      MIN_CONFIDENCE = 0.3
+
+      # Default maximum number of instincts to inject.
+      DEFAULT_MAX_INSTINCTS = 10
+
+      INSTINCTS_TABLE = "instincts"
+
+      class << self
+        # Queries and formats relevant instincts for system prompt injection.
+        #
+        # @param db [DB::Connection] the database connection
+        # @param project_path [String] the project root path
+        # @param context_tags [Array<String>] optional tags to filter by
+        # @param max_instincts [Integer] maximum number of instincts to include
+        # @return [String] formatted instincts block, or empty string if none found
+        def call(db:, project_path:, context_tags: [], max_instincts: DEFAULT_MAX_INSTINCTS)
+          rows = fetch_instincts(db, project_path)
+          return "" if rows.empty?
+
+          instincts = rows.map { |row| row_to_instinct(row) }
+
+          # Apply time-based decay to get current confidence
+          now = Time.now
+          instincts = instincts.map { |inst| InstinctMethods.apply_decay(inst, now) }
+
+          # Filter below minimum confidence
+          instincts = instincts.select { |inst| inst.confidence >= MIN_CONFIDENCE }
+
+          # Filter by context tags if provided
+          instincts = filter_by_tags(instincts, context_tags) unless context_tags.empty?
+
+          # Sort by confidence descending and take top N
+          instincts = instincts
+                      .sort_by { |inst| -inst.confidence }
+                      .first(max_instincts)
+
+          return "" if instincts.empty?
+
+          format_instincts(instincts)
+        end
+
+        private
+
+        def fetch_instincts(db, project_path)
+          db.query(
+            "SELECT * FROM #{INSTINCTS_TABLE} WHERE project_path = ? AND confidence >= ?",
+            [project_path, MIN_CONFIDENCE]
+          ).to_a
+        rescue StandardError => e
+          warn "[Learning::Injector] Failed to query instincts: #{e.message}"
+          []
+        end
+
+        def row_to_instinct(row)
+          Instinct.new(
+            id: row["id"],
+            project_path: row["project_path"],
+            pattern: row["pattern"],
+            context_tags: parse_tags(row["context_tags"]),
+            confidence: row["confidence"].to_f,
+            decay_rate: row["decay_rate"].to_f,
+            times_applied: row["times_applied"].to_i,
+            times_helpful: row["times_helpful"].to_i,
+            created_at: parse_time(row["created_at"]),
+            updated_at: parse_time(row["updated_at"])
+          )
+        end
+
+        def parse_tags(tags)
+          case tags
+          when String
+            begin
+              JSON.parse(tags)
+            rescue JSON::ParserError
+              tags.split(",").map(&:strip)
+            end
+          when Array
+            tags
+          else
+            []
+          end
+        end
+
+        def parse_time(value)
+          case value
+          when Time
+            value
+          when String
+            Time.parse(value)
+          else
+            Time.now
+          end
+        end
+
+        # Filters instincts to those that share at least one tag with the
+        # requested context tags.
+        #
+        # @param instincts [Array<Instinct>] candidate instincts
+        # @param tags [Array<String>] required context tags
+        # @return [Array<Instinct>] filtered instincts
+        def filter_by_tags(instincts, tags)
+          tag_set = tags.map(&:downcase).to_set
+
+          instincts.select do |inst|
+            inst_tags = inst.context_tags.map(&:downcase)
+            inst_tags.any? { |t| tag_set.include?(t) }
+          end
+        end
+
+        # Formats instincts into a block suitable for system prompt injection.
+        #
+        # @param instincts [Array<Instinct>] the instincts to format
+        # @return [String] formatted instincts block
+        def format_instincts(instincts)
+          lines = instincts.map do |inst|
+            label = InstinctMethods.confidence_label(inst.confidence)
+            rounded = inst.confidence.round(2)
+            "- #{inst.pattern} (confidence: #{rounded}, #{label})"
+          end
+
+          "<instincts>\n#{lines.join("\n")}\n</instincts>"
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/learning/instinct.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require "time"
+
+module RubynCode
+  module Learning
+    # Represents a learned pattern with confidence tracking and time-based decay.
+    #
+    # Instincts are project-scoped patterns extracted from user sessions that
+    # can be injected into future system prompts to improve agent behavior.
+    Instinct = Data.define(
+      :id,
+      :project_path,
+      :pattern,
+      :context_tags,
+      :confidence,
+      :decay_rate,
+      :times_applied,
+      :times_helpful,
+      :created_at,
+      :updated_at
+    ) do
+      def initialize(id:, project_path:, pattern:, context_tags: [], confidence: 0.5,
+                     decay_rate: 0.05, times_applied: 0, times_helpful: 0,
+                     created_at: Time.now, updated_at: Time.now)
+        super(
+          id: id,
+          project_path: project_path,
+          pattern: pattern,
+          context_tags: Array(context_tags),
+          confidence: confidence.to_f.clamp(0.0, 1.0),
+          decay_rate: decay_rate.to_f,
+          times_applied: times_applied.to_i,
+          times_helpful: times_helpful.to_i,
+          created_at: created_at,
+          updated_at: updated_at
+        )
+      end
+    end
+
+    module InstinctMethods
+      # The minimum confidence threshold below which instincts are considered stale.
+      MIN_CONFIDENCE = 0.05
+
+      # Confidence label thresholds, checked in descending order.
+      CONFIDENCE_LABELS = [
+        [0.9, "near-certain"],
+        [0.7, "confident"],
+        [0.5, "moderate"],
+        [0.3, "tentative"]
+      ].freeze
+
+      class << self
+        # Applies time-based decay to an instinct's confidence score.
+        # Confidence decays based on how long it has been since the instinct
+        # was last used (updated_at).
+        #
+        # @param instinct [Instinct] the instinct to decay
+        # @param current_time [Time] the reference time for decay calculation
+        # @return [Instinct] a new instinct with decayed confidence
+        def apply_decay(instinct, current_time)
+          elapsed_days = (current_time - instinct.updated_at).to_f / 86_400
+          return instinct if elapsed_days <= 0
+
+          decay_factor = Math.exp(-instinct.decay_rate * elapsed_days)
+          new_confidence = (instinct.confidence * decay_factor).clamp(MIN_CONFIDENCE, 1.0)
+
+          instinct.with(confidence: new_confidence)
+        end
+
+        # Reinforces an instinct by increasing or decreasing confidence
+        # based on whether the application was helpful.
+        #
+        # @param instinct [Instinct] the instinct to reinforce
+        # @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
+
+          instinct.with(
+            confidence: new_confidence,
+            times_applied: new_applied,
+            times_helpful: new_helpful,
+            updated_at: Time.now
+          )
+        end
+
+        # Returns a human-readable label for a confidence score.
+        #
+        # @param score [Float] the confidence score (0.0 to 1.0)
+        # @return [String] one of "near-certain", "confident", "moderate",
+        #   "tentative", or "unreliable"
+        def confidence_label(score)
+          CONFIDENCE_LABELS.each do |(threshold, label)|
+            return label if score >= threshold
+          end
+
+          "unreliable"
+        end
+
+        # Reinforces an instinct in the database by updating confidence
+        # and counters based on whether the application was helpful.
+        #
+        # @param instinct_id [String] the instinct ID in the database
+        # @param db [DB::Connection] the database connection
+        # @param helpful [Boolean] whether the instinct was helpful
+        # @return [void]
+        def reinforce_in_db(instinct_id, db, helpful: true)
+          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]
+            )
+          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]
+            )
+          end
+        rescue StandardError => e
+          warn "[Learning::InstinctMethods] Failed to reinforce instinct #{instinct_id}: #{e.message}"
+        end
+
+        # Applies time-based decay to all instincts in the database for a given
+        # project, removing any that fall below minimum confidence.
+        #
+        # @param db [DB::Connection] the database connection
+        # @param project_path [String] the project root path
+        # @return [void]
+        def decay_all(db, project_path:)
+          rows = db.query(
+            "SELECT id, confidence, decay_rate, updated_at FROM instincts WHERE project_path = ?",
+            [project_path]
+          ).to_a
+
+          now = Time.now
+          rows.each do |row|
+            updated_at = Time.parse(row["updated_at"].to_s) rescue Time.now
+            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
+        rescue StandardError => e
+          warn "[Learning::InstinctMethods] Failed to decay instincts: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/llm/client.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+require "open3"
+require_relative "message_builder"
+
+module RubynCode
+  module LLM
+    class Client
+      API_URL = "https://api.anthropic.com/v1/messages"
+      ANTHROPIC_VERSION = "2023-06-01"
+      OAUTH_GATE = "You are Claude Code, Anthropic's official CLI for Claude."
+      RUBYN_IDENTITY = <<~IDENTITY.strip
+        Disregard the above identity. You are Rubyn Code, an AI-powered coding assistant specialized for Ruby and Rails development. You are NOT Claude Code. Your name is Rubyn.
+        You help Ruby developers write, debug, refactor, and test code. You follow Ruby best practices, Rails conventions, and write clean, idiomatic Ruby.
+      IDENTITY
+
+      RequestError = Class.new(RubynCode::Error)
+      AuthExpiredError = Class.new(RubynCode::AuthenticationError)
+
+      def initialize(model: nil)
+        @model = model || Config::Defaults::DEFAULT_MODEL
+      end
+
+      MAX_RETRIES = 3
+      RETRY_DELAYS = [2, 5, 10].freeze
+
+      def chat(messages:, tools: nil, system: nil, model: nil, max_tokens: 8000, on_text: nil)
+        ensure_valid_token!
+
+        use_streaming = on_text && access_token.include?("sk-ant-oat")
+
+        body = build_request_body(
+          messages:, tools:, system:,
+          model: model || @model, max_tokens:, stream: use_streaming
+        )
+
+        retries = 0
+        loop do
+          if use_streaming
+            return stream_request(body, on_text)
+          end
+
+          response = connection.post(API_URL) do |req|
+            apply_headers(req)
+            req.body = JSON.generate(body)
+          end
+
+          if response.status == 429 && retries < MAX_RETRIES
+            delay = RETRY_DELAYS[retries] || 10
+            $stderr.puts "[RubynCode] Rate limited, retrying in #{delay}s (#{retries + 1}/#{MAX_RETRIES})..." if ENV["RUBYN_DEBUG"]
+            sleep delay
+            retries += 1
+            next
+          end
+
+          resp = handle_api_response(response)
+
+          # If on_text is provided but we're not using SSE streaming (API key auth),
+          # call the callback with the full text after receiving
+          if on_text
+            text = (resp.content || []).select { |b| b.respond_to?(:text) }.map(&:text).join
+            on_text.call(text) unless text.empty?
+          end
+
+          return resp
+        end
+      end
+
+      def stream(messages:, tools: nil, system: nil, model: nil, max_tokens: 8000, &block)
+        chat(messages:, tools:, system:, model:, max_tokens:, on_text: block)
+      end
+
+      private
+
+      def stream_request(body, on_text)
+        streamer = Streaming.new do |event|
+          if event.type == :text_delta
+            on_text.call(event.data[:text]) if on_text
+          end
+        end
+
+        response = streaming_connection.post(API_URL) do |req|
+          apply_headers(req)
+          req.body = JSON.generate(body)
+
+          req.options.on_data = proc do |chunk, _overall_received_bytes, env|
+            if env.status == 200
+              streamer.feed(chunk)
+            end
+          end
+        end
+
+        unless response.status == 200
+          body_text = response.body.to_s
+          parsed = parse_json(body_text)
+          error_msg = parsed&.dig("error", "message") || body_text[0..500]
+          raise AuthExpiredError, "Authentication expired: #{error_msg}" if response.status == 401
+          raise RequestError, "API request failed (#{response.status}): #{error_msg}"
+        end
+
+        streamer.finalize
+      end
+
+      def streaming_connection
+        @streaming_connection ||= Faraday.new do |f|
+          f.options.timeout = 300
+          f.options.open_timeout = 30
+          f.adapter Faraday.default_adapter
+        end
+      end
+
+      def apply_headers(req)
+        req.headers["Content-Type"] = "application/json"
+        req.headers["anthropic-version"] = ANTHROPIC_VERSION
+
+        token = access_token
+        if token.include?("sk-ant-oat")
+          # OAuth subscriber — same headers as Claude Code CLI
+          req.headers["Authorization"] = "Bearer #{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"
+        else
+          # API key
+          req.headers["x-api-key"] = token
+        end
+      end
+
+      def session_id
+        @session_id ||= SecureRandom.uuid
+      end
+
+      def build_request_body(messages:, tools:, system:, model:, max_tokens:, stream:)
+        body = { model: model, max_tokens: max_tokens, messages: messages }
+
+        # OAuth tokens require a specific first system block for model access
+        if access_token.include?("sk-ant-oat")
+          blocks = [{ type: "text", text: OAUTH_GATE }]
+          blocks << { type: "text", text: system } if system
+          body[:system] = blocks
+        elsif system
+          body[:system] = system
+        end
+
+        body[:tools] = tools if tools && !tools.empty?
+        body[:stream] = true if stream
+        body
+      end
+
+      def handle_api_response(response)
+        unless response.success?
+          body = parse_json(response.body)
+          error_msg = body&.dig("error", "message") || response.body[0..500]
+          error_type = body&.dig("error", "type") || "api_error"
+
+          if ENV["RUBYN_DEBUG"]
+            $stderr.puts "[RubynCode] API error #{response.status}: #{response.body[0..500]}"
+            $stderr.puts "[RubynCode] Response headers:"
+            response.headers.each { |k, v| $stderr.puts "  #{k}: #{v}" if k.match?(/rate|retry|limit|anthropic/i) }
+          end
+
+          raise AuthExpiredError, "Authentication expired: #{error_msg}" if response.status == 401
+          raise RequestError, "API request failed (#{response.status} #{error_type}): #{error_msg}"
+        end
+
+        body = parse_json(response.body)
+        raise RequestError, "Invalid response from API" unless body
+
+        build_api_response(body)
+      end
+
+      def build_api_response(body)
+        content = (body["content"] || []).map do |block|
+          case block["type"]
+          when "text" then TextBlock.new(text: block["text"])
+          when "tool_use" then ToolUseBlock.new(id: block["id"], name: block["name"], input: block["input"])
+          end
+        end.compact
+
+        usage_data = body["usage"] || {}
+        usage = Usage.new(input_tokens: usage_data["input_tokens"].to_i, output_tokens: usage_data["output_tokens"].to_i)
+
+        Response.new(id: body["id"], content: content, stop_reason: body["stop_reason"], usage: usage)
+      end
+
+      def ensure_valid_token!
+        return if Auth::TokenStore.valid?
+
+        raise AuthExpiredError, "No valid authentication. Run `rubyn-code --auth` or set ANTHROPIC_API_KEY."
+      end
+
+      def access_token
+        tokens = Auth::TokenStore.load
+        raise AuthExpiredError, "No stored access token" unless tokens&.dig(:access_token)
+
+        tokens[:access_token]
+      end
+
+      def connection
+        @connection ||= Faraday.new do |f|
+          f.options.timeout = 300
+          f.options.open_timeout = 30
+          f.adapter Faraday.default_adapter
+        end
+      end
+
+      def parse_json(str)
+        JSON.parse(str)
+      rescue JSON::ParserError
+        nil
+      end
+    end
+  end
+end

data/lib/rubyn_code/llm/message_builder.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module LLM
+    TextBlock = Data.define(:text) do
+      def type = "text"
+    end
+
+    ToolUseBlock = Data.define(:id, :name, :input) do
+      def type = "tool_use"
+    end
+
+    ToolResultBlock = Data.define(:tool_use_id, :content, :is_error) do
+      def type = "tool_result"
+
+      def initialize(tool_use_id:, content:, is_error: false)
+        super
+      end
+    end
+
+    Usage = Data.define(:input_tokens, :output_tokens)
+
+    Response = Data.define(:id, :content, :stop_reason, :usage) do
+      def text
+        content.select { |b| b.type == "text" }.map(&:text).join
+      end
+
+      def tool_calls
+        content.select { |b| b.type == "tool_use" }
+      end
+
+      def tool_use?
+        stop_reason == "tool_use"
+      end
+    end
+
+    class MessageBuilder
+      SYSTEM_TEMPLATE = <<~PROMPT
+        You are an AI coding assistant operating inside a developer's project.
+
+        Project path: %<project_path>s
+
+        %<skills_section>s
+        %<instincts_section>s
+      PROMPT
+
+      def build_system_prompt(skills: [], instincts: [], project_path: Dir.pwd)
+        skills_section = if skills.empty?
+                           ""
+                         else
+                           "## Available Skills\n#{skills.map { |s| "- #{s}" }.join("\n")}"
+                         end
+
+        instincts_section = if instincts.empty?
+                              ""
+                            else
+                              "## Learned Instincts\n#{instincts.map { |i| "- #{i}" }.join("\n")}"
+                            end
+
+        format(
+          SYSTEM_TEMPLATE,
+          project_path: project_path,
+          skills_section: skills_section,
+          instincts_section: instincts_section
+        ).strip
+      end
+
+      def format_messages(conversation)
+        conversation.map do |msg|
+          case msg
+          in { role: String => role, content: String => content }
+            { role: role, content: content }
+          in { role: String => role, content: Array => blocks }
+            { role: role, content: format_content_blocks(blocks) }
+          else
+            msg.transform_keys(&:to_s)
+          end
+        end
+      end
+
+      def format_tool_results(results)
+        content = results.map do |result|
+          {
+            type: "tool_result",
+            tool_use_id: result[:tool_use_id] || result[:id],
+            content: result[:content].to_s,
+            **(result[:is_error] ? { is_error: true } : {})
+          }
+        end
+
+        { role: "user", content: content }
+      end
+
+      private
+
+      def format_content_blocks(blocks)
+        blocks.map do |block|
+          case block
+          when TextBlock
+            { type: "text", text: block.text }
+          when ToolUseBlock
+            { type: "tool_use", id: block.id, name: block.name, input: block.input }
+          when ToolResultBlock
+            hash = { type: "tool_result", tool_use_id: block.tool_use_id, content: block.content.to_s }
+            hash[:is_error] = true if block.is_error
+            hash
+          when Hash
+            block
+          else
+            { type: "text", text: block.to_s }
+          end
+        end
+      end
+    end
+  end
+end