This repository is a comprehensive, production-oriented algorithmic trading framework implemented in TypeScript. It is organized as a monorepo with six interdependent packages: `trading-signals` (100+ technical indicator implementations with streaming `add`/`replace` semantics, each verified against external reference data like Tulip Indicators and Skender.Stock.Indicators), `trading-strategies` (strategy base classes, concrete strategies such as SMA crossover, scalp, trailing stop, and a multi-indicator confluence strategy, plus a backtesting engine and report generators), `exchange` (abstract broker interface with real implementations for Alpaca and Trading212, including mock broker for backtesting, candle batching, WebSocket streaming, and a CLI tool), `messaging` (a Telegram bot for managing accounts, strategies, watches, and reports via multi-step wizards), `candles` (labeled historical candle datasets for testing), and `trading-signals-docs` (a Next.js documentation site with interactive indicator demos and a visual backtester). The architecture emphasizes clean separation between signal generation, strategy logic, broker execution, and user interface. The indicator library is the core asset, providing a consistent contract (`IndicatorSeries`, `TechnicalIndicator`, `TrendIndicator`) with rich signal detection and state rollback. The strategy framework supports live trading and backtesting via the same advice-execution pipeline. The project is actively maintained with CI/CD, mutation testing, and a well-defined broker integration template. While the codebase shows high craftsmanship in its indicator implementations and test patterns, the large number of indicators and hand-derived test fixtures introduce maintenance overhead, and the tight coupling to Telegram limits platform portability.
This repository is a zero-dependency JavaScript library for detecting 18 candlestick patterns (29 variants) in financial OHLC data. It provides a consistent API per pattern (boolean check and array scanner), a multi-pattern scanner with optional trend context for confidence adjustment, a streaming API for memory-efficient processing of large datasets, a plugin system for custom patterns, and a CLI tool for quick analysis. The library supports both CommonJS and ES Modules, includes TypeScript definitions, and is extensively tested with unit, integration, and property-based tests. It is designed for use in trading systems, backtesting, and algorithmic trading applications.
This is a Python library for technical analysis of financial markets based on 'Chan Theory' (įž čŪš). It computes complex structural elements such as fractals, strokes (bi), line segments, trading ranges (zhongshu), and buy/sell points from candlestick data. The library supports multiple data sources (BaoStock, Akshare, CSV, CCXT), multi-level analysis, customizable algorithms, and plotting via Matplotlib. The code is well-structured with clear separation of concerns, extensive use of caching for performance, and a flexible configuration system. It includes a GUI scanner application for A-shares and demo strategies. The library is designed for both research and production use, with incremental calculation capabilities for real-time updates. While the open-source version omits trading engine and ML features described in the full version, the core analytical engine is robust and reusable.
This repository is a Node.js wrapper for the TA-Lib (Technical Analysis Library) C library, providing access to technical analysis functions for financial market data. It enables Node.js applications to calculate indicators like SMA, EMA, RSI, MACD, Bollinger Bands, and dozens of candlestick patterns. The architecture uses node-gyp to compile the TA-Lib C library into a native Node.js module, with a JavaScript/TypeScript interface that supports both callback-based async and synchronous execution. Key entry points include index.js (main interface), index.d.ts (TypeScript definitions), and various usage examples. The repository demonstrates strong engineering in its cross-platform build system, clean wrapper pattern for the native addon, and high-quality TypeScript definitions that accurately represent the complex TA-Lib API.
This repository is a curated list (awesome-list) of open-source quantitative finance libraries, packages, and resources. It provides a structured README.md organized by category, with inline language tags, and a pipeline that parses the list, enriches it with GitHub metadata (stars, last commit dates), and generates a static website deployed to GitHub Pages. The repo also includes automated tooling for pull-request review: a validation script that checks entry format, section placement, URL security, duplicate detection, and a full CI-driven PR review workflow. The core logic resides in parse.py (multi-threaded GitHub API enrichment), site/generate.py (static site generator), scripts/validate_readme.py (entry validation), and scripts/review_pr.py (automated PR review with offline URL reachability checks and cross-PR duplicate detection). The project is primarily a reference list, not an application or data pipeline, but it includes high-quality supporting tooling for maintainers and contributors.
PA Agent is a desktop application (PyQt6) that combines Al Brooks' price action theory with large language models (DeepSeek, MiMo, QClaw, etc.) to generate two-stage trading analysis: Stage 1 diagnoses market structure (cycle, pattern, direction), Stage 2 produces a trading decision (order type, entry, stop-loss, take-profit). The system ingests K-line data from multiple sources (MT5, TradingView, East Money, Tushare, AkShare) and provides real-time charting, AI reasoning streaming, decision tree visualization, and demo replay. It includes deterministic fallback nodes for data validation, direction voting, and pattern routing, reducing reliance on LLM output consistency. The architecture is modular with a data source abstraction, AI provider abstraction, event bus, incremental indicator computation, and a two-stage orchestration pipeline with retry and validation. While the codebase is well-structured and heavily tested (unit, integration, property-based), it suffers from complexity due to many provider connectors, hardcoded normalizer heuristics, and prompt engineering files that require ongoing maintenance.