sqa 0.0.24 → 0.0.31

data/lib/sqa/strategy/kbs_strategy.rb

@@ -0,0 +1,470 @@
+# frozen_string_literal: true
+
+require 'kbs'
+require 'kbs/dsl'
+
+=begin
+
+Knowledge-Based Strategy using RETE Forward Chaining
+
+This strategy uses a rule-based system with the RETE algorithm for
+forward-chaining inference. It allows defining complex trading rules
+that react to market conditions.
+
+The strategy asserts facts about market conditions (RSI, trends, volume, etc.)
+and fires rules when patterns are matched.
+
+DSL Keywords:
+  - on        : Assert a condition (fact must exist)
+  - without   : Negated condition (fact must NOT exist)
+  - perform   : Define action to execute when rule fires
+  - execute   : Alias for perform
+  - action    : Alias for perform
+
+Example:
+  strategy = SQA::Strategy::KBS.new
+
+  # Capture kb for use in perform blocks
+  kb = strategy.kb
+
+  # Define custom rules using the DSL
+  strategy.add_rule :buy_oversold_uptrend do
+    on :rsi, { level: :oversold }
+    on :trend, { direction: :up }
+    without :position
+
+    perform do
+      kb.assert(:signal, { action: :buy, confidence: :high })
+    end
+  end
+
+  # Execute strategy
+  signal = strategy.trade(vector)
+
+Note: Use 'kb.assert' (not just 'assert') in perform blocks to access the knowledge base.
+
+=end
+
+module SQA
+  class Strategy
+    class KBS
+      attr_reader :kb, :default_rules_loaded
+
+      def initialize(load_defaults: true)
+        @kb = ::KBS::DSL::KnowledgeBase.new
+        @default_rules_loaded = false
+        @last_signal = :hold
+
+        load_default_rules if load_defaults
+      end
+
+      # Main strategy interface - compatible with SQA::Strategy framework
+      def self.trade(vector)
+        strategy = new
+        strategy.execute(vector)
+      end
+
+      # Execute strategy with given market data
+      def execute(vector)
+        # Reset working memory
+        @kb.reset
+
+        # Assert facts from vector
+        assert_market_facts(vector)
+
+        # Run the inference engine
+        @kb.run
+
+        # Query for trading signal
+        determine_signal
+      end
+
+      # Add a custom trading rule
+      #
+      # Example:
+      #   add_rule :buy_dip do
+      #     on :rsi, { value: ->(v) { v < 30 } }
+      #     on :macd, { signal: :bullish }
+      #     perform { kb.assert(:signal, { action: :buy, confidence: :high }) }
+      #   end
+      #
+      # Note: Use `kb.assert` in perform blocks, not just `assert`
+      def add_rule(name, &block)
+        # Capture kb reference for use in perform blocks
+        kb = @kb
+
+        # Define the rule with kb available in closure
+        @kb.instance_eval do
+          rule(name, &block)
+        end
+
+        self
+      end
+
+      # Assert a fact into working memory
+      def assert_fact(type, attributes = {})
+        @kb.assert(type, attributes)
+      end
+
+      # Query facts from working memory
+      def query_facts(type, pattern = {})
+        @kb.query(type, pattern)
+      end
+
+      # Print current working memory (for debugging)
+      def print_facts
+        @kb.print_facts
+      end
+
+      # Print all rules (for debugging)
+      def print_rules
+        @kb.print_rules
+      end
+
+      private
+
+      # Assert market condition facts from the data vector
+      def assert_market_facts(vector)
+        # RSI facts
+        if vector.respond_to?(:rsi) && vector.rsi
+          rsi_value = Array(vector.rsi).last
+
+          assert_fact(:rsi, {
+            value: rsi_value,
+            level: rsi_level(rsi_value)
+          })
+        end
+
+        # MACD facts
+        if vector.respond_to?(:macd) && vector.macd
+          macd_line, signal_line, histogram = vector.macd
+
+          if macd_line && signal_line
+            current_macd = Array(macd_line).last
+            current_signal = Array(signal_line).last
+
+            assert_fact(:macd, {
+              line: current_macd,
+              signal: current_signal,
+              histogram: Array(histogram).last,
+              crossover: macd_crossover(macd_line, signal_line)
+            })
+          end
+        end
+
+        # Price trend facts
+        if vector.respond_to?(:prices) && vector.prices
+          prices = vector.prices
+
+          if prices.size >= 20
+            recent_trend = price_trend(prices.last(20))
+            medium_trend = price_trend(prices.last(50)) if prices.size >= 50
+
+            assert_fact(:trend, {
+              short_term: recent_trend,
+              medium_term: medium_trend || recent_trend,
+              strength: trend_strength(prices)
+            })
+          end
+        end
+
+        # SMA facts
+        if vector.respond_to?(:sma_short) && vector.respond_to?(:sma_long)
+          if vector.sma_short && vector.sma_long
+            short_sma = Array(vector.sma_short).last
+            long_sma = Array(vector.sma_long).last
+
+            assert_fact(:sma_crossover, {
+              short: short_sma,
+              long: long_sma,
+              signal: sma_crossover_signal(short_sma, long_sma)
+            })
+          end
+        end
+
+        # Volume facts
+        if vector.respond_to?(:volume) && vector.volume
+          volumes = Array(vector.volume)
+          current_volume = volumes.last
+          avg_volume = volumes.last(20).sum / 20.0 if volumes.size >= 20
+
+          if avg_volume
+            assert_fact(:volume, {
+              current: current_volume,
+              average: avg_volume,
+              level: volume_level(current_volume, avg_volume)
+            })
+          end
+        end
+
+        # Stochastic facts
+        if vector.respond_to?(:stoch_k) && vector.respond_to?(:stoch_d)
+          if vector.stoch_k && vector.stoch_d
+            k_value = Array(vector.stoch_k).last
+            d_value = Array(vector.stoch_d).last
+
+            assert_fact(:stochastic, {
+              k: k_value,
+              d: d_value,
+              zone: stoch_zone(k_value),
+              crossover: stoch_crossover(vector.stoch_k, vector.stoch_d)
+            })
+          end
+        end
+
+        # Bollinger Bands facts
+        if vector.respond_to?(:bb_upper) && vector.respond_to?(:bb_lower) && vector.respond_to?(:prices)
+          if vector.bb_upper && vector.bb_lower && vector.prices
+            current_price = Array(vector.prices).last
+            upper = Array(vector.bb_upper).last
+            lower = Array(vector.bb_lower).last
+            middle = Array(vector.bb_middle).last if vector.respond_to?(:bb_middle)
+
+            assert_fact(:bollinger, {
+              price: current_price,
+              upper: upper,
+              lower: lower,
+              middle: middle,
+              position: bb_position(current_price, lower, upper)
+            })
+          end
+        end
+      end
+
+      # Determine final trading signal from asserted signal facts
+      def determine_signal
+        # Query for signal facts
+        buy_signals = query_facts(:signal, { action: :buy })
+        sell_signals = query_facts(:signal, { action: :sell })
+
+        # Count confidence levels
+        buy_confidence = calculate_confidence(buy_signals)
+        sell_confidence = calculate_confidence(sell_signals)
+
+        # Determine signal based on confidence
+        if buy_confidence > sell_confidence && buy_confidence >= 0.5
+          @last_signal = :buy
+        elsif sell_confidence > buy_confidence && sell_confidence >= 0.5
+          @last_signal = :sell
+        else
+          @last_signal = :hold
+        end
+
+        @last_signal
+      end
+
+      # Calculate aggregate confidence from multiple signals
+      def calculate_confidence(signals)
+        return 0.0 if signals.empty?
+
+        total_confidence = signals.sum do |fact|
+          case fact.attributes[:confidence]
+          when :high then 1.0
+          when :medium then 0.6
+          when :low then 0.3
+          else 0.5
+          end
+        end
+
+        total_confidence / signals.size.to_f
+      end
+
+      # Helper methods for fact classification
+
+      def rsi_level(value)
+        return :oversold if value < 30
+        return :overbought if value > 70
+        :neutral
+      end
+
+      def macd_crossover(macd_line, signal_line)
+        return :none if macd_line.size < 2 || signal_line.size < 2
+
+        curr_macd = macd_line.last
+        prev_macd = macd_line[-2]
+        curr_signal = signal_line.last
+        prev_signal = signal_line[-2]
+
+        if prev_macd <= prev_signal && curr_macd > curr_signal
+          :bullish
+        elsif prev_macd >= prev_signal && curr_macd < curr_signal
+          :bearish
+        else
+          :none
+        end
+      end
+
+      def price_trend(prices)
+        return :neutral if prices.size < 2
+
+        first_half = prices[0...prices.size/2]
+        second_half = prices[prices.size/2..-1]
+
+        avg_first = first_half.sum / first_half.size.to_f
+        avg_second = second_half.sum / second_half.size.to_f
+
+        if avg_second > avg_first * 1.02
+          :up
+        elsif avg_second < avg_first * 0.98
+          :down
+        else
+          :neutral
+        end
+      end
+
+      def trend_strength(prices)
+        return :weak if prices.size < 10
+
+        changes = prices.each_cons(2).map { |a, b| (b - a) / a.to_f }
+        avg_change = changes.sum / changes.size.to_f
+
+        return :strong if avg_change.abs > 0.02
+        return :moderate if avg_change.abs > 0.01
+        :weak
+      end
+
+      def sma_crossover_signal(short_sma, long_sma)
+        return :bullish if short_sma > long_sma
+        return :bearish if short_sma < long_sma
+        :neutral
+      end
+
+      def volume_level(current, average)
+        ratio = current / average.to_f
+        return :high if ratio > 1.5
+        return :low if ratio < 0.5
+        :normal
+      end
+
+      def stoch_zone(value)
+        return :oversold if value < 20
+        return :overbought if value > 80
+        :neutral
+      end
+
+      def stoch_crossover(k_values, d_values)
+        return :none if k_values.size < 2 || d_values.size < 2
+
+        curr_k = k_values.last
+        prev_k = k_values[-2]
+        curr_d = d_values.last
+        prev_d = d_values[-2]
+
+        if prev_k <= prev_d && curr_k > curr_d
+          :bullish
+        elsif prev_k >= prev_d && curr_k < curr_d
+          :bearish
+        else
+          :none
+        end
+      end
+
+      def bb_position(price, lower, upper)
+        return :below if price < lower
+        return :above if price > upper
+        :inside
+      end
+
+      # Load default trading rules
+      def load_default_rules
+        return if @default_rules_loaded
+
+        # Capture kb reference for use in perform blocks
+        kb = @kb
+
+        # Rule 1: Buy on RSI oversold in uptrend
+        add_rule :buy_oversold_uptrend do
+          on :rsi, { level: :oversold }
+          on :trend, { short_term: :up }
+          perform do
+            kb.assert(:signal, { action: :buy, confidence: :high, reason: :oversold_uptrend })
+          end
+        end
+
+        # Rule 2: Sell on RSI overbought in downtrend
+        add_rule :sell_overbought_downtrend do
+          on :rsi, { level: :overbought }
+          on :trend, { short_term: :down }
+          perform do
+            kb.assert(:signal, { action: :sell, confidence: :high, reason: :overbought_downtrend })
+          end
+        end
+
+        # Rule 3: Buy on bullish MACD crossover
+        add_rule :buy_macd_bullish do
+          on :macd, { crossover: :bullish }
+          on :trend, { medium_term: :up }
+          perform do
+            kb.assert(:signal, { action: :buy, confidence: :medium, reason: :macd_crossover })
+          end
+        end
+
+        # Rule 4: Sell on bearish MACD crossover
+        add_rule :sell_macd_bearish do
+          on :macd, { crossover: :bearish }
+          on :trend, { medium_term: :down }
+          perform do
+            kb.assert(:signal, { action: :sell, confidence: :medium, reason: :macd_crossover })
+          end
+        end
+
+        # Rule 5: Buy at lower Bollinger Band
+        add_rule :buy_bb_lower do
+          on :bollinger, { position: :below }
+          on :trend, { short_term: :up }
+          perform do
+            kb.assert(:signal, { action: :buy, confidence: :medium, reason: :bollinger_bounce })
+          end
+        end
+
+        # Rule 6: Sell at upper Bollinger Band
+        add_rule :sell_bb_upper do
+          on :bollinger, { position: :above }
+          on :trend, { short_term: :down }
+          perform do
+            kb.assert(:signal, { action: :sell, confidence: :medium, reason: :bollinger_resistance })
+          end
+        end
+
+        # Rule 7: Buy on stochastic oversold crossover
+        add_rule :buy_stoch_oversold do
+          on :stochastic, { zone: :oversold, crossover: :bullish }
+          on :volume, { level: :high }
+          perform do
+            kb.assert(:signal, { action: :buy, confidence: :high, reason: :stoch_oversold_volume })
+          end
+        end
+
+        # Rule 8: Sell on stochastic overbought crossover
+        add_rule :sell_stoch_overbought do
+          on :stochastic, { zone: :overbought, crossover: :bearish }
+          on :volume, { level: :high }
+          perform do
+            kb.assert(:signal, { action: :sell, confidence: :high, reason: :stoch_overbought_volume })
+          end
+        end
+
+        # Rule 9: SMA golden cross (buy)
+        add_rule :buy_golden_cross do
+          on :sma_crossover, { signal: :bullish }
+          on :volume, { level: :high }
+          perform do
+            kb.assert(:signal, { action: :buy, confidence: :high, reason: :golden_cross })
+          end
+        end
+
+        # Rule 10: SMA death cross (sell)
+        add_rule :sell_death_cross do
+          on :sma_crossover, { signal: :bearish }
+          on :volume, { level: :high }
+          perform do
+            kb.assert(:signal, { action: :sell, confidence: :high, reason: :death_cross })
+          end
+        end
+
+        @default_rules_loaded = true
+        self
+      end
+    end
+  end
+end

