DhanHQ 3.0.1 → 3.1.0

data/lib/DhanHQ/skills/builtin/straddle.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module DhanHQ
+  module Skills
+    module Builtin
+      # Skill to build a long straddle (buy ATM call + buy ATM put).
+      #
+      # Steps: find instrument → spot price → option chain →
+      # select ATM strikes → build intent.
+      #
+      # @example
+      #   result = DhanHQ::Skills::Registry.call("straddle",
+      #     symbol: "NIFTY",
+      #     expiry: "2026-01-30",
+      #     quantity: 25
+      #   )
+      #
+      class Straddle < Base
+        risk "trade_adjacent_read"
+        scope "orders:read"
+        description "Build a long straddle: buy ATM call + buy ATM put at the same strike."
+
+        param :symbol, type: :string, required: true
+        param :expiry, type: :string, required: true
+        param :quantity, type: :integer, default: 25
+        param :stop_loss, type: :number, default: 300
+        param :target, type: :number, default: 600
+
+        step :find_instrument, priority: 1
+        step :get_spot_price, priority: 2
+        step :get_option_chain, priority: 3
+        step :select_atm_strikes, priority: 4
+        step :build_intent, priority: 5
+
+        def find_instrument(ctx)
+          ctx[:instrument] = DhanHQ::Models::Instrument.find(DhanHQ::Constants::ExchangeSegment::IDX_I, ctx[:symbol])
+          ctx
+        end
+
+        def get_spot_price(ctx)
+          ctx[:spot_price] = ctx[:instrument].ltp
+          ctx
+        end
+
+        def get_option_chain(ctx)
+          ctx[:chain] = ctx[:instrument].option_chain(expiry: ctx[:expiry])
+          ctx
+        end
+
+        def select_atm_strikes(ctx)
+          spot = ctx[:spot_price].to_f
+          chain = ctx[:chain]
+
+          atm = nearest_strike(chain, spot)
+          raise ArgumentError, "Could not find ATM strike" unless atm
+
+          ctx[:atm_strike] = atm[:strike]
+          ctx[:ce_security_id] = leg_security_id(atm, "CE")
+          ctx[:pe_security_id] = leg_security_id(atm, "PE")
+          ctx[:ce_premium] = leg_premium(atm, "CE")
+          ctx[:pe_premium] = leg_premium(atm, "PE")
+          ctx[:total_premium] = ctx[:ce_premium].to_f + ctx[:pe_premium].to_f
+          ctx
+        end
+
+        def build_intent(ctx)
+          ctx[:intent] = {
+            trade_type: "STRADDLE",
+            symbol: ctx[:symbol],
+            expiry: ctx[:expiry],
+            quantity: ctx[:quantity],
+            legs: [
+              { action: DhanHQ::Constants::TransactionType::BUY, option_type: "CE", strike: ctx[:atm_strike], security_id: ctx[:ce_security_id], premium: ctx[:ce_premium] },
+              { action: DhanHQ::Constants::TransactionType::BUY, option_type: "PE", strike: ctx[:atm_strike], security_id: ctx[:pe_security_id], premium: ctx[:pe_premium] }
+            ],
+            total_premium: ctx[:total_premium],
+            break_even_upside: ctx[:atm_strike].to_f + ctx[:total_premium],
+            break_even_downside: ctx[:atm_strike].to_f - ctx[:total_premium],
+            stop_loss: ctx[:stop_loss],
+            target: ctx[:target],
+            note: "Long straddle prepared. Await human confirmation."
+          }
+          ctx
+        end
+      end
+    end
+  end
+end

data/lib/DhanHQ/skills/builtin/strangle.rb

@@ -16,6 +16,10 @@ module DhanHQ
       #   )
       #
       class Strangle < Base
+        risk "trade_adjacent_read"
+        scope "orders:read"
+        description "Build a long strangle: buy OTM call + buy OTM put around the current spot price."
+
         param :symbol, type: :string, required: true
         param :expiry, type: :string, required: true
         param :quantity, type: :integer, default: 50
