@devanshhq/indica 0.1.0 → 0.2.0

package/src/signals/rules.rs

@@ -0,0 +1,333 @@
+use crate::indicators::momentum::macd::Crossover;
+use crate::indicators::trend::supertrend::SupertrendDirection;
+
+use super::engine::{IndicatorValues, SignalRule};
+use super::types::{SignalStrength, SignalVote};
+
+/// RSI-based signal: oversold = Buy, overbought = Sell.
+pub struct RsiRule;
+
+impl SignalRule for RsiRule {
+    fn evaluate(&self, snapshot: &IndicatorValues) -> Option<SignalVote> {
+        let rsi = snapshot.rsi?;
+        let (strength, reason) = if rsi < 20.0 {
+            (
+                SignalStrength::StrongBuy,
+                format!("RSI {rsi:.1} — deeply oversold"),
+            )
+        } else if rsi < 30.0 {
+            (SignalStrength::Buy, format!("RSI {rsi:.1} — oversold"))
+        } else if rsi > 80.0 {
+            (
+                SignalStrength::StrongSell,
+                format!("RSI {rsi:.1} — deeply overbought"),
+            )
+        } else if rsi > 70.0 {
+            (SignalStrength::Sell, format!("RSI {rsi:.1} — overbought"))
+        } else {
+            (
+                SignalStrength::Neutral,
+                format!("RSI {rsi:.1} — neutral zone"),
+            )
+        };
+        Some(SignalVote {
+            strength,
+            weight: 0.8,
+            reason,
+        })
+    }
+}
+
+/// MACD crossover signal.
+pub struct MacdCrossoverRule;
+
+impl SignalRule for MacdCrossoverRule {
+    fn evaluate(&self, snapshot: &IndicatorValues) -> Option<SignalVote> {
+        let macd = snapshot.macd.as_ref()?;
+        let (strength, reason) = match macd.crossover {
+            Crossover::Bullish => (
+                SignalStrength::Buy,
+                format!("MACD bullish crossover (histogram: {:.2})", macd.histogram),
+            ),
+            Crossover::Bearish => (
+                SignalStrength::Sell,
+                format!("MACD bearish crossover (histogram: {:.2})", macd.histogram),
+            ),
+            Crossover::Neutral => {
+                if macd.histogram > 0.0 {
+                    (
+                        SignalStrength::Buy,
+                        format!("MACD positive histogram ({:.2})", macd.histogram),
+                    )
+                } else if macd.histogram < 0.0 {
+                    (
+                        SignalStrength::Sell,
+                        format!("MACD negative histogram ({:.2})", macd.histogram),
+                    )
+                } else {
+                    (SignalStrength::Neutral, "MACD flat".to_string())
+                }
+            }
+        };
+        Some(SignalVote {
+            strength,
+            weight: 0.9,
+            reason,
+        })
+    }
+}
+
+/// Supertrend direction signal.
+pub struct SupertrendRule;
+
+impl SignalRule for SupertrendRule {
+    fn evaluate(&self, snapshot: &IndicatorValues) -> Option<SignalVote> {
+        let st = snapshot.supertrend.as_ref()?;
+        let (strength, reason) = match st.direction {
+            SupertrendDirection::Up => (
+                SignalStrength::Buy,
+                format!("Supertrend UP — support at {:.2}", st.value),
+            ),
+            SupertrendDirection::Down => (
+                SignalStrength::Sell,
+                format!("Supertrend DOWN — resistance at {:.2}", st.value),
+            ),
+        };
+        Some(SignalVote {
+            strength,
+            weight: 1.0,
+            reason,
+        })
+    }
+}
+
+/// Volume trend confirmation / warning.
+pub struct VolumeTrendRule;
+
+impl SignalRule for VolumeTrendRule {
+    fn evaluate(&self, snapshot: &IndicatorValues) -> Option<SignalVote> {
+        let trend = snapshot.volume_trend.as_str();
+        let (strength, reason) = match trend {
+            "surging" => (
+                SignalStrength::Buy,
+                "Volume surging — confirms momentum".to_string(),
+            ),
+            "increasing" => (
+                SignalStrength::Buy,
+                "Volume increasing — supports trend".to_string(),
+            ),
+            "declining" => (
+                SignalStrength::Sell,
+                "Volume declining — trend weakening".to_string(),
+            ),
+            "drying up" => (
+                SignalStrength::StrongSell,
+                "Volume drying up — caution".to_string(),
+            ),
+            "stable" => (SignalStrength::Neutral, "Volume stable".to_string()),
+            _ => return None,
+        };
+        Some(SignalVote {
+            strength,
+            weight: 0.6,
+            reason,
+        })
+    }
+}
+
+/// ADX trend strength — confirms or weakens signals.
+pub struct AdxTrendRule;
+
+impl SignalRule for AdxTrendRule {
+    fn evaluate(&self, snapshot: &IndicatorValues) -> Option<SignalVote> {
+        let adx_val = snapshot.adx?;
+        let (strength, reason) = if adx_val > 40.0 {
+            (
+                SignalStrength::StrongBuy,
+                format!("ADX {adx_val:.1} — very strong trend"),
+            )
+        } else if adx_val > 25.0 {
+            (
+                SignalStrength::Neutral,
+                format!("ADX {adx_val:.1} — trending (confirms direction)"),
+            )
+        } else if adx_val > 20.0 {
+            (
+                SignalStrength::Neutral,
+                format!("ADX {adx_val:.1} — weak trend"),
+            )
+        } else {
+            (
+                SignalStrength::Neutral,
+                format!("ADX {adx_val:.1} — no trend, range-bound"),
+            )
+        };
+        Some(SignalVote {
+            strength,
+            weight: 0.5,
+            reason,
+        })
+    }
+}
+
+/// Stochastic Oscillator rule.
+pub struct StochasticRule;
+
+impl SignalRule for StochasticRule {
+    fn evaluate(&self, snapshot: &IndicatorValues) -> Option<SignalVote> {
+        let stoch = snapshot.stochastic.as_ref()?;
+        let (strength, reason) = if stoch.k < 20.0 && stoch.d < 20.0 {
+            (
+                SignalStrength::StrongBuy,
+                format!(
+                    "Stochastic K={:.1} D={:.1} — deeply oversold",
+                    stoch.k, stoch.d
+                ),
+            )
+        } else if stoch.k < 30.0 {
+            (
+                SignalStrength::Buy,
+                format!("Stochastic K={:.1} — oversold zone", stoch.k),
+            )
+        } else if stoch.k > 80.0 && stoch.d > 80.0 {
+            (
+                SignalStrength::StrongSell,
+                format!(
+                    "Stochastic K={:.1} D={:.1} — deeply overbought",
+                    stoch.k, stoch.d
+                ),
+            )
+        } else if stoch.k > 70.0 {
+            (
+                SignalStrength::Sell,
+                format!("Stochastic K={:.1} — overbought zone", stoch.k),
+            )
+        } else {
+            (
+                SignalStrength::Neutral,
+                format!("Stochastic K={:.1} — neutral zone", stoch.k),
+            )
+        };
+        Some(SignalVote {
+            strength,
+            weight: 0.7,
+            reason,
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::indicators::momentum::macd::MacdResult;
+    use crate::indicators::momentum::stochastic::StochasticResult;
+    use crate::indicators::trend::supertrend::SupertrendResult;
+
+    #[test]
+    fn rsi_oversold() {
+        let vals = IndicatorValues {
+            rsi: Some(25.0),
+            ..Default::default()
+        };
+        let vote = RsiRule.evaluate(&vals).unwrap();
+        assert_eq!(vote.strength, SignalStrength::Buy);
+    }
+
+    #[test]
+    fn rsi_overbought() {
+        let vals = IndicatorValues {
+            rsi: Some(75.0),
+            ..Default::default()
+        };
+        let vote = RsiRule.evaluate(&vals).unwrap();
+        assert_eq!(vote.strength, SignalStrength::Sell);
+    }
+
+    #[test]
+    fn rsi_deeply_oversold() {
+        let vals = IndicatorValues {
+            rsi: Some(15.0),
+            ..Default::default()
+        };
+        let vote = RsiRule.evaluate(&vals).unwrap();
+        assert_eq!(vote.strength, SignalStrength::StrongBuy);
+    }
+
+    #[test]
+    fn macd_bullish_crossover() {
+        let vals = IndicatorValues {
+            macd: Some(MacdResult {
+                value: 1.0,
+                signal: 0.5,
+                histogram: 0.5,
+                crossover: Crossover::Bullish,
+            }),
+            ..Default::default()
+        };
+        let vote = MacdCrossoverRule.evaluate(&vals).unwrap();
+        assert_eq!(vote.strength, SignalStrength::Buy);
+    }
+
+    #[test]
+    fn supertrend_up() {
+        let vals = IndicatorValues {
+            supertrend: Some(SupertrendResult {
+                value: 100.0,
+                direction: SupertrendDirection::Up,
+            }),
+            ..Default::default()
+        };
+        let vote = SupertrendRule.evaluate(&vals).unwrap();
+        assert_eq!(vote.strength, SignalStrength::Buy);
+    }
+
+    #[test]
+    fn volume_surging() {
+        let vals = IndicatorValues {
+            volume_trend: "surging".to_string(),
+            ..Default::default()
+        };
+        let vote = VolumeTrendRule.evaluate(&vals).unwrap();
+        assert_eq!(vote.strength, SignalStrength::Buy);
+    }
+
+    #[test]
+    fn adx_strong() {
+        let vals = IndicatorValues {
+            adx: Some(45.0),
+            ..Default::default()
+        };
+        let vote = AdxTrendRule.evaluate(&vals).unwrap();
+        assert_eq!(vote.strength, SignalStrength::StrongBuy);
+    }
+
+    #[test]
+    fn stochastic_oversold() {
+        let vals = IndicatorValues {
+            stochastic: Some(StochasticResult { k: 15.0, d: 15.0 }),
+            ..Default::default()
+        };
+        let vote = StochasticRule.evaluate(&vals).unwrap();
+        assert_eq!(vote.strength, SignalStrength::StrongBuy);
+    }
+
+    #[test]
+    fn stochastic_overbought() {
+        let vals = IndicatorValues {
+            stochastic: Some(StochasticResult { k: 85.0, d: 85.0 }),
+            ..Default::default()
+        };
+        let vote = StochasticRule.evaluate(&vals).unwrap();
+        assert_eq!(vote.strength, SignalStrength::StrongSell);
+    }
+
+    #[test]
+    fn missing_data_returns_none() {
+        let vals = IndicatorValues::default();
+        assert!(RsiRule.evaluate(&vals).is_none());
+        assert!(MacdCrossoverRule.evaluate(&vals).is_none());
+        assert!(SupertrendRule.evaluate(&vals).is_none());
+        assert!(AdxTrendRule.evaluate(&vals).is_none());
+        assert!(StochasticRule.evaluate(&vals).is_none());
+    }
+}

package/src/signals/types.rs

@@ -0,0 +1,50 @@
+/// Signal strength classification.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum SignalStrength {
+    StrongBuy,
+    Buy,
+    Neutral,
+    Sell,
+    StrongSell,
+}
+
+impl SignalStrength {
+    /// Numeric score: StrongBuy = 2, Buy = 1, Neutral = 0, Sell = -1, StrongSell = -2.
+    pub fn score(self) -> f64 {
+        match self {
+            Self::StrongBuy => 2.0,
+            Self::Buy => 1.0,
+            Self::Neutral => 0.0,
+            Self::Sell => -1.0,
+            Self::StrongSell => -2.0,
+        }
+    }
+}
+
+impl std::fmt::Display for SignalStrength {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::StrongBuy => write!(f, "strong_buy"),
+            Self::Buy => write!(f, "buy"),
+            Self::Neutral => write!(f, "neutral"),
+            Self::Sell => write!(f, "sell"),
+            Self::StrongSell => write!(f, "strong_sell"),
+        }
+    }
+}
+
+/// Composite signal after aggregating all rule votes.
+#[derive(Debug, Clone)]
+pub struct Signal {
+    pub strength: SignalStrength,
+    pub confidence: f64,
+    pub reasons: Vec<String>,
+}
+
+/// A single vote from one signal rule.
+#[derive(Debug, Clone)]
+pub struct SignalVote {
+    pub strength: SignalStrength,
+    pub weight: f64,
+    pub reason: String,
+}