data/lib/sqa/strategy/macd.rb

@@ -0,0 +1,46 @@
+# lib/sqa/strategy/macd.rb
+# frozen_string_literal: true
+
+# MACD (Moving Average Convergence Divergence) crossover strategy
+# Buy when MACD line crosses above signal line (bullish)
+# Sell when MACD line crosses below signal line (bearish)
+#
+class SQA::Strategy::MACD
+  def self.trade(vector)
+    return :hold unless vector.respond_to?(:prices) && vector.prices&.size >= 35
+
+    prices = vector.prices
+
+    # Calculate MACD using SQAI (returns macd, signal, histogram)
+    macd_line, signal_line, histogram = SQAI.macd(
+      prices,
+      fast_period: 12,
+      slow_period: 26,
+      signal_period: 9
+    )
+
+    return :hold if macd_line.nil? || signal_line.nil? || macd_line.size < 2
+
+    # Get current and previous values
+    current_macd = macd_line[-1]
+    current_signal = signal_line[-1]
+    prev_macd = macd_line[-2]
+    prev_signal = signal_line[-2]
+
+    # Bullish crossover: MACD crosses above signal
+    if prev_macd <= prev_signal && current_macd > current_signal
+      :buy
+
+    # Bearish crossover: MACD crosses below signal
+    elsif prev_macd >= prev_signal && current_macd < current_signal
+      :sell
+
+    # No crossover
+    else
+      :hold
+    end
+  rescue => e
+    warn "MACD strategy error: #{e.message}"
+    :hold
+  end
+end