@@ -35,8 +39,7 @@ module DhanHQ
         end
 
         def get_spot_price(ctx)
-          ltp = ctx[:instrument].ltp
-          ctx[:spot_price] = ltp[:ltp] || ltp["ltp"]
+          ctx[:spot_price] = ctx[:instrument].ltp
           ctx
         end
 
@@ -50,24 +53,21 @@ module DhanHQ
           chain = ctx[:chain]
           offset = ctx[:offset_pct] / 100.0
 
-          ce_options = chain.select { |o| (o[:option_type] || o["optionType"]) == "CE" }
-          pe_options = chain.select { |o| (o[:option_type] || o["optionType"]) == "PE" }
-
           ce_strike = spot * (1 + offset)
           pe_strike = spot * (1 - offset)
 
-          long_ce = ce_options.min_by { |o| ((o[:strike] || o["strike"]).to_f - ce_strike).abs }
-          long_pe = pe_options.min_by { |o| ((o[:strike] || o["strike"]).to_f - pe_strike).abs }
+          long_ce = nearest_strike(chain, ce_strike)
+          long_pe = nearest_strike(chain, pe_strike)
 
           raise ArgumentError, "Could not find suitable CE strike near #{ce_strike}" unless long_ce
           raise ArgumentError, "Could not find suitable PE strike near #{pe_strike}" unless long_pe
 
-          ctx[:ce_strike] = long_ce[:strike] || long_ce["strike"]
-          ctx[:pe_strike] = long_pe[:strike] || long_pe["strike"]
-          ctx[:ce_security_id] = long_ce[:security_id] || long_ce["securityId"]
-          ctx[:pe_security_id] = long_pe[:security_id] || long_pe["securityId"]
-          ctx[:ce_premium] = long_ce[:last_price] || long_ce["lastPrice"] || long_ce[:ltp]
-          ctx[:pe_premium] = long_pe[:last_price] || long_pe["lastPrice"] || long_pe[:ltp]
+          ctx[:ce_strike] = long_ce[:strike]
+          ctx[:pe_strike] = long_pe[:strike]
+          ctx[:ce_security_id] = leg_security_id(long_ce, "CE")
+          ctx[:pe_security_id] = leg_security_id(long_pe, "PE")
+          ctx[:ce_premium] = leg_premium(long_ce, "CE")
+          ctx[:pe_premium] = leg_premium(long_pe, "PE")
           ctx
         end
 

data/lib/DhanHQ/version.rb

@@ -2,5 +2,5 @@
 
 module DhanHQ
   # Semantic version of the DhanHQ client gem.
-  VERSION = "3.0.1"
+  VERSION = "3.1.0"
 end

data/lib/dhan_hq.rb

@@ -53,6 +53,9 @@ module DhanHQ
   require_relative "DhanHQ/risk/checks/quantity"
   require_relative "DhanHQ/risk/checks/market_hours"
   require_relative "DhanHQ/risk/checks/options"
+  require_relative "DhanHQ/risk/checks/position_limits"
+  require_relative "DhanHQ/risk/checks/concentration"
+  require_relative "DhanHQ/risk/checks/max_loss"
   require_relative "DhanHQ/risk/pipeline"
 
   # Skills layer: multi-step trading workflows
@@ -65,6 +68,7 @@ module DhanHQ
   require_relative "DhanHQ/skills/builtin/square_off_position"
   require_relative "DhanHQ/skills/builtin/iron_condor"
   require_relative "DhanHQ/skills/builtin/strangle"
+  require_relative "DhanHQ/skills/builtin/market_data_summarizer"
   DhanHQ::Skills::Registry.load_builtins
 
   class Error < StandardError; end
@@ -186,6 +190,49 @@ module DhanHQ
       configuration
     end
 
