ollama-client 0.2.5 → 0.2.6

data/examples/dhanhq/agents/technical_analysis_agent.rb

@@ -1,252 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base_agent"
-require_relative "../schemas/agent_schemas"
-require_relative "../analysis/trend_analyzer"
-require_relative "../services/data_service"
-
-module DhanHQ
-  module Agents
-    # Agent for technical analysis and trading recommendations
-    class TechnicalAnalysisAgent < BaseAgent
-      def initialize(ollama_client:)
-        super(ollama_client: ollama_client, schema: build_analysis_schema)
-        @data_service = Services::DataService.new
-      end
-
-      def analyze_symbol(symbol:, exchange_segment:)
-        # Fetch historical data
-        result = @data_service.execute(
-          action: "get_historical_data",
-          params: {
-            "symbol" => symbol,
-            "exchange_segment" => exchange_segment,
-            "from_date" => (Date.today - 60).strftime("%Y-%m-%d"),
-            "to_date" => Date.today.strftime("%Y-%m-%d")
-          }
-        )
-
-        return { error: "Failed to fetch data: #{result[:error] || 'Unknown error'}" } if result[:error]
-        return { error: "No result data returned" } unless result[:result]
-
-        # Convert to OHLC format
-        ohlc_data = convert_to_ohlc(result)
-
-        if ohlc_data.nil? || ohlc_data.empty?
-          return { error: "Failed to convert data to OHLC format (empty or invalid data)" }
-        end
-
-        # Perform technical analysis
-        analysis = Analysis::TrendAnalyzer.analyze(ohlc_data)
-
-        return { error: "Analysis returned empty result" } if analysis.nil? || analysis.empty?
-
-        # Get LLM interpretation
-        interpretation = interpret_analysis(symbol, analysis)
-
-        {
-          symbol: symbol,
-          exchange_segment: exchange_segment,
-          analysis: analysis,
-          interpretation: interpretation
-        }
-      end
-
-      def generate_recommendation(analysis_result, trading_style: :swing)
-        market_context = build_market_context(analysis_result)
-
-        prompt = build_recommendation_prompt(market_context, trading_style)
-
-        begin
-          @ollama_client.generate(
-            prompt: prompt,
-            schema: build_recommendation_schema(trading_style)
-          )
-        rescue Ollama::Error => e
-          { error: e.message }
-        end
-      end
-
-      protected
-
-      def build_analysis_prompt(*)
-        ""
-      end
-
-      private
-
-      def convert_to_ohlc(historical_data)
-        return [] unless historical_data.is_a?(Hash)
-
-        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 nil unless outer_result.is_a?(Hash)
-
-        outer_result[:data] || outer_result["data"]
-      end
-
-      def ohlc_from_hash(data)
-        series = extract_series(data)
-        return [] if series[:closes].nil? || series[:closes].empty?
-
-        max_length = series_lengths(series).max
-        return [] if max_length.zero?
-
-        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)
-        context = <<~CONTEXT
-          Technical Analysis for #{symbol}:
-
-          Trend: #{analysis[:trend][:trend]} (Strength: #{analysis[:trend][:strength]}%)
-          RSI: #{analysis[:indicators][:rsi]&.round(2) || 'N/A'}
-          MACD: #{analysis[:indicators][:macd]&.round(2) || 'N/A'}
-          Current Price: #{analysis[:current_price]}
-
-          Patterns: #{analysis[:patterns][:candlestick].length} candlestick patterns detected
-          Structure Break: #{analysis[:structure_break][:broken] ? 'Yes' : 'No'}
-        CONTEXT
-
-        begin
-          @ollama_client.generate(
-            prompt: "Interpret this technical analysis: #{context}",
-            schema: {
-              "type" => "object",
-              "properties" => {
-                "summary" => { "type" => "string" },
-                "sentiment" => { "type" => "string", "enum" => ["bullish", "bearish", "neutral"] },
-                "key_levels" => { "type" => "array", "items" => { "type" => "number" } }
-              }
-            }
-          )
-        rescue Ollama::Error
-          { summary: "Analysis completed", sentiment: "neutral" }
-        end
-      end
-
-      def build_market_context(analysis_result)
-        analysis = analysis_result[:analysis]
-        <<~CONTEXT
-          Symbol: #{analysis_result[:symbol]}
-          Current Price: #{analysis[:current_price]}
-          Trend: #{analysis[:trend][:trend]} (#{analysis[:trend][:strength]}% strength)
-          RSI: #{analysis[:indicators][:rsi]&.round(2) || 'N/A'}
-          MACD: #{analysis[:indicators][:macd]&.round(2) || 'N/A'} (Signal: #{analysis[:indicators][:macd_signal]&.round(2) || 'N/A'})
-          Structure Break: #{analysis[:structure_break][:broken] ? 'Yes' : 'No'}
-          Patterns: #{analysis[:patterns][:candlestick].length} recent patterns
-        CONTEXT
-      end
-
-      def build_recommendation_prompt(market_context, trading_style)
-        style_instructions = case trading_style
-                             when :intraday
-                               "Focus on intraday moves, entry/exit within same day, use tight stops"
-                             when :swing
-                               "Focus on swing trades, 2-7 day holds, use wider stops"
-                             when :options
-                               "Focus on options buying, identify high probability setups, consider IV"
-                             else
-                               "General trading recommendations"
-                             end
-
-        <<~PROMPT
-          Analyze the following technical analysis and provide trading recommendations:
-
-          #{market_context}
-
-          Trading Style: #{style_instructions}
-
-          Provide:
-          - Entry strategy
-          - Stop loss levels
-          - Target levels
-          - Risk/reward ratio
-          - Confidence level
-        PROMPT
-      end
-
-      def build_analysis_schema
-        {
-          "type" => "object",
-          "properties" => {
-            "action" => { "type" => "string" },
-            "reasoning" => { "type" => "string" }
-          }
-        }
-      end
-
-      def build_recommendation_schema(_trading_style)
-        {
-          "type" => "object",
-          "properties" => {
-            "recommendation" => { "type" => "string", "enum" => ["buy", "sell", "hold", "avoid"] },
-            "entry_price" => { "type" => "number" },
-            "stop_loss" => { "type" => "number" },
-            "target_price" => { "type" => "number" },
-            "risk_reward_ratio" => { "type" => "number" },
-            "confidence" => {
-              "type" => "number",
-              "minimum" => 0,
-              "maximum" => 1,
-              "description" => "Confidence (0.0 to 1.0)"
-            },
-            "reasoning" => { "type" => "string" },
-            "timeframe" => { "type" => "string" }
-          }
-        }
-      end
-    end
-  end
-end