package/index.d.ts

@@ -1,66 +0,0 @@
-/* auto-generated by NAPI-RS */
-/* eslint-disable */
-export declare function batchComputeIndicators(stocks: Array<JsStockData>): Array<JsIndicatorSnapshot>
-
-export declare function calcAtr(highs: Array<number>, lows: Array<number>, closes: Array<number>, period: number): number | null
-
-export declare function calcBollingerBands(closes: Array<number>, period: number, stdDev: number): JsBollingerBands | null
-
-export declare function calcEma(values: Array<number>, period: number): number | null
-
-export declare function calcMacd(closes: Array<number>, fast: number, slow: number, signal: number): JsMacdResult | null
-
-export declare function calcPivotPoints(high: number, low: number, close: number): JsPivotPoints
-
-export declare function calcRelativeStrength(stock: Array<number>, benchmark: Array<number>, period: number): number | null
-
-export declare function calcRsi(closes: Array<number>, period: number): number | null
-
-export declare function calcSma(values: Array<number>, period: number): number | null
-
-export declare function calcVolumeTrend(volumes: Array<number>): string
-
-export interface JsBollingerBands {
-  upper: number
-  middle: number
-  lower: number
-  percentB: number
-}
-
-export interface JsIndicatorSnapshot {
-  symbol: string
-  sma20?: number
-  sma50?: number
-  sma200?: number
-  ema20?: number
-  rsi14?: number
-  macd?: JsMacdResult
-  bollinger?: JsBollingerBands
-  atr14?: number
-  volumeTrend: string
-}
-
-export interface JsMacdResult {
-  value: number
-  signal: number
-  histogram: number
-  crossover: string
-}
-
-export interface JsPivotPoints {
-  r3: number
-  r2: number
-  r1: number
-  pivot: number
-  s1: number
-  s2: number
-  s3: number
-}
-
-export interface JsStockData {
-  symbol: string
-  closes: Array<number>
-  highs: Array<number>
-  lows: Array<number>
-  volumes: Array<number>
-}