+    # Configures the DhanHQ client by fetching credentials from a dashboard API.
+    #
+    # @param bearer_token [String] Secret dashboard token (e.g. YOUR_DASHBOARD_TOKEN)
+    # @param url [String] The full URL of the dashboard API
+    # @return [DhanHQ::Configuration] The configured configuration
+    # @raise [DhanHQ::TokenEndpointError] On HTTP error or missing credentials
+    def configure_from_dashboard(bearer_token:, url: "http://localhost:3011/api/dhan_access_token")
+      raise DhanHQ::TokenEndpointError, "bearer_token is required" if bearer_token.to_s.empty?
+
+      conn = ::Faraday.new(url: url) do |c|
+        c.request :url_encoded
+        c.adapter ::Faraday.default_adapter
+      end
+
+      response = conn.get("") do |req|
+        req.headers["Authorization"] = "Bearer #{bearer_token}"
+        req.headers["Accept"] = "application/json"
+      end
+
+      unless response.success?
+        body = parse_json_body(response.body)
+        msg = body["error"] || body["message"] || body["errorMessage"] || response.body.to_s
+        raise DhanHQ::TokenEndpointError, "Dashboard returned #{response.status}: #{msg}"
+      end
+
+      data = parse_json_body(response.body)
+      data = data.transform_keys(&:to_s) if data.is_a?(Hash)
+
+      access_token = data["access_token"] || data["accessToken"] || data["dhan_access_token"] || data["dhanaccesstoken"]
+      client_id = data["client_id"] || data["clientId"] || data["dhan_client_id"] || data["dhanClientId"]
+      client_id ||= self.configuration&.client_id || ENV.fetch("DHAN_CLIENT_ID", nil)
+
+      raise DhanHQ::TokenEndpointError, "Dashboard response missing access_token (tried access_token, dhan_access_token, dhanaccesstoken)" if access_token.to_s.empty?
+      raise DhanHQ::TokenEndpointError, "Dashboard response missing client_id, and no fallback client_id was found in config or ENV['DHAN_CLIENT_ID']" if client_id.to_s.empty?
+
+      self.configuration ||= Configuration.new
+      configuration.access_token = access_token.to_s
+      configuration.client_id = client_id.to_s
+      dhan_base = data["base_url"] || data["baseUrl"]
+      configuration.base_url = dhan_base.to_s if dhan_base.to_s != ""
+      configuration
+    end
+
     # @param body [String, Hash] Raw response body
     # @return [Hash] Parsed hash; empty hash on parse failure or empty string
     def parse_json_body(body)

data/skills/dhanhq-ruby/SKILL.md

@@ -1,74 +1,207 @@
-# DhanHQ Ruby SDK Skill
+---
+name: dhanhq-ruby
+description: >
+  Use when the user mentions DhanHQ, Dhan API, or wants to trade on
+  Indian exchanges (NSE, BSE, MCX) using Ruby. Triggers for: place, modify, or
+  cancel stock/F&O/commodity orders on Dhan using Ruby; fetch portfolio holdings
+  or positions; get live or historical market data; access option
+  chains with Greeks; check fund limits or margin; build any trading
+  automation for Indian markets; resolve NSE/BSE instrument IDs;
+  stream live WebSocket market feeds or order updates. Also trigger
+  for general questions about programmatic trading on Indian exchanges
+  if Dhan is the user's broker.
+compatibility: >
+  Requires Ruby and the dhanhq gem.
+  Order placement, modification, and cancellation require static IP
+  whitelisting on Dhan. Data APIs (quotes, history, option chain,
+  live feed) require an active Dhan Data Plan.
+---
+
+# DhanHQ — Indian Market Trading Skill (Ruby SDK)
 
 Use this skill when an agent needs to write, review, or operate Ruby code using the `DhanHQ` gem.
 
-## Safety rules
+## Safety Rules — Always Enforce
 
