@vesper85/technical-indicators 0.1.0

package/README.md

@@ -0,0 +1,249 @@
+# @osiris-ai/technical-indicators
+
+A library for calculating technical indicators used in financial analysis and trading.
+
+## Installation
+
+```bash
+pnpm add @osiris-ai/technical-indicators
+```
+
+## Usage
+
+### Using Individual Functions
+
+```typescript
+import { calculateSMA, calculateRSI, calculateMACD } from '@osiris-ai/technical-indicators';
+
+// Simple Moving Average
+const closes = [100, 102, 101, 105, 107, 109, 108];
+const sma = calculateSMA(closes, { period: 5 });
+console.log(sma); // 106.4 (single number)
+
+// RSI
+const rsi = calculateRSI(closes, { period: 14 });
+console.log(rsi); // 65.5 (single number)
+
+// MACD (returns array)
+const macd = calculateMACD(closes, { 
+  fastPeriod: 12, 
+  slowPeriod: 26, 
+  signalPeriod: 9 
+});
+console.log(macd); // [0.5, 0.3, 0.2] - [MACD, signal, histogram]
+```
+
+### Using TechnicalAnalysisService
+
+```typescript
+import { TechnicalAnalysisService } from '@osiris-ai/technical-indicators';
+import { Logger } from '@osiris-ai/logger';
+
+const service = new TechnicalAnalysisService({ logger: new Logger() });
+
+// OHLCV data format
+const ohlcvData = [
+  {
+    timestamp: 1640995200000,
+    open: 100,
+    high: 105,
+    low: 99,
+    close: 103,
+    volume: 1000000
+  },
+  // ... more candles
+];
+
+// Calculate RSI
+const rsi = service.calculate('rsi_14', ohlcvData, { period: 14 });
+console.log(rsi); // 65.5
+
+// Calculate MACD with component selection
+const macdSignal = service.calculate(
+  'macd_12_26_9', 
+  ohlcvData, 
+  { component: 'signal' }
+);
+console.log(macdSignal); // 0.3 (just the signal line)
+```
+
+## Input/Output Types
+
+### Input Types
+
+**Individual Functions:**
+- **Price arrays**: `number[]` - Array of closing prices, highs, lows, etc.
+- **Volume arrays**: `number[]` - Array of volume values
+- **Parameters**: `TAParams` - Object containing indicator-specific parameters
+
+**TechnicalAnalysisService:**
+- **Data**: `OHLCV[]` - Array of OHLCV objects
+  ```typescript
+  interface OHLCV {
+    timestamp: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume: number;
+  }
+  ```
+- **Indicator**: `string` - Indicator name with parameters (e.g., `"rsi_14"`, `"macd_12_26_9"`)
+- **Params**: `TAParams & { component?: string }` - Additional parameters and optional component selector
+
+### Output Types
+
+**Single Value Indicators** (return `number`):
+- RSI, EMA, SMA, ATR, ADX, OBV, CCI, MFI, VWAP, WilliamsR, ROC, PSAR, WMA
+
+**Multi-Value Indicators** (return `number[]`):
+- **MACD**: `[MACD, signal, histogram]`
+- **Bollinger Bands**: `[upper, middle, lower]`
+- **Stochastic**: `[%K, %D]`
+- **Stochastic RSI**: `[%K, %D]`
+- **Keltner Channels**: `[upper, lower, middle]`
+
+### Examples
+
+```typescript
+// Single value output
+const rsi: number = calculateRSI([100, 102, 101, 105, 107], { period: 5 });
+// Result: 65.5
+
+// Array output - MACD
+const macd: number[] = calculateMACD(closes, {
+  fastPeriod: 12,
+  slowPeriod: 26,
+  signalPeriod: 9
+});
+// Result: [0.5, 0.3, 0.2]
+
+// Array output - Bollinger Bands
+const bb: number[] = calculateBollingerBands(closes, {
+  period: 20,
+  stdDev: 2
+});
+// Result: [110.5, 105.0, 99.5] // [upper, middle, lower]
+
+// Using component selector with service
+const upperBand: number = service.calculate(
+  'bb_20_2',
+  ohlcvData,
+  { component: 'upper' }
+);
+// Result: 110.5 (just the upper band)
+```
+
+## Available Indicators
+
+- **SMA** (Simple Moving Average) - `calculateSMA`
+- **EMA** (Exponential Moving Average) - `calculateEMA`
+- **RSI** (Relative Strength Index) - `calculateRSI`
+- **MACD** (Moving Average Convergence Divergence) - `calculateMACD`
+- **ATR** (Average True Range) - `calculateATR`
+- **Bollinger Bands** - `calculateBollingerBands`
+- **ADX** (Average Directional Index) - `calculateADX`
+- **Stochastic** - `calculateStochastic`
+- **OBV** (On-Balance Volume) - `calculateOBV`
+- **CCI** (Commodity Channel Index) - `calculateCCI`
+- **MFI** (Money Flow Index) - `calculateMFI`
+- **VWAP** (Volume Weighted Average Price) - `calculateVWAP`
+- **Williams %R** - `calculateWilliamsR`
+- **Stochastic RSI** - `calculateStochasticRSI`
+- **ROC** (Rate of Change) - `calculateROC`
+- **Parabolic SAR** - `calculateParabolicSAR`
+- **Keltner Channels** - `calculateKeltnerChannels`
+- **WMA** (Weighted Moving Average) - `calculateWMA`
+
+## Adding New Technical Indicators
+
+Follow this checklist when adding a new technical indicator:
+
+### 1. Update Indicator Lists
+- [ ] Add indicator name to `supportedIndicators` array in `src/indicators/index.ts`
+- [ ] If indicator has multiple components (e.g., MACD, Bollinger Bands), add entry to `availableComponents` object
+
+### 2. Implement Calculation Function
+- [ ] Create `calculate[IndicatorName]` function in `src/indicators/index.ts`
+- [ ] Define function signature with appropriate input arrays and `TAParams`
+- [ ] Return type: `number` for single value, `number[]` for multi-value indicators
+- [ ] Add parameter validation (check required params, minimum data length)
+- [ ] Use `technicalindicators` library for calculation
+- [ ] Return the last calculated value (for single) or array of values (for multi-value)
+
+### 3. Integrate with Service
+- [ ] Add case in `calculate()` method switch statement in `src/index.ts`
+- [ ] Handle component selection if indicator has multiple components
+- [ ] Extract appropriate price arrays (closes, highs, lows, volumes) from OHLCV data
+
+### 4. Add Parameter Extraction
+- [ ] Add case in `extractIndicatorParams()` method if indicator uses parameterized naming (e.g., `rsi_14`)
+- [ ] Parse parameters from indicator string format
+- [ ] Return base indicator name and extracted parameters
+
+### 5. Testing & Documentation
+- [ ] Test with sample data
+- [ ] Verify error handling for insufficient data
+- [ ] Update this README with the new indicator
+- [ ] Add example usage in README
+
+### Example: Adding a New Indicator
+
+```typescript
+// 1. Add to supportedIndicators
+export const supportedIndicators = [..., "newindicator"] as const;
+
+// 2. Implement function
+export function calculateNewIndicator(
+  closes: number[],
+  params: TAParams
+): number {
+  const period = params.period;
+  if (!period) {
+    throw new Error("Period is required for NewIndicator");
+  }
+  if (closes.length < period) {
+    throw new Error(`Insufficient data: need ${period}, got ${closes.length}`);
+  }
+  const values = TI.NewIndicator.calculate({ values: closes, period });
+  const last = values[values.length - 1];
+  if (!last) {
+    throw new Error("Failed to calculate NewIndicator");
+  }
+  return last;
+}
+
+// 3. Add to service switch
+case "newindicator":
+  return calculateNewIndicator(closes, finalParams);
+
+// 4. Add parameter extraction if needed
+case "newindicator":
+  if (!parts || !parts[0])
+    throw new Error(`Period is required for newindicator`);
+  return { base, params: { period: parseInt(parts[0]) } };
+```
+
+## Development
+
+```bash
+# Install dependencies
+pnpm install
+
+# Build the package
+pnpm build
+
+# Watch mode
+pnpm build:watch
+
+# Type check
+pnpm type-check
+
+# Lint
+pnpm lint
+```
+
+## License
+
+MIT
+

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+import { Logger } from "@osiris-ai/logger";
+import { OHLCV, TAParams } from "./types";
+export declare class TechnicalAnalysisService {
+    private logger;
+    constructor(config: {
+        logger: Logger;
+    });
+    calculate(indicator: string, data: OHLCV[], params: TAParams & {
+        component?: string;
+    }): number | number[];
+    private extractIndicatorParams;
+}
+export * from "./indicators/index";
+export * from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,688 @@
+import * as TI from 'technicalindicators';
+
+// @osiris-ai/technical-indicators - Technical Indicators Library
+
+var supportedIndicators = ["rsi", "ema", "sma", "atr", "macd", "bb", "wma", "adx", "stochastic", "obv", "cci", "mfi", "vwap", "williamsr", "stochasticrsi", "roc", "psar", "keltnerchannels"];
+var availableComponents = {
+  rsi: ["rsi"],
+  ema: ["ema"],
+  sma: ["sma"],
+  atr: ["atr"],
+  macd: ["macd", "signal", "histogram"],
+  bb: ["upper", "middle", "lower"],
+  wma: ["wma"],
+  adx: ["adx"],
+  stochastic: ["stochastic", "k", "d"],
+  obv: ["obv"],
+  cci: ["cci"],
+  mfi: ["mfi"],
+  vwap: ["vwap"],
+  williamsr: ["williamsr"],
+  stochasticrsi: ["stochasticrsi", "k", "d"],
+  roc: ["roc"],
+  psar: ["psar"],
+  keltnerchannels: ["keltnerchannels", "upper", "middle", "lower"]
+};
+function calculateRSI(closes, params) {
+  const period = params.period;
+  if (!period) {
+    throw new Error("Period is required for RSI");
+  }
+  if (closes.length < period) {
+    throw new Error(
+      `Insufficient data for RSI: need ${period}, got ${closes.length}`
+    );
+  }
+  const values = TI.RSI.calculate({ values: closes, period });
+  const last = values[values.length - 1];
+  if (!last) {
+    throw new Error("Failed to calculate RSI");
+  }
+  return last;
+}
+function calculateEMA(closes, params) {
+  const period = params.period;
+  if (!period) {
+    throw new Error("Period is required for EMA");
+  }
+  if (closes.length < period) {
+    throw new Error(
+      `Insufficient data for EMA: need ${period}, got ${closes.length}`
+    );
+  }
+  const values = TI.EMA.calculate({ values: closes, period });
+  if (!values || values.length === 0) {
+    throw new Error(`Failed to calculate EMA: library returned empty array. Input length: ${closes.length}, period: ${period}`);
+  }
+  const last = values[values.length - 1];
+  if (last === void 0 || last === null || isNaN(last)) {
+    throw new Error(`Failed to calculate EMA: invalid result. Array length: ${values.length}, last value: ${last}`);
+  }
+  return last;
+}
+function calculateSMA(closes, params) {
+  const period = params.period;
+  if (!period) {
+    throw new Error("Period is required for SMA");
+  }
+  if (closes.length < period) {
+    throw new Error(
+      `Insufficient data for SMA: need ${period}, got ${closes.length}`
+    );
+  }
+  const values = TI.SMA.calculate({ values: closes, period });
+  if (!values || values.length === 0) {
+    throw new Error(`Failed to calculate SMA: library returned empty array. Input length: ${closes.length}, period: ${period}`);
+  }
+  const last = values[values.length - 1];
+  if (last === void 0 || last === null || isNaN(last)) {
+    throw new Error(`Failed to calculate SMA: invalid result. Array length: ${values.length}, last value: ${last}`);
+  }
+  return last;
+}
+function calculateATR(highs, lows, closes, params) {
+  const period = params.period;
+  if (!period) {
+    throw new Error("Period is required for ATR");
+  }
+  if (closes.length < period) {
+    throw new Error(
+      `Insufficient data for ATR: need ${period}, got ${closes.length}`
+    );
+  }
+  const values = TI.ATR.calculate({
+    high: highs,
+    low: lows,
+    close: closes,
+    period
+  });
+  const last = values[values.length - 1];
+  if (!last) {
+    throw new Error("Failed to calculate ATR");
+  }
+  return last;
+}
+function calculateMACD(closes, params) {
+  const { fastPeriod, slowPeriod, signalPeriod } = params;
+  if (!fastPeriod) {
+    throw new Error("Fast period is required for MACD");
+  }
+  if (!slowPeriod) {
+    throw new Error("Slow period is required for MACD");
+  }
+  if (!signalPeriod) {
+    throw new Error("Signal period is required for MACD");
+  }
+  const minBars = Math.max(fastPeriod, slowPeriod) + signalPeriod;
+  if (closes.length < minBars) {
+    throw new Error(
+      `Insufficient data for MACD: need ${minBars}, got ${closes.length}`
+    );
+  }
+  const values = TI.MACD.calculate({
+    values: closes,
+    fastPeriod,
+    slowPeriod,
+    signalPeriod,
+    SimpleMAOscillator: false,
+    SimpleMASignal: false
+  });
+  if (!values || values.length === 0) {
+    throw new Error(`Failed to calculate MACD: library returned empty array. Input length: ${closes.length}, fastPeriod: ${fastPeriod}, slowPeriod: ${slowPeriod}, signalPeriod: ${signalPeriod}`);
+  }
+  const last = values[values.length - 1];
+  if (!last || !last.MACD || !last.signal || !last.histogram) {
+    throw new Error(`Failed to calculate MACD: invalid result. Array length: ${values.length}, last value: ${JSON.stringify(last)}`);
+  }
+  return [last.MACD, last.signal, last.histogram];
+}
+function calculateBollingerBands(closes, params) {
+  const period = params.period;
+  if (!period) {
+    throw new Error("Period is required for Bollinger Bands");
+  }
+  const stdDev = params.stdDev;
+  if (!stdDev) {
+    throw new Error("Standard deviation is required for Bollinger Bands");
+  }
+  if (closes.length < period) {
+    throw new Error(
+      `Insufficient data for Bollinger Bands: need ${period}, got ${closes.length}`
+    );
+  }
+  const values = TI.BollingerBands.calculate({
+    values: closes,
+    period,
+    stdDev
+  });
+  if (!values || values.length === 0) {
+    throw new Error(`Failed to calculate Bollinger Bands: library returned empty array. Input length: ${closes.length}, period: ${period}, stdDev: ${stdDev}`);
+  }
+  const last = values[values.length - 1];
+  if (!last || !last.upper || !last.middle || !last.lower) {
+    throw new Error(`Failed to calculate Bollinger Bands: invalid result. Array length: ${values.length}, last value: ${JSON.stringify(last)}`);
+  }
+  return [last.upper, last.middle, last.lower];
+}
+function calculateADX(highs, lows, closes, params) {
+  const period = params.period;
+  if (!period) {
+    throw new Error("Period is required for ADX");
+  }
+  const minBars = period * 2;
+  if (closes.length < minBars) {
+    throw new Error(
+      `Insufficient data for ADX: need ${minBars}, got ${closes.length}`
+    );
+  }
+  const values = TI.ADX.calculate({
+    high: highs,
+    low: lows,
+    close: closes,
+    period
+  });
+  const last = values[values.length - 1];
+  if (!last || !last.adx) {
+    throw new Error("Failed to calculate ADX");
+  }
+  return last.adx;
+}
+function calculateStochastic(highs, lows, closes, params) {
+  const period = params.period;
+  if (!period) {
+    throw new Error("Period is required for Stochastic");
+  }
+  const signalPeriod = params.signalPeriod;
+  if (!signalPeriod) {
+    throw new Error("Signal period is required for Stochastic");
+  }
+  const minBars = period + signalPeriod;
+  if (closes.length < minBars) {
+    throw new Error(
+      `Insufficient data for Stochastic: need ${minBars}, got ${closes.length}`
+    );
+  }
+  const values = TI.Stochastic.calculate({
+    high: highs,
+    low: lows,
+    close: closes,
+    period,
+    signalPeriod
+  });
+  const last = values[values.length - 1];
+  if (!last || !last.k || !last.d) {
+    throw new Error("Failed to calculate Stochastic");
+  }
+  return [last.k, last.d];
+}
+function calculateOBV(closes, volumes, params) {
+  if (closes.length < 2) {
+    throw new Error(
+      `Insufficient data for OBV: need at least 2 candles, got ${closes.length}`
+    );
+  }
+  const values = TI.OBV.calculate({ close: closes, volume: volumes });
+  const last = values[values.length - 1];
+  if (!last) {
+    throw new Error("Failed to calculate OBV");
+  }
+  return last;
+}
+function calculateCCI(highs, lows, closes, params) {
+  const period = params.period;
+  if (!period) {
+    throw new Error("Period is required for CCI");
+  }
+  if (closes.length < period) {
+    throw new Error(
+      `Insufficient data for CCI: need ${period}, got ${closes.length}`
+    );
+  }
+  const values = TI.CCI.calculate({
+    high: highs,
+    low: lows,
+    close: closes,
+    period
+  });
+  const last = values[values.length - 1];
+  if (!last) {
+    throw new Error("Failed to calculate CCI");
+  }
+  return last;
+}
+function calculateMFI(highs, lows, closes, volumes, params) {
+  const period = params.period;
+  if (!period) {
+    throw new Error("Period is required for MFI");
+  }
+  if (closes.length < period) {
+    throw new Error(
+      `Insufficient data for MFI: need ${period}, got ${closes.length}`
+    );
+  }
+  const values = TI.MFI.calculate({
+    high: highs,
+    low: lows,
+    close: closes,
+    volume: volumes,
+    period
+  });
+  const last = values[values.length - 1];
+  if (!last) {
+    throw new Error("Failed to calculate MFI");
+  }
+  return last;
+}
+function calculateVWAP(highs, lows, closes, volumes, params) {
+  if (closes.length === 0) {
+    throw new Error("Insufficient data for VWAP");
+  }
+  const values = TI.VWAP.calculate({
+    high: highs,
+    low: lows,
+    close: closes,
+    volume: volumes
+  });
+  if (!values || values.length === 0) {
+    throw new Error(`Failed to calculate VWAP: library returned empty array. Input length: ${closes.length}`);
+  }
+  const last = values[values.length - 1];
+  if (last === void 0 || last === null || isNaN(last)) {
+    throw new Error(`Failed to calculate VWAP: invalid result. Array length: ${values.length}, last value: ${last}`);
+  }
+  return last;
+}
+function calculateWilliamsR(highs, lows, closes, params) {
+  const period = params.period;
+  if (!period) {
+    throw new Error("Period is required for Williams %R");
+  }
+  if (closes.length < period) {
+    throw new Error(
+      `Insufficient data for Williams %R: need ${period}, got ${closes.length}`
+    );
+  }
+  const values = TI.WilliamsR.calculate({
+    high: highs,
+    low: lows,
+    close: closes,
+    period
+  });
+  const last = values[values.length - 1];
+  if (!last) {
+    throw new Error("Failed to calculate Williams %R");
+  }
+  return last;
+}
+function calculateStochasticRSI(closes, params) {
+  const rsiPeriod = params.rsiPeriod;
+  const stochasticPeriod = params.stochasticPeriod;
+  const kPeriod = params.kPeriod;
+  const dPeriod = params.dPeriod;
+  if (!rsiPeriod) {
+    throw new Error("RSI period is required for Stochastic RSI");
+  }
+  if (!stochasticPeriod) {
+    throw new Error("Stochastic period is required for Stochastic RSI");
+  }
+  if (!kPeriod) {
+    throw new Error("K period is required for Stochastic RSI");
+  }
+  if (!dPeriod) {
+    throw new Error("D period is required for Stochastic RSI");
+  }
+  const minBars = Math.max(rsiPeriod, stochasticPeriod) + kPeriod + dPeriod;
+  if (closes.length < minBars) {
+    throw new Error(
+      `Insufficient data for Stochastic RSI: need ${minBars}, got ${closes.length}`
+    );
+  }
+  const values = TI.StochasticRSI.calculate({
+    values: closes,
+    rsiPeriod,
+    stochasticPeriod,
+    kPeriod,
+    dPeriod
+  });
+  const last = values[values.length - 1];
+  if (!last || !last.k || !last.d) {
+    throw new Error("Failed to calculate Stochastic RSI");
+  }
+  return [last.k, last.d];
+}
+function calculateROC(closes, params) {
+  const period = params.period;
+  if (!period) {
+    throw new Error("Period is required for ROC");
+  }
+  if (closes.length < period + 1) {
+    throw new Error(
+      `Insufficient data for ROC: need ${period + 1}, got ${closes.length}`
+    );
+  }
+  const values = TI.ROC.calculate({ values: closes, period });
+  const last = values[values.length - 1];
+  if (!last) {
+    throw new Error("Failed to calculate ROC");
+  }
+  return last;
+}
+function calculateParabolicSAR(highs, lows, params) {
+  const step = params.step;
+  const max = params.max;
+  if (!step) {
+    throw new Error("Step is required for Parabolic SAR");
+  }
+  if (!max) {
+    throw new Error("Max is required for Parabolic SAR");
+  }
+  if (highs.length < 2) {
+    throw new Error(
+      `Insufficient data for Parabolic SAR: need at least 2 candles, got ${highs.length}`
+    );
+  }
+  const values = TI.PSAR.calculate({
+    high: highs,
+    low: lows,
+    step,
+    max
+  });
+  if (!values || values.length === 0) {
+    throw new Error(`Failed to calculate Parabolic SAR: library returned empty array. Input length: ${highs.length}, step: ${step}, max: ${max}`);
+  }
+  const last = values[values.length - 1];
+  if (last === void 0 || last === null || isNaN(last)) {
+    throw new Error(`Failed to calculate Parabolic SAR: invalid result. Array length: ${values.length}, last value: ${last}`);
+  }
+  return last;
+}
+function calculateKeltnerChannels(highs, lows, closes, params) {
+  const maPeriod = params.maPeriod;
+  const multiplier = params.multiplier;
+  const atrPeriod = params.atrPeriod;
+  if (!maPeriod) {
+    throw new Error("MA period is required for Keltner Channels");
+  }
+  if (!multiplier) {
+    throw new Error("Multiplier is required for Keltner Channels");
+  }
+  if (!atrPeriod) {
+    throw new Error("ATR period is required for Keltner Channels");
+  }
+  const minBars = Math.max(maPeriod, atrPeriod);
+  if (closes.length < minBars) {
+    throw new Error(
+      `Insufficient data for Keltner Channels: need ${minBars}, got ${closes.length}`
+    );
+  }
+  const values = TI.KeltnerChannels.calculate({
+    high: highs,
+    low: lows,
+    close: closes,
+    maPeriod,
+    multiplier,
+    atrPeriod,
+    useSMA: false
+  });
+  if (!values || values.length === 0) {
+    throw new Error(`Failed to calculate Keltner Channels: library returned empty array. Input length: ${closes.length}, maPeriod: ${maPeriod}, multiplier: ${multiplier}, atrPeriod: ${atrPeriod}`);
+  }
+  const last = values[values.length - 1];
+  if (!last || !last.upper || !last.lower || !last.middle) {
+    throw new Error(`Failed to calculate Keltner Channels: invalid result. Array length: ${values.length}, last value: ${JSON.stringify(last)}`);
+  }
+  return [last.upper, last.lower, last.middle];
+}
+function calculateWMA(closes, params) {
+  const period = params.period;
+  if (!period) {
+    throw new Error("Period is required for WMA");
+  }
+  if (closes.length < period) {
+    throw new Error(
+      `Insufficient data for WMA: need ${period}, got ${closes.length}`
+    );
+  }
+  const values = TI.WMA.calculate({ values: closes, period });
+  const last = values[values.length - 1];
+  if (!last) {
+    throw new Error("Failed to calculate WMA");
+  }
+  return last;
+}
+
+// src/index.ts
+var TechnicalAnalysisService = class {
+  logger;
+  constructor(config) {
+    this.logger = config.logger;
+  }
+  calculate(indicator, data, params) {
+    try {
+      this.logger.info("Calculating technical indicator", { indicator, params });
+      if (!data || data.length === 0) {
+        throw new Error("No OHLCV data provided for TA calculation");
+      }
+      const closes = data.map((d) => Number(d.close));
+      const highs = data.map((d) => Number(d.high));
+      const lows = data.map((d) => Number(d.low));
+      const volumes = data.map((d) => Number(d.volume));
+      const component = params.component;
+      const paramsWithoutComponent = { ...params };
+      delete paramsWithoutComponent.component;
+      const { base, params: extractedParams } = this.extractIndicatorParams(indicator);
+      const finalParams = { ...extractedParams, ...paramsWithoutComponent };
+      switch (base) {
+        case "rsi":
+          return calculateRSI(closes, finalParams);
+        case "ema":
+          return calculateEMA(closes, finalParams);
+        case "sma":
+          return calculateSMA(closes, finalParams);
+        case "atr":
+          return calculateATR(highs, lows, closes, finalParams);
+        case "macd": {
+          const result = calculateMACD(closes, finalParams);
+          if (component && !availableComponents.macd.includes(component)) {
+            throw new Error(`Invalid component for MACD: ${component}`);
+          }
+          if (component === "signal") {
+            return result[1] ?? 0;
+          } else if (component === "macd") {
+            return result[0] ?? 0;
+          } else if (component === "histogram") {
+            return result[2] ?? 0;
+          }
+          return result;
+        }
+        case "bb": {
+          const result = calculateBollingerBands(closes, finalParams);
+          if (component && !availableComponents.bb.includes(component)) {
+            throw new Error(`Invalid component for Bollinger Bands: ${component}`);
+          }
+          if (component === "lower") {
+            return result[2] ?? 0;
+          } else if (component === "upper") {
+            return result[0] ?? 0;
+          } else if (component === "middle") {
+            return result[1] ?? 0;
+          }
+          return result;
+        }
+        case "adx":
+          return calculateADX(highs, lows, closes, finalParams);
+        case "stochastic": {
+          const result = calculateStochastic(highs, lows, closes, finalParams);
+          if (component && !availableComponents.stochastic.includes(component)) {
+            throw new Error(`Invalid component for Stochastic: ${component}`);
+          }
+          if (component === "d") {
+            return result[1] ?? 0;
+          } else if (component === "k") {
+            return result[0] ?? 0;
+          }
+          return result;
+        }
+        case "obv":
+          return calculateOBV(closes, volumes, finalParams);
+        case "cci":
+          return calculateCCI(highs, lows, closes, finalParams);
+        case "mfi":
+          return calculateMFI(highs, lows, closes, volumes, finalParams);
+        case "vwap":
+          return calculateVWAP(highs, lows, closes, volumes, finalParams);
+        case "williamsr":
+          return calculateWilliamsR(highs, lows, closes, finalParams);
+        case "stochasticrsi": {
+          const result = calculateStochasticRSI(closes, finalParams);
+          if (component && !availableComponents.stochasticrsi.includes(component)) {
+            throw new Error(`Invalid component for Stochastic RSI: ${component}`);
+          }
+          if (component === "k") {
+            return result[0] ?? 0;
+          } else if (component === "d") {
+            return result[1] ?? 0;
+          }
+          return result;
+        }
+        case "roc":
+          return calculateROC(closes, finalParams);
+        case "psar":
+          return calculateParabolicSAR(highs, lows, finalParams);
+        case "keltnerchannels": {
+          const result = calculateKeltnerChannels(highs, lows, closes, finalParams);
+          if (component && !availableComponents.keltnerchannels.includes(component)) {
+            throw new Error(`Invalid component for Keltner Channels: ${component}`);
+          }
+          if (component === "upper") {
+            return result[0] ?? 0;
+          } else if (component === "lower") {
+            return result[1] ?? 0;
+          } else if (component === "middle") {
+            return result[2] ?? 0;
+          }
+          return result;
+        }
+        case "wma":
+          return calculateWMA(closes, finalParams);
+        default:
+          throw new Error(`Unsupported technical indicator: ${indicator}`);
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const errorStack = error instanceof Error ? error.stack : void 0;
+      this.logger.error("Error calculating technical indicator", {
+        indicator,
+        params,
+        error: errorMessage,
+        stack: errorStack
+      });
+      throw error;
+    }
+  }
+  extractIndicatorParams(indicator) {
+    const cleanIndicator = indicator.startsWith("ta_") ? indicator.substring(3) : indicator;
+    if (cleanIndicator === "vwap") {
+      return { base: "vwap", params: {} };
+    }
+    const match = cleanIndicator.match(/^([a-z]+)_(.+)$/);
+    if (!match) {
+      throw new Error(`Invalid indicator format: ${indicator}`);
+    }
+    const base = match[1];
+    if (!base || !supportedIndicators.includes(base)) {
+      throw new Error(`Base indicator not found: ${indicator}`);
+    }
+    const parts = match[2]?.split("_");
+    switch (base) {
+      case "rsi":
+      case "ema":
+      case "sma":
+      case "atr":
+        if (!parts || !parts[0])
+          throw new Error(`Period is required for ${base}`);
+        return { base, params: { period: parseInt(parts[0]) } };
+      case "macd":
+        if (!parts || (!parts[0] || !parts[1] || !parts[2]))
+          throw new Error(`MACD requires 3 params: ${indicator}`);
+        return {
+          base,
+          params: {
+            fastPeriod: parseInt(parts[0]),
+            slowPeriod: parseInt(parts[1]),
+            signalPeriod: parseInt(parts[2])
+          }
+        };
+      case "bb":
+        if (!parts || !parts[0] || !parts[1])
+          throw new Error(`BB requires 2 params: ${indicator}`);
+        return {
+          base,
+          params: {
+            period: parseInt(parts[0]),
+            stdDev: parseFloat(parts[1])
+          }
+        };
+      case "stochastic":
+        if (!parts || !parts[0] || !parts[1])
+          throw new Error(`Stoch requires 2 params: ${indicator}`);
+        return {
+          base,
+          params: {
+            period: parseInt(parts[0]),
+            signalPeriod: parseInt(parts[1])
+          }
+        };
+      case "adx":
+        if (!parts || !parts[0])
+          throw new Error(`Period is required for ${base}`);
+        return { base, params: { period: parseInt(parts[0]) } };
+      case "roc":
+      case "wma":
+        if (!parts || !parts[0])
+          throw new Error(`Period is required for ${base}`);
+        return { base, params: { period: parseInt(parts[0]) } };
+      case "stochasticrsi":
+        if (!parts || !parts[0] || !parts[1] || !parts[2] || !parts[3])
+          throw new Error(`Stochastic RSI requires 4 params: ${indicator}`);
+        return {
+          base,
+          params: {
+            rsiPeriod: parseInt(parts[0]),
+            stochasticPeriod: parseInt(parts[1]),
+            kPeriod: parseInt(parts[2]),
+            dPeriod: parseInt(parts[3])
+          }
+        };
+      case "psar":
+        if (!parts || !parts[0] || !parts[1])
+          throw new Error(`Parabolic SAR requires 2 params: ${indicator}`);
+        return {
+          base,
+          params: {
+            step: parseFloat(parts[0]),
+            max: parseFloat(parts[1])
+          }
+        };
+      case "keltnerchannels":
+        if (!parts || !parts[0] || !parts[1] || !parts[2])
+          throw new Error(`Keltner Channels requires 3 params: ${indicator}`);
+        return {
+          base,
+          params: {
+            maPeriod: parseInt(parts[0]),
+            multiplier: parseFloat(parts[1]),
+            atrPeriod: parseInt(parts[2])
+          }
+        };
+      case "vwap":
+        return { base, params: {} };
+      default:
+        throw new Error(`Unknown indicator: ${base}`);
+    }
+  }
+};
+
+export { TechnicalAnalysisService, availableComponents, calculateADX, calculateATR, calculateBollingerBands, calculateCCI, calculateEMA, calculateKeltnerChannels, calculateMACD, calculateMFI, calculateOBV, calculateParabolicSAR, calculateROC, calculateRSI, calculateSMA, calculateStochastic, calculateStochasticRSI, calculateVWAP, calculateWMA, calculateWilliamsR, supportedIndicators };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/indicators/index.d.ts

@@ -0,0 +1,41 @@
+import { TAParams } from "../types";
+export declare const supportedIndicators: readonly ["rsi", "ema", "sma", "atr", "macd", "bb", "wma", "adx", "stochastic", "obv", "cci", "mfi", "vwap", "williamsr", "stochasticrsi", "roc", "psar", "keltnerchannels"];
+export declare const availableComponents: {
+    rsi: string[];
+    ema: string[];
+    sma: string[];
+    atr: string[];
+    macd: string[];
+    bb: string[];
+    wma: string[];
+    adx: string[];
+    stochastic: string[];
+    obv: string[];
+    cci: string[];
+    mfi: string[];
+    vwap: string[];
+    williamsr: string[];
+    stochasticrsi: string[];
+    roc: string[];
+    psar: string[];
+    keltnerchannels: string[];
+};
+export declare function calculateRSI(closes: number[], params: TAParams): number;
+export declare function calculateEMA(closes: number[], params: TAParams): number;
+export declare function calculateSMA(closes: number[], params: TAParams): number;
+export declare function calculateATR(highs: number[], lows: number[], closes: number[], params: TAParams): number;
+export declare function calculateMACD(closes: number[], params: TAParams): number[];
+export declare function calculateBollingerBands(closes: number[], params: TAParams): number[];
+export declare function calculateADX(highs: number[], lows: number[], closes: number[], params: TAParams): number;
+export declare function calculateStochastic(highs: number[], lows: number[], closes: number[], params: TAParams): number[];
+export declare function calculateOBV(closes: number[], volumes: number[], params: TAParams): number;
+export declare function calculateCCI(highs: number[], lows: number[], closes: number[], params: TAParams): number;
+export declare function calculateMFI(highs: number[], lows: number[], closes: number[], volumes: number[], params: TAParams): number;
+export declare function calculateVWAP(highs: number[], lows: number[], closes: number[], volumes: number[], params: TAParams): number;
+export declare function calculateWilliamsR(highs: number[], lows: number[], closes: number[], params: TAParams): number;
+export declare function calculateStochasticRSI(closes: number[], params: TAParams): number[];
+export declare function calculateROC(closes: number[], params: TAParams): number;
+export declare function calculateParabolicSAR(highs: number[], lows: number[], params: TAParams): number;
+export declare function calculateKeltnerChannels(highs: number[], lows: number[], closes: number[], params: TAParams): number[];
+export declare function calculateWMA(closes: number[], params: TAParams): number;
+//# sourceMappingURL=index.d.ts.map

package/dist/types.d.ts

@@ -0,0 +1,11 @@
+export interface TAParams extends Record<string, any> {
+}
+export interface OHLCV {
+    timestamp: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@vesper85/technical-indicators",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Technical indicators library for financial analysis",
+  "keywords": [
+    "technical-indicators",
+    "trading",
+    "finance",
+    "indicators",
+    "ta",
+    "technical-analysis"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "!**/*.map"
+  ],
+  "sideEffects": false,
+  "license": "MIT",
+  "scripts": {
+    "build": "tsup && npm run types",
+    "types": "tsc --emitDeclarationOnly --declaration --outDir dist",
+    "build:watch": "tsup --watch",
+    "dev": "tsup --watch",
+    "lint": "eslint \"src/**/*.ts*\"",
+    "lint:fix": "eslint \"src/**/*.ts*\" --fix",
+    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist",
+    "type-check": "tsc --noEmit",
+    "test:service": "tsx test-ta-service.ts",
+    "prepublishOnly": "npm run build",
+    "changeset": "changeset",
+    "version": "changeset version",
+    "release": "npm run build && changeset publish"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.29.8",
+    "@osiris-ai/eslint-config": "workspace:*",
+    "@osiris-ai/typescript-config": "workspace:*",
+    "@types/node": "^24.0.8",
+    "eslint": "^8.37.0",
+    "tsup": "^8.5.0",
+    "tsx": "^4.19.2",
+    "typescript": "^5.8.3"
+  },
+  "dependencies": {
+    "@osiris-ai/logger": "workspace:*",
+    "technicalindicators": "^3.1.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/FetcchX/legion-sdk.git"
+  },
+  "bugs": {
+    "url": "https://github.com/FetcchX/legion-sdk/issues"
+  },
+  "homepage": "https://github.com/FetcchX/legion-sdk#readme"
+}