package/src/atr.rs

@@ -1,66 +0,0 @@
-use crate::utils::round;
-
-/// Average True Range using Wilder's smoothing.
-/// Requires `period + 1` data points minimum.
-/// Returns `None` if insufficient data.
-pub fn atr(highs: &[f64], lows: &[f64], closes: &[f64], period: usize) -> Option<f64> {
-    let len = closes.len();
-    if len < period + 1 || highs.len() < len || lows.len() < len || period == 0 {
-        return None;
-    }
-
-    // Compute true ranges
-    let true_ranges: Vec<f64> = (1..len)
-        .map(|i| {
-            let hl = highs[i] - lows[i];
-            let hc = (highs[i] - closes[i - 1]).abs();
-            let lc = (lows[i] - closes[i - 1]).abs();
-            hl.max(hc).max(lc)
-        })
-        .collect();
-
-    if true_ranges.len() < period {
-        return None;
-    }
-
-    // Initial ATR = simple average of first `period` true ranges
-    let mut atr_value: f64 = true_ranges[..period].iter().sum::<f64>() / period as f64;
-
-    // Wilder's smoothing
-    for &tr in &true_ranges[period..] {
-        atr_value = (atr_value * (period as f64 - 1.0) + tr) / period as f64;
-    }
-
-    Some(round(atr_value, 2))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn atr_basic() {
-        let highs = vec![48.7, 48.72, 48.9, 48.87, 48.82, 49.05, 49.2, 49.35,
-                         49.92, 50.19, 50.12, 49.66, 49.88, 50.19, 50.36, 50.57];
-        let lows  = vec![47.79, 48.14, 48.39, 48.37, 48.24, 48.64, 48.94, 48.86,
-                         49.50, 49.87, 49.20, 48.90, 49.43, 49.73, 49.26, 50.09];
-        let closes = vec![48.16, 48.61, 48.75, 48.63, 48.74, 49.03, 49.07, 49.32,
-                          49.91, 50.13, 49.53, 49.50, 49.75, 50.03, 49.99, 50.23];
-        let result = atr(&highs, &lows, &closes, 14).unwrap();
-        assert!(result > 0.0);
-        assert!(result < 2.0); // Reasonable range for this data
-    }
-
-    #[test]
-    fn atr_insufficient_data() {
-        assert!(atr(&[1.0; 5], &[1.0; 5], &[1.0; 5], 14).is_none());
-    }
-
-    #[test]
-    fn atr_flat_market() {
-        // All same price = ATR near 0
-        let data = vec![100.0; 20];
-        let result = atr(&data, &data, &data, 14).unwrap();
-        assert_eq!(result, 0.0);
-    }
-}