-- Prefer read-only tools and SDK calls unless the user explicitly asks to trade.
-- Resolve instruments before trading with `DhanHQ::Models::Instrument.search` and use the returned `security_id` plus `exchange_segment`.
-- Preview every order with `DhanHQ::Agent::OrderPreview` before any live order placement.
-- Never place, modify, or cancel orders unless both `DHANHQ_MCP_ENABLE_WRITES=true` and `LIVE_TRADING=true` are set and the user has clearly confirmed the action.
-- Include a `correlation_id` for every agent-originated order.
-- Do not ask for or print access tokens.
+1. Confirm before placing live orders.
+2. Show a readable order preview before execution.
+3. Default to `LIMIT` orders unless the user explicitly wants `MARKET`.
+4. Warn when notional exceeds `Rs. 50,000`.
+5. For F&O, validate lot size before placement.
+6. Never use `CNC` or `MTF` for F&O, commodity, or currency segments.
+7. Never hardcode credentials in generated code.
+8. Ask for confirmation before modifying or cancelling orders, or performing multi-leg live execution.
 
 ## Setup
 
+Require the core library and configure using environment variables or a configuration block:
+
 ```ruby
 require "dhan_hq"
-require "dhan_hq/agent"
 
+# Configures from environment variables: DHAN_CLIENT_ID, DHAN_ACCESS_TOKEN
 DhanHQ.configure_with_env
 ```
 
-Required environment variables:
+Or configure explicitly:
 
-- `DHAN_CLIENT_ID`
-- `DHAN_ACCESS_TOKEN`
+```ruby
+DhanHQ.configure do |config|
+  config.client_id = "YOUR_CLIENT_ID"
+  config.access_token = "YOUR_ACCESS_TOKEN"
+end
+```
 
-Optional agent variables:
+If generating scripts inside this repo, prefer using the helper script:
 
-- `DHANHQ_AGENT_SCOPES`, comma-separated scopes such as `portfolio:read,market:read,orders:read`
-- `DHANHQ_MCP_ENABLE_WRITES=true` for agent write tools
-- `LIVE_TRADING=true` for any live trading write
+```ruby
+require_relative "scripts/dhan_helpers"
+get_client
+```
 