data/examples/dhanhq/agents/trading_agent.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base_agent"
-require_relative "../schemas/agent_schemas"
-require_relative "../services/trading_service"
-require_relative "../utils/trading_parameter_normalizer"
-
-module DhanHQ
-  module Agents
-    # Agent for trading order decisions using LLM
-    class TradingAgent < BaseAgent
-      def initialize(ollama_client:)
-        super(ollama_client: ollama_client, schema: DhanHQ::Schemas::AgentSchemas::TRADING_AGENT_SCHEMA)
-        @trading_service = DhanHQ::Services::TradingService.new
-      end
-
-      def execute_decision(decision)
-        action = decision["action"]
-        raw_params = decision["parameters"] || {}
-        params = DhanHQ::Utils::TradingParameterNormalizer.normalize(raw_params)
-
-        # Warn if price seems suspiciously low
-        if params["price"] && params["price"] < 10
-          puts "⚠️  Warning: Price value (#{params['price']}) seems unusually low. Please verify."
-        end
-
-        @trading_service.execute(action: action, params: params)
-      end
-
-      protected
-
-      def build_analysis_prompt(market_context:)
-        <<~PROMPT
-          Analyze the following market situation and decide the best trading action:
-
-          Market Context:
-          #{market_context}
-
-          Available Actions (TRADING ONLY):
-          - place_order: Build order parameters (requires: security_id as string, quantity, price, transaction_type, exchange_segment)
-          - place_super_order: Build super order parameters with SL/TP (requires: security_id as string, quantity, price, target_price, stop_loss_price, exchange_segment)
-          - cancel_order: Build cancel parameters (requires: order_id)
-          - no_action: Take no action if market conditions are unclear or risky
-
-          CRITICAL PARAMETER EXTRACTION RULES:
-          1. security_id must be a STRING (e.g., "13" not 13)
-          2. price, target_price, stop_loss_price must be NUMERIC values (numbers, not strings)
-          3. When extracting prices from context:
-             - "2,850" means 2850 (remove commas, convert to number)
-             - "1,483.2" means 1483.2 (remove commas, keep decimal)
-             - Use the EXACT numeric value from context, do NOT approximate
-             - If context says "Entry price: 2,850", use 2850 (not 2, not 285, not any approximation)
-          4. quantity must be a positive integer
-          5. Valid exchange_segment values: NSE_EQ, NSE_FNO, NSE_CURRENCY, BSE_EQ, BSE_FNO, BSE_CURRENCY, MCX_COMM, IDX_I
-
-          CRITICAL: The parameters object must contain ONLY valid parameter values (strings, numbers, etc.).
-          DO NOT include comments, instructions, explanations, or descriptions in the parameters object.
-          Parameters should be clean JSON values only.
-
-          Example of CORRECT parameter extraction:
-          Context: "Entry price: 2,850, Quantity: 100, security_id='1333'"
-          Correct parameters: {"security_id": "1333", "quantity": 100, "price": 2850}
-          WRONG: {"price": 2, "description": "approximation"} ❌
-          WRONG: {"price": "2850"} ❌ (should be number, not string)
-
-          Decision Criteria:
-          - Only take actions with confidence > 0.6
-          - Consider risk management (use super orders for risky trades)
-          - Ensure all required parameters are provided with EXACT values from context
-          - Be conservative - prefer no_action if uncertain
-
-          Respond with a JSON object containing:
-          - action: one of the available trading actions
-          - reasoning: why this action was chosen (put explanations here, NOT in parameters)
-          - confidence: your confidence level (0-1)
-          - parameters: object with ONLY required parameter values (no comments, no explanations, exact numeric values)
-        PROMPT
-      end
-    end
-  end
-end