data/lib/sqa/strategy/mp.rb

@@ -6,7 +6,7 @@ class SQA::Strategy::MP
 	extend SQA::Strategy::Common
 
 	def self.trade(vector)
-		mp = vector.market_profile=:mixed,
+		mp = vector.market_profile || :mixed
 
 		if :resistance == mp
 			:sell

data/lib/sqa/strategy/stochastic.rb

@@ -0,0 +1,60 @@
+# lib/sqa/strategy/stochastic.rb
+# frozen_string_literal: true
+
+# Stochastic Oscillator crossover strategy
+# Buy when %K crosses above %D in oversold territory (< 20)
+# Sell when %K crosses below %D in overbought territory (> 80)
+#
+class SQA::Strategy::Stochastic
+  def self.trade(vector)
+    return :hold unless vector.respond_to?(:prices) && vector.prices&.size >= 14
+
+    prices = vector.prices
+
+    # We need high, low, close arrays for stochastic
+    # For simplicity, use prices as close, and approximate high/low from recent range
+    # In a real scenario, you'd get actual high/low from the stock data
+    high = prices.dup
+    low = prices.dup
+    close = prices
+
+    # Calculate Stochastic using SQAI
+    # Returns fastk and fastd (or slowk and slowd depending on the function)
+    stoch_k, stoch_d = SQAI.stoch(
+      high,
+      low,
+      close,
+      fastk_period: 14,
+      slowk_period: 3,
+      slowd_period: 3
+    )
+
+    return :hold if stoch_k.nil? || stoch_d.nil? || stoch_k.size < 2
+
+    # Get current and previous values
+    current_k = stoch_k[-1]
+    current_d = stoch_d[-1]
+    prev_k = stoch_k[-2]
+    prev_d = stoch_d[-2]
+
+    # Oversold threshold
+    oversold = 20.0
+    # Overbought threshold
+    overbought = 80.0
+
+    # Buy signal: %K crosses above %D in oversold territory
+    if current_k < oversold && prev_k <= prev_d && current_k > current_d
+      :buy
+
+    # Sell signal: %K crosses below %D in overbought territory
+    elsif current_k > overbought && prev_k >= prev_d && current_k < current_d
+      :sell
+
+    else
+      :hold
+    end
+  rescue => e
+    warn "Stochastic strategy error: #{e.message}"
+    :hold
+  end
+end