-## Common calls
+## Current SDK Constants
+
+Use constants from the `DhanHQ::Constants` module for segments, order types, validity, product types, and transactions:
+
+| Category | Constant | Value |
+|----------|----------|-------|
+| Exchange Segment | `DhanHQ::Constants::ExchangeSegment::NSE_EQ` (or `DhanHQ::Constants::NSE`) | `"NSE_EQ"` |
+| | `DhanHQ::Constants::ExchangeSegment::BSE_EQ` (or `DhanHQ::Constants::BSE`) | `"BSE_EQ"` |
+| | `DhanHQ::Constants::ExchangeSegment::NSE_FNO` (or `DhanHQ::Constants::NSE_FNO` / `DhanHQ::Constants::FNO`) | `"NSE_FNO"` |
+| | `DhanHQ::Constants::ExchangeSegment::BSE_FNO` (or `DhanHQ::Constants::BSE_FNO`) | `"BSE_FNO"` |
+| | `DhanHQ::Constants::ExchangeSegment::MCX_COMM` (or `DhanHQ::Constants::MCX`) | `"MCX_COMM"` |
+| | `DhanHQ::Constants::ExchangeSegment::IDX_I` (or `DhanHQ::Constants::INDEX`) | `"IDX_I"` |
+| Transaction Type | `DhanHQ::Constants::TransactionType::BUY` (or `DhanHQ::Constants::BUY`) | `"BUY"` |
+| | `DhanHQ::Constants::TransactionType::SELL` (or `DhanHQ::Constants::SELL`) | `"SELL"` |
+| Order Type | `DhanHQ::Constants::OrderType::LIMIT` (or `DhanHQ::Constants::LIMIT`) | `"LIMIT"` |
+| | `DhanHQ::Constants::OrderType::MARKET` (or `DhanHQ::Constants::MARKET`) | `"MARKET"` |
+| | `DhanHQ::Constants::OrderType::STOP_LOSS` (or `DhanHQ::Constants::SL`) | `"STOP_LOSS"` |
+| | `DhanHQ::Constants::OrderType::STOP_LOSS_MARKET` (or `DhanHQ::Constants::SLM`) | `"STOP_LOSS_MARKET"` |
+| Product Type | `DhanHQ::Constants::ProductType::CNC` (or `DhanHQ::Constants::CNC`) | `"CNC"` |
+| | `DhanHQ::Constants::ProductType::INTRADAY` (or `DhanHQ::Constants::INTRA`) | `"INTRADAY"` |
+| | `DhanHQ::Constants::ProductType::MARGIN` (or `DhanHQ::Constants::MARGIN`) | `"MARGIN"` |
+| | `DhanHQ::Constants::ProductType::MTF` (or `DhanHQ::Constants::MTF`) | `"MTF"` |
+| Validity | `DhanHQ::Constants::Validity::DAY` (or `DhanHQ::Constants::DAY`) | `"DAY"` |
+| | `DhanHQ::Constants::Validity::IOC` (or `DhanHQ::Constants::IOC`) | `"IOC"` |
+
+## Preferred SDK Methods (ActiveRecord-Style Models)
+
+| Task | Method |
+|------|--------|
+| Place order | `DhanHQ::Models::Order.place(params)` |
+| List all orders | `DhanHQ::Models::Order.all` |
+| Order by ID | `DhanHQ::Models::Order.find(order_id)` |
+| Order by correlation ID | `DhanHQ::Models::Order.find_by_correlation(correlation_id)` |
+| Today's trades | `DhanHQ::Models::Trade.today` |
+| Historical trades | `DhanHQ::Models::Trade.history(from_date:, to_date:, page:)` |
+| Holdings | `DhanHQ::Models::Holding.all` |
+| Positions | `DhanHQ::Models::Position.all` |
+| Fund limits | `DhanHQ::Models::Funds.fetch` |
+| Margin calculator | `DhanHQ::Models::Margin.calculate(params)` |
+| Multi-instrument margin | `DhanHQ::Models::Margin.calculate_multi(params)` |
+| Daily charts | `DhanHQ::Models::HistoricalData.daily(params)` |
+| Intraday charts | `DhanHQ::Models::HistoricalData.intraday(params)` |
+| Option chain | `DhanHQ::Models::OptionChain.fetch(params)` |
+| Expiry list | `DhanHQ::Models::OptionChain.fetch_expiry_list(params)` |
+| Search instruments | `DhanHQ::Models::Instrument.search(query, options)` |
+| Find specific instrument | `DhanHQ::Models::Instrument.find(exchange_segment, symbol, options)` |
+| Find instrument anywhere | `DhanHQ::Models::Instrument.find_anywhere(symbol, options)` |
+| Super orders | `DhanHQ::Models::SuperOrder.create(params)` |
+| Forever orders | `DhanHQ::Models::ForeverOrder.create(params)` |
+| Live market feed | `DhanHQ::WS.connect(mode: :ticker) { |tick| ... }` |
+| Live order updates | `DhanHQ::WS::Orders.connect { |update| ... }` |
+| Live market depth | `DhanHQ::WS::MarketDepth.connect(symbols: [{...}]) { |depth| ... }` |
+
+## High-Value Gotchas
+
+- **Return values are model instances:** Most class methods return `DhanHQ::Models` objects rather than raw HTTP hashes.
+- **Instrument search is segment-specific:** `DhanHQ::Models::Instrument.by_segment(exchange_segment)` downloads the CSV for a single segment, which is more token-efficient than downloading the entire master CSV.
+- **Spelling fixes in models:** Typos from the Dhan API are normalized in model attributes (e.g. `availabelBalance` is normalized to `available_balance` or `availabel_balance`).
+- **Timestamps:** Timestamps returned by `HistoricalData` are automatically normalized into Ruby `Time` objects.
+- **WebSocket connection management:** Use sequential connections or single connection pools to avoid 429 rate limiting. Dhan allows up to 5 concurrent WebSocket connections.
+
+## Core Patterns
+
+### 1. Check account access before data calls
 
 ```ruby
-DhanHQ::Models::Profile.fetch
-DhanHQ::Models::Funds.fetch
-DhanHQ::Models::Holding.all
-DhanHQ::Models::Position.all
-DhanHQ::Models::Order.all
-DhanHQ::Models::Trade.today
-DhanHQ::Models::Instrument.search("RELIANCE", segments: ["NSE_EQ"], limit: 5)
-DhanHQ::Models::MarketFeed.ltp("NSE_EQ" => ["2885"])
+funds = DhanHQ::Models::Funds.fetch
+puts "Available Balance: Rs. #{funds.availabel_balance}"
 ```
 
