ollama-client 0.2.1 → 0.2.3

data/examples/dhanhq/agents/base_agent.rb

@@ -24,8 +24,6 @@ module DhanHQ
         return low_confidence_decision(decision) if low_confidence?(decision)
 
         decision
-      rescue Ollama::Error => e
-        error_decision(e.message)
       rescue StandardError => e
         error_decision(e.message)
       end

data/examples/dhanhq/agents/orchestrator_agent.rb

@@ -30,8 +30,7 @@ module DhanHQ
 
       protected
 
-      def build_analysis_prompt(market_context:)
-        # Not used, but required by base class
+      def build_analysis_prompt(*)
         ""
       end
 

data/examples/dhanhq/agents/technical_analysis_agent.rb

@@ -69,8 +69,7 @@ module DhanHQ
 
       protected
 
-      def build_analysis_prompt(market_context:)
-        # Not used in this agent, but required by base class
+      def build_analysis_prompt(*)
         ""
       end
 
@@ -79,58 +78,72 @@ module DhanHQ
       def convert_to_ohlc(historical_data)
         return [] unless historical_data.is_a?(Hash)
 
-        # Navigate to the actual data: result -> result -> data
+        data = extract_data_payload(historical_data)
+        return [] unless data
+
+        return ohlc_from_hash(data) if data.is_a?(Hash)
+        return ohlc_from_array(data) if data.is_a?(Array)
+
+        []
+      end
+
+      def extract_data_payload(historical_data)
         outer_result = historical_data[:result] || historical_data["result"]
-        return [] unless outer_result.is_a?(Hash)
+        return nil unless outer_result.is_a?(Hash)
 
-        data = outer_result[:data] || outer_result["data"]
-        return [] unless data
+        outer_result[:data] || outer_result["data"]
+      end
 
-        # Handle DhanHQ format: {open: [...], high: [...], low: [...], close: [...], volume: [...]}
-        if data.is_a?(Hash)
-          opens = data[:open] || data["open"] || []
-          highs = data[:high] || data["high"] || []
-          lows = data[:low] || data["low"] || []
-          closes = data[:close] || data["close"] || []
-          volumes = data[:volume] || data["volume"] || []
-
-          return [] if closes.nil? || closes.empty?
-
-          # Convert parallel arrays to array of hashes
-          max_length = [opens.length, highs.length, lows.length, closes.length].max
-          return [] if max_length.zero?
-
-          ohlc_data = []
-
-          (0...max_length).each do |i|
-            ohlc_data << {
-              open: opens[i] || closes[i] || 0,
-              high: highs[i] || closes[i] || 0,
-              low: lows[i] || closes[i] || 0,
-              close: closes[i] || 0,
-              volume: volumes[i] || 0
-            }
-          end
+      def ohlc_from_hash(data)
+        series = extract_series(data)
+        return [] if series[:closes].nil? || series[:closes].empty?
 
-          return ohlc_data
-        end
+        max_length = series_lengths(series).max
+        return [] if max_length.zero?
 
-        # Handle array format: [{open, high, low, close, volume}, ...]
-        if data.is_a?(Array)
-          return data.map do |bar|
-            next nil unless bar.is_a?(Hash)
-
-            {
-              open: bar["open"] || bar[:open],
-              high: bar["high"] || bar[:high],
-              low: bar["low"] || bar[:low],
-              close: bar["close"] || bar[:close],
-              volume: bar["volume"] || bar[:volume]
-            }
-          end.compact
+        build_ohlc_rows(series, max_length)
+      end
+
+      def extract_series(data)
+        {
+          opens: data[:open] || data["open"] || [],
+          highs: data[:high] || data["high"] || [],
+          lows: data[:low] || data["low"] || [],
+          closes: data[:close] || data["close"] || [],
+          volumes: data[:volume] || data["volume"] || []
+        }
+      end
+
+      def series_lengths(series)
+        [series[:opens].length, series[:highs].length, series[:lows].length, series[:closes].length]
+      end
+
+      def build_ohlc_rows(series, max_length)
+        (0...max_length).map do |index|
+          {
+            open: series[:opens][index] || series[:closes][index] || 0,
+            high: series[:highs][index] || series[:closes][index] || 0,
+            low: series[:lows][index] || series[:closes][index] || 0,
+            close: series[:closes][index] || 0,
+            volume: series[:volumes][index] || 0
+          }
         end
+      end
 