data/lib/sqa/strategy/volume_breakout.rb

@@ -0,0 +1,57 @@
+# lib/sqa/strategy/volume_breakout.rb
+# frozen_string_literal: true
+
+# Volume Breakout strategy
+# Buy when price breaks above resistance with high volume
+# Sell when price breaks below support with high volume
+#
+class SQA::Strategy::VolumeBreakout
+  def self.trade(vector)
+    return :hold unless vector.respond_to?(:prices) &&
+                        vector.respond_to?(:volumes) &&
+                        vector.prices&.size >= 20 &&
+                        vector.volumes&.size >= 20
+
+    prices = vector.prices
+    volumes = vector.volumes
+
+    # Calculate moving averages
+    sma_20 = SQAI.sma(prices, period: 20)
+    return :hold if sma_20.nil?
+
+    current_price = prices.last
+    prev_price = prices[-2]
+    current_volume = volumes.last
+
+    # Calculate average volume
+    avg_volume = volumes.last(20).sum / 20.0
+
+    # High volume threshold (1.5x average)
+    volume_threshold = avg_volume * 1.5
+
+    # Get recent high and low (resistance and support) from previous prices
+    # Exclude current price to allow breakout detection
+    lookback_prices = prices[...-1].last(20)  # Last 20 prices excluding current
+    recent_high = lookback_prices.max
+    recent_low = lookback_prices.min
+
+    # Buy signal: price breaks above recent high with high volume
+    if current_price > recent_high &&
+       prev_price <= recent_high &&
+       current_volume > volume_threshold
+      :buy
+
+    # Sell signal: price breaks below recent low with high volume
+    elsif current_price < recent_low &&
+          prev_price >= recent_low &&
+          current_volume > volume_threshold
+      :sell
+
+    else
+      :hold
+    end
+  rescue => e
+    warn "VolumeBreakout strategy error: #{e.message}"
+    :hold
+  end
+end

data/lib/sqa/strategy.rb

@@ -62,4 +62,9 @@ require_relative 'strategy/mr'
 require_relative 'strategy/random'
 require_relative 'strategy/rsi'
 require_relative 'strategy/sma'
+require_relative 'strategy/bollinger_bands'
+require_relative 'strategy/macd'
+require_relative 'strategy/stochastic'
+require_relative 'strategy/volume_breakout'
+require_relative 'strategy/kbs_strategy'