-## Order preview
+### 2. Fetch historical data
 
 ```ruby
-preview = DhanHQ::Agent::OrderPreview.new(
-  transaction_type: "BUY",
-  exchange_segment: "NSE_EQ",
-  product_type: "INTRADAY",
-  order_type: "MARKET",
-  validity: "DAY",
+candles = DhanHQ::Models::HistoricalData.daily(
   security_id: "2885",
-  quantity: 1,
-  correlation_id: "agent-20260702-001"
+  exchange_segment: "NSE_EQ",
+  instrument: "EQUITY",
+  from_date: "2024-01-01",
+  to_date: "2024-12-31"
 )
 
-preview.to_h
+candles.each do |candle|
+  puts "Date: #{candle[:timestamp].to_date}, Close: #{candle[:close]}"
+end
 ```
 
-## MCP server
+### 3. Option-chain data
 
-The gem includes a stdio MCP executable:
+```ruby
+chain = DhanHQ::Models::OptionChain.fetch(
+  underlying_scrip: 13,
+  underlying_seg: "IDX_I",
+  expiry: "2025-03-27"
+)
 
-```bash
-dhanhq-mcp
+puts "Underlying spot: #{chain[:last_price]}"
+chain[:strikes].each do |strike_data|
+  puts "Strike: #{strike_data[:strike]}, Call LTP: #{strike_data[:call][:last_price]}"
+end
 ```
 
-Start with read-only scopes. Add write scopes only for explicitly confirmed trading sessions.
+### 4. Margin check before live order placement
+
+```ruby
+margin = DhanHQ::Models::Margin.calculate(
+  security_id: "2885",
+  exchange_segment: "NSE_EQ",
+  transaction_type: "BUY",
+  quantity: 10,
+  product_type: "CNC",
+  price: 2450.0
+)
+
+puts "Sufficient balance? #{margin.available_balance >= margin.total_margin}"
+```
+
+### 5. Live market feed
+
+```ruby
+market_client = DhanHQ::WS.connect(mode: :ticker) do |tick|
+  puts "Market Tick: #{tick[:security_id]} = #{tick[:ltp]}"
+end
+
+market_client.subscribe_one(segment: "NSE_EQ", security_id: "2885")
+sleep(10)
+market_client.stop
+```
 
-See the references directory for focused workflows.
+## Reference Files
+
+Refer to the documents in the references directory for focused workflows:
+
+| Need | File |
+|------|------|
+| Orders, super orders, forever orders | [references/orders.md](references/orders.md) |
+| Holdings, positions, eDIS | [references/portfolio.md](references/portfolio.md) |
+| Daily/minute history, quotes, expired options | [references/market-data.md](references/market-data.md) |
+| Option-chain usage | [references/option-chain.md](references/option-chain.md) |
+| Fund limits and margin checks | [references/funds.md](references/funds.md) |
+| Live feeds and depth | [references/live-feed.md](references/live-feed.md) |
+| Error handling | [references/error-codes.md](references/error-codes.md) |
+| Instrument resolution | [references/instruments.md](references/instruments.md) |
+| Multi-step execution patterns | [references/common-workflows.md](references/common-workflows.md) |
+| Options analytics | [references/options-analysis-patterns.md](references/options-analysis-patterns.md) |
+| Backtesting patterns | [references/backtesting-with-dhan.md](references/backtesting-with-dhan.md) |
+| Extranal data sources (RSI, PE ratios, screener) | [references/scanx-data.md](references/scanx-data.md) |

data/skills/dhanhq-ruby/examples/fetch_option_chain.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../../lib", __dir__))
+require "dhan_hq"
+require_relative "../scripts/dhan_helpers"
+
+# Initialize credentials
+get_client
+
+expiries = DhanHQ::Models::OptionChain.fetch_expiry_list(underlying_scrip: 13, underlying_seg: DhanHQ::Constants::ExchangeSegment::IDX_I)
+nearest_expiry = expiries.first
+
+if nearest_expiry.nil?
+  puts "Failed to fetch expiries."
+  exit 1
+end
+
+puts "Using expiry: #{nearest_expiry}"
+
+chain_df, spot = fetch_chain_df(under_security_id: 13, expiry: nearest_expiry)
+atm = find_atm_row(chain_df, spot)
+
+if atm.nil?
+  puts "Failed to find ATM row."
+  exit 1
+end
+
+puts "Nifty Spot: #{spot}"
+puts "ATM Strike: #{atm["strike"]}"
+
+# Filter strikes between ATM - 500 and ATM + 500
+nearby = chain_df.select do |row|
+  row["strike"].between?(atm["strike"] - 500, atm["strike"] + 500)
+end
+
+puts "\nOption Chain (ATM ± 500 points):\n\n"
+printf(
+  "%-10s | %-8s | %-12s | %-6s | %-8s | %-12s | %-6s\n",
+  "Strike", "CE LTP", "CE OI", "CE IV", "PE LTP", "PE OI", "PE IV"
+)
+puts "-" * 75
+nearby.each do |row|
+  printf(
+    "%-10g | %-8.2f | %-12d | %-6.2f | %-8.2f | %-12d | %-6.2f\n",
+    row["strike"],
+    row["ce_ltp"].to_f,
+    row["ce_oi"].to_i,
+    row["ce_iv"].to_f,
+    row["pe_ltp"].to_f,
+    row["pe_oi"].to_i,
+    row["pe_iv"].to_f
+  )
+end
+puts

data/skills/dhanhq-ruby/examples/gtt_forever_order.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../../lib", __dir__))
+require "dhan_hq"
+require_relative "../scripts/dhan_helpers"
+
+# Initialize credentials
+get_client
+
+# Example 1: Single GTT — Buy Reliance if it dips to ₹2300
+puts "--- GTT Single: Buy RELIANCE on dip ---"
+# order = DhanHQ::Models::ForeverOrder.create(
+#   security_id: "2885",
+#   exchange_segment: "NSE_EQ",
+#   transaction_type: "BUY",
+#   product_type: "CNC",              # Equity delivery
+#   order_type: "LIMIT",
+#   quantity: 5,
+#   price: 2300.00,                   # Limit price
+#   trigger_price: 2305.00,           # Trigger price
+#   order_flag: "SINGLE",
+#   validity: "DAY"
+# )
+# puts "GTT placed: #{order.inspect}"
+
+# Example 2: OCO — Sell Reliance at ₹2700 (target) OR ₹2200 (stop loss)
+puts "\n--- GTT OCO: Target + Stop Loss for RELIANCE holding ---"
+# order = DhanHQ::Models::ForeverOrder.create(
+#   security_id: "2885",
+#   exchange_segment: "NSE_EQ",
+#   transaction_type: "SELL",
+#   product_type: "CNC",              # Selling from holdings
+#   order_type: "LIMIT",
+#   quantity: 5,
+#   price: 2700.00,                   # Target price (price of first leg)
+#   trigger_price: 2695.00,           # Target trigger price (trigger of first leg)
+#   price1: 2200.00,                  # Stop loss price (price of second leg)
+#   trigger_price1: 2205.00,          # Stop loss trigger price (trigger of second leg)
+#   quantity1: 5,                     # Stop loss quantity (quantity of second leg)
+#   order_flag: "OCO",                # One Cancels Other
+#   validity: "DAY"
+# )
+# puts "OCO placed: #{order.inspect}"
+
+# Example 3: List all active forever orders
+puts "\n--- Active Forever Orders ---"
+forever_orders = begin
+  DhanHQ::Models::ForeverOrder.all
+rescue StandardError
+  []
+end
+if forever_orders.any?
+  forever_orders.each do |ord|
+    puts "  ID: #{ord.order_id} | " \
+         "#{ord.trading_symbol} | " \
+         "Type: #{ord.order_flag} | " \
+         "Trigger: ₹#{ord.trigger_price}"
+  end
+else
+  puts "  No active forever orders"
+end
+
+# Example 4: Cancel a forever order
+# order = DhanHQ::Models::ForeverOrder.find("YOUR_ORDER_ID")
+# order.cancel if order

data/skills/dhanhq-ruby/examples/historical_data_analysis.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../../lib", __dir__))
+require "dhan_hq"
+require "date"
+require_relative "../scripts/dhan_helpers"
+
+# Initialize credentials
+get_client
+
+to_date = Date.today.strftime("%Y-%m-%d")
+from_date = (Date.today - 180).strftime("%Y-%m-%d")
+
+# Fetch daily charts via HistoricalData model
+candles = DhanHQ::Models::HistoricalData.daily(
+  security_id: "2885",
+  exchange_segment: DhanHQ::Constants::ExchangeSegment::NSE_EQ,
+  instrument: DhanHQ::Constants::InstrumentType::EQUITY,
+  from_date: from_date,
+  to_date: to_date
+)
+
+if candles.empty?
+  puts "No candle data returned."
+  exit 1
+end
+
+close_prices = candles.map { |c| c[:close].to_f }
+timestamps = candles.map { |c| c[:timestamp] }
+
+# Calculate SMAs
+def calculate_sma(prices, period)
+  return [] if prices.size < period
+
+  # Calculate SMA for each index starting from period - 1
+  ((period - 1)...prices.size).map do |i|
+    prices[(i - period + 1)..i].sum / period.to_f
+  end
+end
+
+sma_20_series = calculate_sma(close_prices, 20)
+sma_50_series = calculate_sma(close_prices, 50)
+
+latest_sma_20 = sma_20_series.last
+latest_sma_50 = sma_50_series.last
+
+# Calculate returns
+returns = []
+close_prices.each_cons(2) do |prev_price, curr_price|
+  returns << ((curr_price - prev_price) / prev_price)
+end
+
+# Calculate daily volatility (standard deviation of returns) and annualize it
+mean_return = returns.sum / returns.size.to_f
+variance = returns.sum { |r| (r - mean_return)**2 } / (returns.size - 1).to_f
+std_dev = Math.sqrt(variance)
+annualized_volatility = std_dev * Math.sqrt(252)
+
+start_date = begin
+  timestamps.first.is_a?(Time) ? timestamps.first.to_date : Date.parse(timestamps.first.to_s)
+rescue StandardError
+  "N/A"
+end
+end_date = begin
+  timestamps.last.is_a?(Time) ? timestamps.last.to_date : Date.parse(timestamps.last.to_s)
+rescue StandardError
+  "N/A"
+end
+
+puts "=== RELIANCE — Last 6 Months ===\n\n"
+puts "Period:         #{start_date} to #{end_date}"
+puts "Trading Days:   #{candles.size}"
+puts "Start Price:    Rs. #{"%.2f" % close_prices.first}"
+puts "End Price:      Rs. #{"%.2f" % close_prices.last}"
+puts "High:           Rs. #{"%.2f" % candles.map { |c| c[:high].to_f }.max}"
+puts "Low:            Rs. #{"%.2f" % candles.map { |c| c[:low].to_f }.min}"
+puts "Total Return:   #{format("%.2f%", ((close_prices.last / close_prices.first) - 1.0) * 100)}"
+puts "Avg Daily Vol:  #{format("%.0f", candles.sum { |c| c[:volume].to_i } / candles.size.to_f)}"
+puts "Volatility:     #{format("%.2f%", annualized_volatility * 100)} (annualized)"
+
+if latest_sma_20 && latest_sma_50
+  puts "\nSMA 20:         Rs. #{"%.2f" % latest_sma_20}"
+  puts "SMA 50:         Rs. #{"%.2f" % latest_sma_50}"
+  if latest_sma_20 > latest_sma_50
+    puts "Signal:         Bullish (SMA 20 > SMA 50)"
+  else
+    puts "Signal:         Bearish (SMA 20 < SMA 50)"
+  end
+end