data/examples/dhanhq/analysis/market_structure.rb

@@ -1,138 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../indicators/technical_indicators"
-
-module DhanHQ
-  module Analysis
-    # Market Structure Analysis (SMC - Smart Money Concepts)
-    class MarketStructure
-      def self.analyze_trend(highs, lows, closes)
-        return { trend: :unknown, strength: 0 } if closes.nil? || closes.length < 3
-
-        trend = infer_trend(highs, lows)
-        strength = moving_average_strength(closes)
-
-        { trend: trend, strength: strength.round(2) }
-      end
-
-      # Smart Money Concepts: Order Blocks
-      def self.find_order_blocks(highs, lows, closes, volumes)
-        return [] if closes.nil? || closes.length < 5
-
-        order_blocks = []
-
-        (4...closes.length).each do |i|
-          # Bullish order block: strong move up after consolidation
-          if closes[i] > closes[i - 1] && closes[i - 1] > closes[i - 2] &&
-             volumes[i] > volumes[i - 1] * 1.5
-            order_blocks << {
-              type: :bullish,
-              price_range: [lows[i - 2], highs[i]],
-              timestamp: i,
-              volume: volumes[i]
-            }
-          end
-
-          # Bearish order block: strong move down after consolidation
-          next unless closes[i] < closes[i - 1] && closes[i - 1] < closes[i - 2] &&
-                      volumes[i] > volumes[i - 1] * 1.5
-
-          order_blocks << {
-            type: :bearish,
-            price_range: [lows[i], highs[i - 2]],
-            timestamp: i,
-            volume: volumes[i]
-          }
-        end
-
-        order_blocks
-      end
-
-      # Liquidity Zones (SMC)
-      def self.find_liquidity_zones(highs, lows, closes, lookback = 50)
-        return { buy_side: [], sell_side: [] } if closes.nil? || closes.length < lookback
-
-        # Buy-side liquidity: areas where stops are likely (below support)
-        # Sell-side liquidity: areas where stops are likely (above resistance)
-
-        support_resistance = DhanHQ::Indicators::TechnicalIndicators.support_resistance(
-          highs, lows, closes, lookback
-        )
-
-        current_price = closes.last
-        buy_side = support_resistance[:support].select { |s| s[:price] < current_price }
-        sell_side = support_resistance[:resistance].select { |r| r[:price] > current_price }
-
-        { buy_side: buy_side, sell_side: sell_side }
-      end
-
-      # Market Structure Break (Change in trend)
-      def self.detect_structure_break(highs, lows, closes)
-        return { broken: false, direction: nil } if closes.nil? || closes.length < 10
-
-        trend = analyze_trend(highs, lows, closes)
-
-        # Structure break: previous high/low is broken
-        recent_high = highs ? highs.last(5).max : closes.last(5).max
-        recent_low = lows ? lows.last(5).min : closes.last(5).min
-        previous_high = highs ? highs[-10..-6].max : closes[-10..-6].max
-        previous_low = lows ? lows[-10..-6].min : closes[-10..-6].min
-
-        broken = false
-        direction = nil
-
-        if recent_high > previous_high && trend[:trend] != :uptrend
-          broken = true
-          direction = :bullish_break
-        elsif recent_low < previous_low && trend[:trend] != :downtrend
-          broken = true
-          direction = :bearish_break
-        end
-
-        { 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

@@ -1,192 +0,0 @@
-# frozen_string_literal: true
-
-module DhanHQ
-  module Analysis
-    # Candlestick and chart pattern recognition
-    class PatternRecognizer
-      # Detect common candlestick patterns
-      def self.detect_candlestick_patterns(opens, highs, lows, closes)
-        return [] if closes.nil? || closes.length < 3
-
-        patterns = []
-
-        (2...closes.length).each do |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?(first_candle, second_candle)
-            patterns << { type: :bullish_engulfing, index: i, strength: :medium }
-          end
-
-          if bearish_engulfing?(first_candle, second_candle)
-            patterns << { type: :bearish_engulfing, index: i, strength: :medium }
-          end
-
-          # Hammer pattern
-          patterns << { type: :hammer, index: i - 1, strength: :medium } if hammer?(second_candle)
-
-          # Shooting star
-          patterns << { type: :shooting_star, index: i - 1, strength: :medium } if shooting_star?(second_candle)
-
-          # Three white soldiers / three black crows
-          if three_white_soldiers?([first_candle, second_candle, third_candle])
-            patterns << { type: :three_white_soldiers, index: i, strength: :strong }
-          end
-
-          if three_black_crows?([first_candle, second_candle, third_candle])
-            patterns << { type: :three_black_crows, index: i, strength: :strong }
-          end
-        end
-
-        patterns
-      end
-
-      # Detect chart patterns
-      def self.detect_chart_patterns(highs, lows, closes)
-        return [] if closes.nil? || closes.length < 20
-
-        patterns = []
-
-        # Head and Shoulders (simplified)
-        if head_and_shoulders?(highs, lows)
-          patterns << { type: :head_and_shoulders, strength: :strong, direction: :bearish }
-        end
-
-        # Double Top/Bottom
-        double_pattern = double_top_bottom?(highs, lows, closes)
-        patterns << double_pattern if double_pattern
-
-        patterns
-      end
-
-      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]
-
-        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?(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?(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?(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?(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?(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)
-        return false if highs.length < 20
-
-        # Simplified: look for three peaks with middle one highest
-        peaks = find_peaks(highs)
-        return false if peaks.length < 3
-
-        # Check if middle peak is highest (head)
-        middle_idx = peaks.length / 2
-        head = peaks[middle_idx]
-        left_shoulder = peaks[middle_idx - 1]
-        right_shoulder = peaks[middle_idx + 1]
-
-        head[:value] > left_shoulder[:value] && head[:value] > right_shoulder[:value]
-      end
-
-      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)
-        troughs = find_troughs(lows)
-
-        if peaks.length >= 2
-          peak1 = peaks[-2]
-          peak2 = peaks[-1]
-          # Check if peaks are similar (within 2%)
-          if (peak1[:value] - peak2[:value]).abs / peak1[:value] < 0.02
-            return { type: :double_top, strength: :medium, direction: :bearish }
-          end
-        end
-
-        if troughs.length >= 2
-          trough1 = troughs[-2]
-          trough2 = troughs[-1]
-          # Check if troughs are similar
-          if (trough1[:value] - trough2[:value]).abs / trough1[:value] < 0.02
-            return { type: :double_bottom, strength: :medium, direction: :bullish }
-          end
-        end
-
-        false
-      end
-
-      def self.find_peaks(values)
-        peaks = []
-        (1...(values.length - 1)).each do |i|
-          peaks << { index: i, value: values[i] } if values[i] > values[i - 1] && values[i] > values[i + 1]
-        end
-        peaks
-      end
-
-      def self.find_troughs(values)
-        troughs = []
-        (1...(values.length - 1)).each do |i|
-          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