package/src/batch.rs

@@ -1,139 +0,0 @@
-use crate::*;
-use rayon::prelude::*;
-
-/// Input data for a single stock.
-#[derive(Debug, Clone)]
-pub struct StockData {
-    pub symbol: String,
-    pub closes: Vec<f64>,
-    pub highs: Vec<f64>,
-    pub lows: Vec<f64>,
-    pub volumes: Vec<f64>,
-}
-
-/// All indicators computed for a single stock.
-#[derive(Debug, Clone)]
-pub struct IndicatorSnapshot {
-    pub symbol: String,
-    pub sma_20: Option<f64>,
-    pub sma_50: Option<f64>,
-    pub sma_200: Option<f64>,
-    pub ema_20: Option<f64>,
-    pub rsi_14: Option<f64>,
-    pub macd_result: Option<MacdResult>,
-    pub bollinger: Option<BollingerBandsResult>,
-    pub atr_14: Option<f64>,
-    pub volume_trend: String,
-}
-
-/// Compute all indicators for a single stock.
-pub fn compute_indicators(stock: &StockData) -> IndicatorSnapshot {
-    IndicatorSnapshot {
-        symbol: stock.symbol.clone(),
-        sma_20: sma(&stock.closes, 20),
-        sma_50: sma(&stock.closes, 50),
-        sma_200: sma(&stock.closes, 200),
-        ema_20: ema(&stock.closes, 20),
-        rsi_14: rsi(&stock.closes, 14),
-        macd_result: macd(&stock.closes, 12, 26, 9),
-        bollinger: bollinger_bands(&stock.closes, 20, 2.0),
-        atr_14: atr(&stock.highs, &stock.lows, &stock.closes, 14),
-        volume_trend: volume_trend(&stock.volumes).to_string(),
-    }
-}
-
-/// Compute indicators for multiple stocks sequentially.
-pub fn batch_compute(stocks: &[StockData]) -> Vec<IndicatorSnapshot> {
-    stocks.iter().map(compute_indicators).collect()
-}
-
-/// Compute indicators for multiple stocks in parallel using Rayon.
-/// Automatically distributes work across all CPU cores.
-pub fn batch_compute_parallel(stocks: &[StockData]) -> Vec<IndicatorSnapshot> {
-    stocks.par_iter().map(compute_indicators).collect()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn make_stock(symbol: &str, days: usize) -> StockData {
-        let closes: Vec<f64> = (0..days).map(|i| 100.0 + (i as f64 * 0.5)).collect();
-        let highs: Vec<f64> = closes.iter().map(|c| c + 2.0).collect();
-        let lows: Vec<f64> = closes.iter().map(|c| c - 2.0).collect();
-        let volumes: Vec<f64> = vec![1_000_000.0; days];
-        StockData {
-            symbol: symbol.to_string(),
-            closes,
-            highs,
-            lows,
-            volumes,
-        }
-    }
-
-    #[test]
-    fn single_stock() {
-        let stock = make_stock("RELIANCE", 250);
-        let result = compute_indicators(&stock);
-        assert_eq!(result.symbol, "RELIANCE");
-        assert!(result.sma_20.is_some());
-        assert!(result.sma_50.is_some());
-        assert!(result.sma_200.is_some());
-        assert!(result.rsi_14.is_some());
-        assert!(result.macd_result.is_some());
-        assert!(result.bollinger.is_some());
-        assert!(result.atr_14.is_some());
-        assert_eq!(result.volume_trend, "stable");
-    }
-
-    #[test]
-    fn batch_multiple() {
-        let stocks: Vec<StockData> = ["RELIANCE", "TCS", "INFY", "SBIN", "HDFCBANK"]
-            .iter()
-            .map(|s| make_stock(s, 250))
-            .collect();
-
-        let results = batch_compute(&stocks);
-        assert_eq!(results.len(), 5);
-        assert_eq!(results[0].symbol, "RELIANCE");
-        assert_eq!(results[4].symbol, "HDFCBANK");
-    }
-
-    #[test]
-    fn batch_2000_stocks() {
-        let stocks: Vec<StockData> = (0..2000)
-            .map(|i| make_stock(&format!("STOCK{}", i), 250))
-            .collect();
-
-        let start = std::time::Instant::now();
-        let results = batch_compute(&stocks);
-        let elapsed = start.elapsed();
-
-        assert_eq!(results.len(), 2000);
-        println!("2000 stocks sequential: {:?}", elapsed);
-    }
-
-    #[test]
-    fn batch_2000_parallel() {
-        let stocks: Vec<StockData> = (0..2000)
-            .map(|i| make_stock(&format!("STOCK{}", i), 250))
-            .collect();
-
-        let start = std::time::Instant::now();
-        let results = batch_compute_parallel(&stocks);
-        let elapsed = start.elapsed();
-
-        assert_eq!(results.len(), 2000);
-        println!("2000 stocks parallel:   {:?}", elapsed);
-    }
-
-    #[test]
-    fn insufficient_data_stock() {
-        let stock = make_stock("NEWIPO", 10);
-        let result = compute_indicators(&stock);
-        assert_eq!(result.symbol, "NEWIPO");
-        assert!(result.sma_20.is_none());
-        assert!(result.rsi_14.is_none());
-        assert!(result.macd_result.is_none());
-    }
-}