-        []
+      def ohlc_from_array(data)
+        data.filter_map { |bar| normalize_bar(bar) }
+      end
+
+      def normalize_bar(bar)
+        return nil unless bar.is_a?(Hash)
+
+        {
+          open: bar["open"] || bar[:open],
+          high: bar["high"] || bar[:high],
+          low: bar["low"] || bar[:low],
+          close: bar["close"] || bar[:close],
+          volume: bar["volume"] || bar[:volume]
+        }
       end
 
       def interpret_analysis(symbol, analysis)
@@ -214,7 +227,7 @@ module DhanHQ
         }
       end
 
-      def build_recommendation_schema(trading_style)
+      def build_recommendation_schema(_trading_style)
         {
           "type" => "object",
           "properties" => {
@@ -223,7 +236,12 @@ module DhanHQ
             "stop_loss" => { "type" => "number" },
             "target_price" => { "type" => "number" },
             "risk_reward_ratio" => { "type" => "number" },
-            "confidence" => { "type" => "number", "minimum" => 0, "maximum" => 1 },
+            "confidence" => {
+              "type" => "number",
+              "minimum" => 0,
+              "maximum" => 1,
+              "description" => "Confidence (0.0 to 1.0)"
+            },
             "reasoning" => { "type" => "string" },
             "timeframe" => { "type" => "string" }
           }

data/examples/dhanhq/analysis/market_structure.rb

@@ -9,34 +9,8 @@ module DhanHQ
       def self.analyze_trend(highs, lows, closes)
         return { trend: :unknown, strength: 0 } if closes.nil? || closes.length < 3
 
-        # Higher highs and higher lows = Uptrend
-        # Lower highs and lower lows = Downtrend
-        recent_highs = highs.last(10) if highs
-        recent_lows = lows.last(10) if lows
-        recent_closes = closes.last(10)
-
-        higher_highs = recent_highs ? recent_highs.each_cons(2).all? { |a, b| b >= a } : false
-        higher_lows = recent_lows ? recent_lows.each_cons(2).all? { |a, b| b >= a } : false
-        lower_highs = recent_highs ? recent_highs.each_cons(2).all? { |a, b| b <= a } : false
-        lower_lows = recent_lows ? recent_lows.each_cons(2).all? { |a, b| b <= a } : false
-
-        trend = if higher_highs && higher_lows
-                  :uptrend
-                elsif lower_highs && lower_lows
-                  :downtrend
-                else
-                  :sideways
-                end
-
-        # Calculate trend strength using moving averages
-        sma_20 = DhanHQ::Indicators::TechnicalIndicators.sma(closes, 20)
-        sma_50 = DhanHQ::Indicators::TechnicalIndicators.sma(closes, 50)
-
-        strength = if sma_20.last && sma_50.last
-                     ((sma_20.last - sma_50.last) / sma_50.last * 100).abs
-                   else
-                     0
-                   end
+        trend = infer_trend(highs, lows)
+        strength = moving_average_strength(closes)
 
         { trend: trend, strength: strength.round(2) }
       end
@@ -117,6 +91,48 @@ module DhanHQ
 
         { broken: broken, direction: direction, current_trend: trend[:trend] }
       end
+
+      def self.infer_trend(highs, lows)
+        recent_highs = extract_recent(highs)
+        recent_lows = extract_recent(lows)
+
+        higher_highs = non_decreasing?(recent_highs)
+        higher_lows = non_decreasing?(recent_lows)
+        lower_highs = non_increasing?(recent_highs)
+        lower_lows = non_increasing?(recent_lows)
+
+        return :uptrend if higher_highs && higher_lows
+        return :downtrend if lower_highs && lower_lows
+
+        :sideways
+      end
+
+      def self.moving_average_strength(closes)
+        short_average = DhanHQ::Indicators::TechnicalIndicators.sma(closes, 20)
+        long_average = DhanHQ::Indicators::TechnicalIndicators.sma(closes, 50)
+
+        return 0 unless short_average.last && long_average.last
+
+        ((short_average.last - long_average.last) / long_average.last * 100).abs
+      end
+
+      def self.extract_recent(series, lookback = 10)
+        return nil unless series
+
+        series.last(lookback)
+      end
+
+      def self.non_decreasing?(series)
+        return false unless series
+
+        series.each_cons(2).all? { |first, second| second >= first }
+      end
+
+      def self.non_increasing?(series)
+        return false unless series
+
+        series.each_cons(2).all? { |first, second| second <= first }
+      end
     end
   end
 end

data/examples/dhanhq/analysis/pattern_recognizer.rb

@@ -11,35 +11,31 @@ module DhanHQ
         patterns = []
 
         (2...closes.length).each do |i|
-          o1, h1, l1, c1 = opens[i - 2], highs[i - 2], lows[i - 2], closes[i - 2]
-          o2, h2, l2, c2 = opens[i - 1], highs[i - 1], lows[i - 1], closes[i - 1]
-          o3, h3, l3, c3 = opens[i], highs[i], lows[i], closes[i]
+          first_candle = build_candle(opens, highs, lows, closes, i - 2)
+          second_candle = build_candle(opens, highs, lows, closes, i - 1)
+          third_candle = build_candle(opens, highs, lows, closes, i)
 
           # Engulfing patterns
-          if bullish_engulfing?(o1, c1, o2, c2)
+          if bullish_engulfing?(first_candle, second_candle)
             patterns << { type: :bullish_engulfing, index: i, strength: :medium }
           end
 
-          if bearish_engulfing?(o1, c1, o2, c2)
+          if bearish_engulfing?(first_candle, second_candle)
             patterns << { type: :bearish_engulfing, index: i, strength: :medium }
           end
 
           # Hammer pattern
-          if hammer?(o2, h2, l2, c2)
-            patterns << { type: :hammer, index: i - 1, strength: :medium }
-          end
+          patterns << { type: :hammer, index: i - 1, strength: :medium } if hammer?(second_candle)
 
           # Shooting star
-          if shooting_star?(o2, h2, l2, c2)
-            patterns << { type: :shooting_star, index: i - 1, strength: :medium }
-          end
+          patterns << { type: :shooting_star, index: i - 1, strength: :medium } if shooting_star?(second_candle)
 
           # Three white soldiers / three black crows
-          if three_white_soldiers?(c1, c2, c3, o1, o2, o3)
+          if three_white_soldiers?([first_candle, second_candle, third_candle])
             patterns << { type: :three_white_soldiers, index: i, strength: :strong }
           end
 
-          if three_black_crows?(c1, c2, c3, o1, o2, o3)
+          if three_black_crows?([first_candle, second_candle, third_candle])
             patterns << { type: :three_black_crows, index: i, strength: :strong }
           end
         end
@@ -65,46 +61,62 @@ module DhanHQ
         patterns
       end
 
-      private
+      def self.bullish_engulfing?(first_candle, second_candle)
+        first_open = first_candle[:open]
+        first_close = first_candle[:close]
+        second_open = second_candle[:open]
+        second_close = second_candle[:close]
 
-      def self.bullish_engulfing?(o1, c1, o2, c2)
-        c1 < o1 && # First candle is bearish
-          c2 > o2 && # Second candle is bullish
-          o2 < c1 && # Second opens below first close
-          c2 > o1 # Second closes above first open
+        first_close < first_open && # First candle is bearish
+          second_close > second_open && # Second candle is bullish
+          second_open < first_close && # Second opens below first close
+          second_close > first_open # Second closes above first open
       end
 
-      def self.bearish_engulfing?(o1, c1, o2, c2)
-        c1 > o1 && # First candle is bullish
-          c2 < o2 && # Second candle is bearish
-          o2 > c1 && # Second opens above first close
-          c2 < o1 # Second closes below first open
+      def self.bearish_engulfing?(first_candle, second_candle)
+        first_open = first_candle[:open]
+        first_close = first_candle[:close]
+        second_open = second_candle[:open]
+        second_close = second_candle[:close]
+
+        first_close > first_open && # First candle is bullish
+          second_close < second_open && # Second candle is bearish
+          second_open > first_close && # Second opens above first close
+          second_close < first_open # Second closes below first open
       end
 
-      def self.hammer?(open, high, low, close)
-        body = (close - open).abs
-        lower_shadow = [open, close].min - low
-        upper_shadow = high - [open, close].max
+      def self.hammer?(candle)
+        body = (candle[:close] - candle[:open]).abs
+        lower_shadow = [candle[:open], candle[:close]].min - candle[:low]
+        upper_shadow = candle[:high] - [candle[:open], candle[:close]].max
 
         lower_shadow > body * 2 && upper_shadow < body * 0.5
       end
 
-      def self.shooting_star?(open, high, low, close)
-        body = (close - open).abs
-        upper_shadow = high - [open, close].max
-        lower_shadow = [open, close].min - low
+      def self.shooting_star?(candle)
+        body = (candle[:close] - candle[:open]).abs
+        upper_shadow = candle[:high] - [candle[:open], candle[:close]].max
+        lower_shadow = [candle[:open], candle[:close]].min - candle[:low]
 
         upper_shadow > body * 2 && lower_shadow < body * 0.5
       end
 
-      def self.three_white_soldiers?(c1, c2, c3, o1, o2, o3)
-        c1 > o1 && c2 > o2 && c3 > o3 && # All bullish
-          c2 > c1 && c3 > c2 # Each closes higher
+      def self.three_white_soldiers?(candles)
+        first, second, third = candles
+        first[:close] > first[:open] &&
+          second[:close] > second[:open] &&
+          third[:close] > third[:open] && # All bullish
+          second[:close] > first[:close] &&
+          third[:close] > second[:close] # Each closes higher
       end
 
-      def self.three_black_crows?(c1, c2, c3, o1, o2, o3)
-        c1 < o1 && c2 < o2 && c3 < o3 && # All bearish
-          c2 < c1 && c3 < c2 # Each closes lower
+      def self.three_black_crows?(candles)
+        first, second, third = candles
+        first[:close] < first[:open] &&
+          second[:close] < second[:open] &&
+          third[:close] < third[:open] && # All bearish
+          second[:close] < first[:close] &&
+          third[:close] < second[:close] # Each closes lower
       end
 
       def self.head_and_shoulders?(highs, _lows)
@@ -123,8 +135,8 @@ module DhanHQ
         head[:value] > left_shoulder[:value] && head[:value] > right_shoulder[:value]
       end
 
-      def self.double_top_bottom?(highs, lows, closes)
-        return nil if highs.length < 20
+      def self.double_top_bottom?(highs, lows, _closes)
+        return false if highs.length < 20
 
         # Double top: two similar highs with dip in between
         peaks = find_peaks(highs)
@@ -148,15 +160,13 @@ module DhanHQ
           end
         end
 
-        nil
+        false
       end
 
       def self.find_peaks(values)
         peaks = []
         (1...(values.length - 1)).each do |i|
-          if values[i] > values[i - 1] && values[i] > values[i + 1]
-            peaks << { index: i, value: values[i] }
-          end
+          peaks << { index: i, value: values[i] } if values[i] > values[i - 1] && values[i] > values[i + 1]
         end
         peaks
       end
@@ -164,12 +174,19 @@ module DhanHQ
       def self.find_troughs(values)
         troughs = []
         (1...(values.length - 1)).each do |i|
-          if values[i] < values[i - 1] && values[i] < values[i + 1]
-            troughs << { index: i, value: values[i] }
-          end
+          troughs << { index: i, value: values[i] } if values[i] < values[i - 1] && values[i] < values[i + 1]
         end
         troughs
       end
+
+      def self.build_candle(opens, highs, lows, closes, index)
+        {
+          open: opens[index],
+          high: highs[index],
+          low: lows[index],
+          close: closes[index]
+        }
+      end
     end
   end
 end

data/examples/dhanhq/analysis/trend_analyzer.rb

@@ -20,9 +20,9 @@ module DhanHQ
         return {} if closes.nil? || closes.empty?
 
         # Technical indicators
-        sma_20 = DhanHQ::Indicators::TechnicalIndicators.sma(closes, 20)
-        sma_50 = DhanHQ::Indicators::TechnicalIndicators.sma(closes, 50)
-        ema_12 = DhanHQ::Indicators::TechnicalIndicators.ema(closes, 12)
+        sma20 = DhanHQ::Indicators::TechnicalIndicators.sma(closes, 20)
+        sma50 = DhanHQ::Indicators::TechnicalIndicators.sma(closes, 50)
+        ema12 = DhanHQ::Indicators::TechnicalIndicators.ema(closes, 12)
         rsi = DhanHQ::Indicators::TechnicalIndicators.rsi(closes, 14)
         macd = DhanHQ::Indicators::TechnicalIndicators.macd(closes)
 
@@ -43,9 +43,9 @@ module DhanHQ
           trend: trend,
           structure_break: structure_break,
           indicators: {
-            sma_20: sma_20.last,
-            sma_50: sma_50.last,
-            ema_12: ema_12.last,
+            sma20: sma20.last,
+            sma50: sma50.last,
+            ema12: ema12.last,
             rsi: rsi.last,
             macd: macd[:macd].last,
             macd_signal: macd[:signal].last,
@@ -64,8 +64,6 @@ module DhanHQ
         }
       end
 
-      private
-
       def self.extract_closes(data)
         data.map { |d| d[:close] || d["close"] || d["c"] || d[:c] }.compact
       end