Add indicator signals feature with buy/sell/hold analysis
- Add signals-calculator.js module for calculating buy/sell/hold signals for all indicators - Integrate signals into Trend Analysis panel (renamed to Indicator Analysis) - Display individual indicator signals with badges, values, strength bars, and detailed reasoning - Add aggregate summary signal showing overall recommendation from all indicators - Support signals for RSI, MACD, Stochastic, Bollinger Bands, SMA/EMA, ATR, and HTS - Provide tooltips on hover showing indicator value, configuration, and reasoning - Ensure indicators calculate on all available candles, not just recent ones - Cache indicator calculations for performance while recalculating on historical data loads - Style improvements: monospace font, consistent button widths, reduced margins - Add AGENTS.md documentation file with project guidelines
This commit is contained in:
DiTus
@ -715,13 +715,16 @@
|
||||
margin-top: 4px;
|
||||
}
|
||||
|
||||
.ta-signal {
|
||||
.ta-signal {
|
||||
display: inline-block;
|
||||
padding: 4px 12px;
|
||||
border-radius: 4px;
|
||||
font-size: 12px;
|
||||
font-weight: 600;
|
||||
margin-top: 8px;
|
||||
margin-top: 4px;
|
||||
min-width: 60px;
|
||||
text-align: center;
|
||||
font-family: 'Courier New', monospace;
|
||||
}
|
||||
|
||||
.ta-signal.buy {
|
||||
@ -1270,11 +1273,45 @@
|
||||
}
|
||||
}
|
||||
|
||||
@media (max-width: 600px) {
|
||||
@media (max-width: 600px) {
|
||||
.ta-content {
|
||||
grid-template-columns: 1fr;
|
||||
}
|
||||
}
|
||||
|
||||
/* Signal Styles */
|
||||
.ta-summary-badge {
|
||||
background: var(--tv-bg);
|
||||
border: 1px solid var(--tv-border);
|
||||
padding: 4px 10px;
|
||||
border-radius: 4px;
|
||||
font-size: 11px;
|
||||
font-weight: 600;
|
||||
text-transform: uppercase;
|
||||
}
|
||||
|
||||
.ta-summary-badge.buy {
|
||||
background: rgba(38, 166, 154, 0.2);
|
||||
color: var(--tv-green);
|
||||
border-color: var(--tv-green);
|
||||
}
|
||||
|
||||
.ta-summary-badge.sell {
|
||||
background: rgba(239, 83, 80, 0.2);
|
||||
color: var(--tv-red);
|
||||
border-color: var(--tv-red);
|
||||
}
|
||||
|
||||
.ta-summary-badge.hold {
|
||||
background: rgba(120, 123, 134, 0.2);
|
||||
color: var(--tv-text-secondary);
|
||||
border-color: var(--tv-text-secondary);
|
||||
}
|
||||
|
||||
.signal-strength-fill {
|
||||
height: 100%;
|
||||
transition: width 0.3s ease;
|
||||
}
|
||||
</style>
|
||||
<link rel="stylesheet" href="./css/indicators-new.css">
|
||||
</head>
|
||||
|
||||
@ -1,7 +1,8 @@
|
||||
import { INTERVALS, COLORS } from '../core/index.js';
|
||||
import { calculateAllIndicatorSignals, calculateSummarySignal } from './signals-calculator.js';
|
||||
|
||||
export class TradingDashboard {
|
||||
constructor() {
|
||||
constructor() {
|
||||
this.chart = null;
|
||||
this.candleSeries = null;
|
||||
this.currentInterval = '1d';
|
||||
@ -10,6 +11,8 @@ export class TradingDashboard {
|
||||
this.isLoading = false;
|
||||
this.hasInitialLoad = false;
|
||||
this.taData = null;
|
||||
this.indicatorSignals = [];
|
||||
this.summarySignal = null;
|
||||
|
||||
this.init();
|
||||
}
|
||||
@ -286,7 +289,7 @@ export class TradingDashboard {
|
||||
|
||||
async loadInitialData() {
|
||||
await Promise.all([
|
||||
this.loadData(1000, true),
|
||||
this.loadData(2000, true),
|
||||
this.loadStats()
|
||||
]);
|
||||
this.hasInitialLoad = true;
|
||||
@ -340,14 +343,14 @@ if (data.candles && data.candles.length > 0) {
|
||||
}
|
||||
}
|
||||
|
||||
async loadNewData() {
|
||||
async loadNewData() {
|
||||
if (!this.hasInitialLoad || this.isLoading) return;
|
||||
|
||||
try {
|
||||
const response = await fetch(`/api/v1/candles?symbol=BTC&interval=${this.currentInterval}&limit=50`);
|
||||
const data = await response.json();
|
||||
|
||||
if (data.candles && data.candles.length > 0) {
|
||||
if (data.candles && data.candles.length > 0) {
|
||||
const atEdge = this.isAtRightEdge();
|
||||
|
||||
const currentSeriesData = this.candleSeries.data();
|
||||
@ -373,6 +376,8 @@ if (data.candles && data.candles.length > 0) {
|
||||
const existingData = this.allData.get(this.currentInterval) || [];
|
||||
this.allData.set(this.currentInterval, this.mergeData(existingData, chartData));
|
||||
|
||||
console.log(`[NewData Load] Added ${chartData.length} new candles, total in dataset: ${this.allData.get(this.currentInterval).length}`);
|
||||
|
||||
if (atEdge) {
|
||||
this.chart.timeScale().scrollToRealTime();
|
||||
}
|
||||
@ -380,10 +385,11 @@ if (data.candles && data.candles.length > 0) {
|
||||
const latest = chartData[chartData.length - 1];
|
||||
this.updateStats(latest);
|
||||
|
||||
// Redraw indicators when new data loads
|
||||
// Recalculate indicators and signals when new data loads
|
||||
if (window.drawIndicatorsOnChart) {
|
||||
window.drawIndicatorsOnChart();
|
||||
}
|
||||
await this.loadSignals();
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('Error loading new data:', error);
|
||||
@ -397,7 +403,7 @@ if (data.candles && data.candles.length > 0) {
|
||||
return Array.from(dataMap.values()).sort((a, b) => a.time - b.time);
|
||||
}
|
||||
|
||||
onVisibleRangeChange() {
|
||||
onVisibleRangeChange() {
|
||||
if (!this.hasInitialLoad || this.isLoading) {
|
||||
return;
|
||||
}
|
||||
@ -408,6 +414,8 @@ if (data.candles && data.candles.length > 0) {
|
||||
}
|
||||
|
||||
const data = this.candleSeries.data();
|
||||
const allData = this.allData.get(this.currentInterval);
|
||||
|
||||
if (!data || data.length === 0) {
|
||||
return;
|
||||
}
|
||||
@ -416,22 +424,37 @@ if (data.candles && data.candles.length > 0) {
|
||||
const bufferSize = visibleBars * 2;
|
||||
const refillThreshold = bufferSize * 0.8;
|
||||
const barsFromLeft = Math.floor(visibleRange.from);
|
||||
const visibleOldestTime = data[Math.floor(visibleRange.from)]?.time;
|
||||
const visibleNewestTime = data[Math.ceil(visibleRange.to)]?.time;
|
||||
|
||||
console.log(`[VisibleRange] Visible: ${visibleBars} bars (${data.length} in chart, ${allData?.length || 0} in dataset)`);
|
||||
console.log(`[VisibleRange] Time range: ${new Date((visibleOldestTime || 0) * 1000).toLocaleDateString()} to ${new Date((visibleNewestTime || 0) * 1000).toLocaleDateString()}`);
|
||||
|
||||
if (barsFromLeft < refillThreshold) {
|
||||
console.log(`Buffer low (${barsFromLeft} < ${refillThreshold.toFixed(0)}), silently prefetching ${bufferSize} candles...`);
|
||||
console.log(`Buffer low (${barsFromLeft} < ${refillThreshold.toFixed(0)}), prefetching ${bufferSize} candles...`);
|
||||
const oldestCandle = data[0];
|
||||
if (oldestCandle) {
|
||||
this.loadHistoricalData(oldestCandle.time, bufferSize);
|
||||
}
|
||||
}
|
||||
|
||||
// Recalculate indicators when data changes
|
||||
if (data.length !== allData?.length) {
|
||||
console.log(`[VisibleRange] Chart data (${data.length}) vs dataset (${allData?.length || 0}) differ, redrawing indicators...`);
|
||||
}
|
||||
|
||||
window.drawIndicatorsOnChart?.();
|
||||
this.loadSignals().catch(e => console.error('Error loading signals:', e));
|
||||
}
|
||||
|
||||
async loadHistoricalData(beforeTime, limit = 1000) {
|
||||
async loadHistoricalData(beforeTime, limit = 1000) {
|
||||
if (this.isLoading) {
|
||||
return;
|
||||
}
|
||||
this.isLoading = true;
|
||||
|
||||
console.log(`[Historical] Loading historical data before ${new Date(beforeTime * 1000).toLocaleDateString()}, limit=${limit}`);
|
||||
|
||||
try {
|
||||
const endTime = new Date((beforeTime - 1) * 1000);
|
||||
|
||||
@ -459,17 +482,24 @@ if (data.candles && data.candles.length > 0) {
|
||||
const mergedData = this.mergeData(existingData, chartData);
|
||||
this.allData.set(this.currentInterval, mergedData);
|
||||
|
||||
console.log(`[Historical] SUCCESS: Added ${chartData.length} candles`);
|
||||
console.log(`[Historical] Total candles in dataset: ${mergedData.length}`);
|
||||
console.log(`[Historical] Oldest: ${new Date(mergedData[0]?.time * 1000).toLocaleDateString()}`);
|
||||
console.log(`[Historical] Newest: ${new Date(mergedData[mergedData.length - 1]?.time * 1000).toLocaleDateString()}`);
|
||||
|
||||
this.candleSeries.setData(mergedData);
|
||||
|
||||
// Recalculate indicators with the expanded dataset
|
||||
// Recalculate indicators and signals with the expanded dataset
|
||||
console.log(`[Historical] Recalculating indicators...`);
|
||||
window.drawIndicatorsOnChart?.();
|
||||
await this.loadSignals();
|
||||
|
||||
console.log(`Prefetched ${chartData.length} candles, total: ${mergedData.length}`);
|
||||
console.log(`[Historical] Indicators recalculated for ${mergedData.length} candles`);
|
||||
} else {
|
||||
console.log('No more historical data available');
|
||||
console.log('[Historical] No more historical data available from database');
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('Error loading historical data:', error);
|
||||
console.error('[Historical] Error loading historical data:', error);
|
||||
} finally {
|
||||
this.isLoading = false;
|
||||
}
|
||||
@ -492,6 +522,7 @@ async loadTA() {
|
||||
}
|
||||
|
||||
this.taData = data;
|
||||
await this.loadSignals();
|
||||
this.renderTA();
|
||||
} catch (error) {
|
||||
console.error('Error loading TA:', error);
|
||||
@ -499,6 +530,17 @@ async loadTA() {
|
||||
}
|
||||
}
|
||||
|
||||
async loadSignals() {
|
||||
try {
|
||||
this.indicatorSignals = calculateAllIndicatorSignals();
|
||||
this.summarySignal = calculateSummarySignal(this.indicatorSignals);
|
||||
} catch (error) {
|
||||
console.error('Error loading signals:', error);
|
||||
this.indicatorSignals = [];
|
||||
this.summarySignal = null;
|
||||
}
|
||||
}
|
||||
|
||||
renderTA() {
|
||||
if (!this.taData || this.taData.error) {
|
||||
document.getElementById('taContent').innerHTML = `<div class="ta-error">${this.taData?.error || 'No data available'}</div>`;
|
||||
@ -515,14 +557,35 @@ renderTA() {
|
||||
document.getElementById('taInterval').textContent = this.currentInterval.toUpperCase();
|
||||
document.getElementById('taLastUpdate').textContent = new Date().toLocaleTimeString();
|
||||
|
||||
const summary = this.summarySignal || {};
|
||||
const summarySignalClass = summary.signal || 'hold';
|
||||
|
||||
const signalsHtml = this.indicatorSignals?.length > 0 ? this.indicatorSignals.map(indSignal => {
|
||||
const signalIcon = indSignal.signal === 'buy' ? '🟢' : indSignal.signal === 'sell' ? '🔴' : '🟡';
|
||||
const signalClass = indSignal.signal || 'hold';
|
||||
const valueStr = indSignal.value !== null && indSignal.value !== undefined ? indSignal.value.toFixed(2) : 'N/A';
|
||||
const indicatorConfig = indSignal.params ? `\nConfiguration: ${indSignal.params}` : '';
|
||||
const tooltipText = `Value: ${valueStr}${indicatorConfig}\n\n${indSignal.reasoning}`;
|
||||
|
||||
return `
|
||||
<div class="ta-ma-row" style="border-bottom: none; padding: 4px 0; cursor: help;">
|
||||
<span class="ta-ma-label" title="${tooltipText}">${indSignal.name}</span>
|
||||
<span class="ta-ma-value" style="display: flex; align-items: center; gap: 8px;">
|
||||
<span class="ta-signal ${signalClass}" style="font-size: 11px; padding: 2px 8px; min-width: 60px; text-align: center;" title="${tooltipText}">${signalIcon} ${indSignal.signal.toUpperCase()}</span>
|
||||
</span>
|
||||
</div>
|
||||
`;
|
||||
}).join('') : '';
|
||||
|
||||
const summaryBadge = '';
|
||||
|
||||
document.getElementById('taContent').innerHTML = `
|
||||
<div class="ta-section">
|
||||
<div class="ta-section-title">Trend Analysis</div>
|
||||
<div class="ta-trend ${trendClass}">
|
||||
${data.trend.direction} ${trendClass === 'bullish' ? '↑' : trendClass === 'bearish' ? '↓' : '→'}
|
||||
<div class="ta-section-title">
|
||||
Indicator Analysis
|
||||
${summaryBadge}
|
||||
</div>
|
||||
<div class="ta-strength">${data.trend.strength}</div>
|
||||
<span class="ta-signal ${signalClass}">${data.trend.signal}</span>
|
||||
${signalsHtml ? signalsHtml : `<div style="padding: 8px 0; color: var(--tv-text-secondary); font-size: 12px;">No indicators selected. Add indicators from the sidebar panel to view signals.</div>`}
|
||||
</div>
|
||||
|
||||
<div class="ta-section">
|
||||
@ -542,9 +605,35 @@ renderTA() {
|
||||
</span>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div class="ta-section">
|
||||
<div class="ta-section-title">Support / Resistance</div>
|
||||
<div class="ta-level">
|
||||
<span class="ta-level-label">Resistance</span>
|
||||
<span class="ta-level-value">${data.levels.resistance.toFixed(2)}</span>
|
||||
</div>
|
||||
<div class="ta-level">
|
||||
<span class="ta-level-label">Support</span>
|
||||
<span class="ta-level-value">${data.levels.support.toFixed(2)}</span>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div class="ta-section">
|
||||
<div class="ta-section-title">Price Position</div>
|
||||
<div class="ta-position-bar">
|
||||
<div class="ta-position-marker" style="left: ${Math.min(Math.max(data.levels.position_in_range, 5), 95)}%"></div>
|
||||
</div>
|
||||
<div class="ta-strength" style="margin-top: 8px; font-size: 11px;">
|
||||
${data.levels.position_in_range.toFixed(0)}% in range
|
||||
</div>
|
||||
</div>
|
||||
`;
|
||||
}
|
||||
|
||||
renderSignalsSection() {
|
||||
return '';
|
||||
}
|
||||
|
||||
async loadStats() {
|
||||
try {
|
||||
const response = await fetch('/api/v1/stats?symbol=BTC');
|
||||
|
||||
@ -101,6 +101,8 @@ export function setActiveIndicators(indicators) {
|
||||
renderIndicatorPanel();
|
||||
}
|
||||
|
||||
window.getActiveIndicators = getActiveIndicators;
|
||||
|
||||
// Render main panel
|
||||
export function renderIndicatorPanel() {
|
||||
const container = document.getElementById('indicatorPanel');
|
||||
@ -659,8 +661,20 @@ function saveUserPresets() {
|
||||
|
||||
function renderIndicatorOnPane(indicator, meta, instance, candles, paneIndex, lineStyleMap) {
|
||||
// Recalculate with current TF candles
|
||||
console.log(`[renderIndicatorOnPane] ${indicator.name}: START`);
|
||||
console.log(`[renderIndicatorOnPane] ${indicator.name}: Input candles = ${candles.length}`);
|
||||
console.log(`[renderIndicatorOnPane] ${indicator.name}: Calling instance.calculate()...`);
|
||||
|
||||
const results = instance.calculate(candles);
|
||||
|
||||
console.log(`[renderIndicatorOnPane] ${indicator.name}: calculate() returned ${results?.length || 0} results`);
|
||||
console.log(`[renderIndicatorOnPane] ${indicator.name}: Expected ${candles.length} results, got ${results?.length || 0}`);
|
||||
|
||||
if (results.length !== candles.length) {
|
||||
console.error(`[renderIndicatorOnPane] ${indicator.name}: MISMATCH! Expected ${candles.length} results but got ${results.length}`);
|
||||
console.error(`[renderIndicatorOnPane] ${indicator.name}: This means instance.calculate() is not returning the correct number of results!`);
|
||||
}
|
||||
|
||||
// Clear previous series for this indicator
|
||||
if (indicator.series && indicator.series.length > 0) {
|
||||
indicator.series.forEach(s => {
|
||||
@ -678,6 +692,8 @@ function renderIndicatorOnPane(indicator, meta, instance, candles, paneIndex, li
|
||||
const isObjectResult = firstNonNull && typeof firstNonNull === 'object';
|
||||
|
||||
let plotsCreated = 0;
|
||||
let dataPointsAdded = 0;
|
||||
|
||||
meta.plots.forEach((plot, plotIdx) => {
|
||||
if (isObjectResult) {
|
||||
const hasData = results.some(r => r && r[plot.id] !== undefined && r[plot.id] !== null);
|
||||
@ -687,6 +703,8 @@ function renderIndicatorOnPane(indicator, meta, instance, candles, paneIndex, li
|
||||
const plotColor = indicator.params[`_color_${plotIdx}`] || plot.color || '#2962ff';
|
||||
|
||||
const data = [];
|
||||
let firstDataIndex = -1;
|
||||
|
||||
for (let i = 0; i < candles.length; i++) {
|
||||
let value;
|
||||
if (isObjectResult) {
|
||||
@ -696,6 +714,9 @@ function renderIndicatorOnPane(indicator, meta, instance, candles, paneIndex, li
|
||||
}
|
||||
|
||||
if (value !== null && value !== undefined) {
|
||||
if (firstDataIndex === -1) {
|
||||
firstDataIndex = i;
|
||||
}
|
||||
data.push({
|
||||
time: candles[i].time,
|
||||
value: value
|
||||
@ -703,7 +724,14 @@ function renderIndicatorOnPane(indicator, meta, instance, candles, paneIndex, li
|
||||
}
|
||||
}
|
||||
|
||||
if (data.length === 0) return;
|
||||
console.log(`[renderIndicatorOnPane] ${indicator.name} plot ${plotIdx}: ${data.length} data points created, first data at index ${firstDataIndex}/${candles.length}`);
|
||||
|
||||
if (data.length === 0) {
|
||||
console.log(`[renderIndicatorOnPane] ${indicator.name} plot ${plotIdx}: No data to render`);
|
||||
return;
|
||||
}
|
||||
|
||||
console.log(`[renderIndicatorOnPane] ${indicator.name} plot ${plotIdx}: Creating series with ${data.length} data points [${data[0].time} to ${data[data.length - 1].time}]`);
|
||||
|
||||
let series;
|
||||
let plotLineStyle = lineStyle;
|
||||
@ -792,12 +820,26 @@ export function drawIndicatorsOnChart() {
|
||||
}
|
||||
|
||||
const currentInterval = window.dashboard.currentInterval;
|
||||
const candles = window.dashboard.allData.get(currentInterval);
|
||||
const candles = window.dashboard?.allData?.get(currentInterval);
|
||||
|
||||
if (!candles || candles.length === 0) {
|
||||
console.log('[Indicators] No candles available');
|
||||
return;
|
||||
}
|
||||
|
||||
console.log(`[Indicators] ========== drawIndicatorsOnChart START ==========`);
|
||||
console.log(`[Indicators] Candles from allData: ${candles.length}`);
|
||||
console.log(`[Indicators] First candle time: ${candles[0]?.time} (${new Date(candles[0]?.time * 1000).toLocaleDateString()})`);
|
||||
console.log(`[Indicators] Last candle time: ${candles[candles.length - 1]?.time} (${new Date(candles[candles.length - 1]?.time * 1000).toLocaleDateString()})`);
|
||||
|
||||
const oldestTime = candles[0]?.time;
|
||||
const newestTime = candles[candles.length - 1]?.time;
|
||||
const oldestDate = oldestTime ? new Date(oldestTime * 1000).toLocaleDateString() : 'N/A';
|
||||
const newestDate = newestTime ? new Date(newestTime * 1000).toLocaleDateString() : 'N/A';
|
||||
|
||||
console.log(`[Indicators] ========== Redrawing ==========`);
|
||||
console.log(`[Indicators] Candles: ${candles.length} | Time range: ${oldestDate} (${oldestTime}) to ${newestDate} (${newestTime})`);
|
||||
|
||||
// Remove all existing series
|
||||
activeIndicators.forEach(ind => {
|
||||
ind.series?.forEach(s => {
|
||||
@ -827,9 +869,18 @@ export function drawIndicatorsOnChart() {
|
||||
const IndicatorClass = IR?.[ind.type];
|
||||
if (!IndicatorClass) return;
|
||||
|
||||
const instance = new IndicatorClass({ type: ind.type, params: ind.params, name: ind.name });
|
||||
const instance = new IndicatorClass(ind);
|
||||
const meta = instance.getMetadata();
|
||||
|
||||
// Store calculated results and metadata for signal calculation
|
||||
const results = instance.calculate(candles);
|
||||
ind.cachedResults = results;
|
||||
ind.cachedMeta = meta;
|
||||
|
||||
const validResults = results.filter(r => r !== null && r !== undefined);
|
||||
const warmupPeriod = ind.params?.period || 44;
|
||||
console.log(`[Indicators] ${ind.name}: ${validResults.length} valid results (need ${warmupPeriod} candles warmup)`);
|
||||
|
||||
if (meta.displayMode === 'pane') {
|
||||
paneIndicators.push({ indicator: ind, meta, instance });
|
||||
} else {
|
||||
@ -844,21 +895,32 @@ export function drawIndicatorsOnChart() {
|
||||
|
||||
window.dashboard.chart.panes()[0]?.setHeight(mainPaneHeight);
|
||||
|
||||
console.log(`[Indicators] ========== Rendering Indicators ==========`);
|
||||
console.log(`[Indicators] Input candles: ${candles.length} | Panel count: ${totalPanes}`);
|
||||
|
||||
overlayIndicators.forEach(({ indicator, meta, instance }) => {
|
||||
console.log(`[Indicators] Processing overlay: ${indicator.name}`);
|
||||
console.log(`[Indicators] Before renderIndicatorOnPane: indicator.cachedResults length = ${indicator.cachedResults?.length || 0}`);
|
||||
renderIndicatorOnPane(indicator, meta, instance, candles, 0, lineStyleMap);
|
||||
console.log(`[Indicators] After renderIndicatorOnPane: indicator.cachedResults length = ${indicator.cachedResults?.length || 0}`);
|
||||
});
|
||||
|
||||
paneIndicators.forEach(({ indicator, meta, instance }, idx) => {
|
||||
const paneIndex = nextPaneIndex++;
|
||||
indicatorPanes.set(indicator.id, paneIndex);
|
||||
|
||||
console.log(`[Indicators] Processing pane: ${indicator.name} (pane ${paneIndex})`);
|
||||
console.log(`[Indicators] Before renderIndicatorOnPane: indicator.cachedResults length = ${indicator.cachedResults?.length || 0}`);
|
||||
renderIndicatorOnPane(indicator, meta, instance, candles, paneIndex, lineStyleMap);
|
||||
console.log(`[Indicators] After renderIndicatorOnPane: indicator.cachedResults length = ${indicator.cachedResults?.length || 0}`);
|
||||
|
||||
const pane = window.dashboard.chart.panes()[paneIndex];
|
||||
if (pane) {
|
||||
pane.setHeight(paneHeight);
|
||||
}
|
||||
});
|
||||
|
||||
console.log(`[Indicators] ========== drawIndicatorsOnChart END ==========`);
|
||||
}
|
||||
|
||||
function resetIndicator(id) {
|
||||
|
||||
499
src/api/dashboard/static/js/ui/signals-calculator.js
Normal file
499
src/api/dashboard/static/js/ui/signals-calculator.js
Normal file
@ -0,0 +1,499 @@
|
||||
// Signal Calculator for Technical Indicators
|
||||
// Calculates buy/hold/sell signals for all active indicators
|
||||
|
||||
import { IndicatorRegistry as IR } from '../indicators/index.js';
|
||||
|
||||
const SIGNAL_TYPES = {
|
||||
BUY: 'buy',
|
||||
SELL: 'sell',
|
||||
HOLD: 'hold'
|
||||
};
|
||||
|
||||
const SIGNAL_COLORS = {
|
||||
buy: '#26a69a',
|
||||
hold: '#787b86',
|
||||
sell: '#ef5350'
|
||||
};
|
||||
|
||||
/**
|
||||
* Calculate signal for a single indicator
|
||||
* @param {Object} indicator - Indicator object with type, params, etc.
|
||||
* @param {Array} candles - Recent candle data
|
||||
* @param {Object} indicatorValues - Computed indicator values for last candle
|
||||
* @returns {Object} Signal object with type, strength, value, reasoning
|
||||
*/
|
||||
function calculateIndicatorSignal(indicator, candles, indicatorValues) {
|
||||
const lastCandle = candles[candles.length - 1];
|
||||
const prevCandle = candles[candles.length - 2];
|
||||
|
||||
console.log('[calculateIndicatorSignal] Type:', indicator.type, 'Values:', indicatorValues, 'LastCandle:', lastCandle?.close);
|
||||
|
||||
if (!lastCandle) {
|
||||
return { type: SIGNAL_TYPES.HOLD, strength: 0, value: null, reasoning: 'No data' };
|
||||
}
|
||||
|
||||
switch (indicator.type) {
|
||||
case 'sma':
|
||||
case 'ema':
|
||||
case 'ma':
|
||||
return calculateMASignal(indicator, lastCandle, prevCandle, indicatorValues);
|
||||
case 'rsi':
|
||||
return calculateRSISignal(indicator, lastCandle, indicatorValues);
|
||||
case 'macd':
|
||||
return calculateMACDSignal(indicator, lastCandle, prevCandle, indicatorValues);
|
||||
case 'stoch':
|
||||
return calculateStochSignal(indicator, lastCandle, prevCandle, indicatorValues);
|
||||
case 'bb':
|
||||
return calculateBollingerBandsSignal(indicator, lastCandle, indicatorValues);
|
||||
case 'sma':
|
||||
case 'ema':
|
||||
return calculateMASignal(indicator, lastCandle, prevCandle, indicatorValues);
|
||||
case 'atr':
|
||||
return calculateATRSignal(indicator, indicatorValues);
|
||||
case 'hts':
|
||||
return calculateHTSSignal(indicator, lastCandle, prevCandle, indicatorValues);
|
||||
default:
|
||||
return { type: SIGNAL_TYPES.HOLD, strength: 0, value: null, reasoning: 'Unknown indicator type' };
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* RSI Signal Calculation
|
||||
*/
|
||||
function calculateRSISignal(indicator, lastCandle, indicatorValues) {
|
||||
const rsi = indicatorValues?.rsi;
|
||||
const overbought = indicator.params.overbought || 70;
|
||||
const oversold = indicator.params.oversold || 30;
|
||||
|
||||
if (rsi === null || rsi === undefined) {
|
||||
return { type: SIGNAL_TYPES.HOLD, strength: 0, value: null, reasoning: 'No RSI data' };
|
||||
}
|
||||
|
||||
let signal, strength, reasoning;
|
||||
|
||||
if (rsi <= oversold) {
|
||||
signal = SIGNAL_TYPES.BUY;
|
||||
strength = 80 + Math.min((oversold - rsi) * 0.5, 20);
|
||||
reasoning = `RSI ${rsi.toFixed(1)} is extremely oversold (${oversold}), suggesting the price may be approaching a bottom and potential rebound`;
|
||||
} else if (rsi >= overbought) {
|
||||
signal = SIGNAL_TYPES.SELL;
|
||||
strength = 80 + Math.min((rsi - overbought) * 0.5, 20);
|
||||
reasoning = `RSI ${rsi.toFixed(1)} is overbought (${overbought}), indicating the asset may be overvalued due for a correction`;
|
||||
} else if (rsi < 50) {
|
||||
signal = SIGNAL_TYPES.HOLD;
|
||||
strength = 30;
|
||||
reasoning = `RSI ${rsi.toFixed(1)} shows bearish momentum below 50, sellers currently in control`;
|
||||
} else if (rsi > 50) {
|
||||
signal = SIGNAL_TYPES.HOLD;
|
||||
strength = 30;
|
||||
reasoning = `RSI ${rsi.toFixed(1)} shows bullish momentum above 50, buyers currently in control`;
|
||||
} else {
|
||||
signal = SIGNAL_TYPES.HOLD;
|
||||
strength = 0;
|
||||
reasoning = 'RSI at 50 indicates neutral market conditions with balanced buying/selling pressure';
|
||||
}
|
||||
|
||||
return { type: signal, strength, value: rsi, reasoning };
|
||||
}
|
||||
|
||||
/**
|
||||
* MACD Signal Calculation
|
||||
*/
|
||||
function calculateMACDSignal(indicator, lastCandle, prevCandle, values) {
|
||||
const macd = values?.macd;
|
||||
const signalLine = values?.signal;
|
||||
const histogram = values?.histogram;
|
||||
|
||||
if (macd === null || signalLine === null) {
|
||||
return { type: SIGNAL_TYPES.HOLD, strength: 0, value: null, reasoning: 'No MACD data' };
|
||||
}
|
||||
|
||||
let macdSignal, strength, reasoning;
|
||||
|
||||
if (macd > signalLine && histogram > 0) {
|
||||
macdSignal = SIGNAL_TYPES.BUY;
|
||||
strength = 75 + Math.min((macd - signalLine) * 10, 25);
|
||||
reasoning = `MACD (${macd.toFixed(2)}) is above signal line (${signalLine.toFixed(2)}) with positive histogram (${histogram.toFixed(2)}), indicating strong bullish momentum`;
|
||||
} else if (macd < signalLine && histogram < 0) {
|
||||
macdSignal = SIGNAL_TYPES.SELL;
|
||||
strength = 75 + Math.min((signalLine - macd) * 10, 25);
|
||||
reasoning = `MACD (${macd.toFixed(2)}) is below signal line (${signalLine.toFixed(2)}) with negative histogram (${histogram.toFixed(2)}), indicating strong bearish momentum`;
|
||||
} else if (macd > 0 && signalLine < 0) {
|
||||
macdSignal = SIGNAL_TYPES.BUY;
|
||||
strength = 85;
|
||||
reasoning = `Bullish crossover: MACD (${macd.toFixed(2)}) crossed above zero while signal (${signalLine.toFixed(2)}) is still negative, potential trend reversal upward`;
|
||||
} else if (macd < 0 && signalLine > 0) {
|
||||
macdSignal = SIGNAL_TYPES.SELL;
|
||||
strength = 85;
|
||||
reasoning = `Bearish crossover: MACD (${macd.toFixed(2)}) crossed below zero while signal (${signalLine.toFixed(2)}) is still positive, potential trend reversal downward`;
|
||||
} else {
|
||||
macdSignal = SIGNAL_TYPES.HOLD;
|
||||
strength = 30;
|
||||
reasoning = `MACD (${macd.toFixed(2)}) and signal (${signalLine.toFixed(2)}) are close together with no clear directional bias`;
|
||||
}
|
||||
|
||||
return { type: macdSignal, strength, value: histogram, reasoning };
|
||||
}
|
||||
|
||||
/**
|
||||
* Stochastic Signal Calculation
|
||||
*/
|
||||
function calculateStochSignal(indicator, lastCandle, prevCandle, values) {
|
||||
const k = values?.k;
|
||||
const d = values?.d;
|
||||
|
||||
if (k === null || d === null) {
|
||||
return { type: SIGNAL_TYPES.HOLD, strength: 0, value: null, reasoning: 'No Stochastic data' };
|
||||
}
|
||||
|
||||
const prevK = prevCandle?.values?.k;
|
||||
|
||||
let signalType, strength, reasoning;
|
||||
|
||||
if (k < 20 && prevK < 20 && k > d) {
|
||||
signalType = SIGNAL_TYPES.BUY;
|
||||
strength = 80;
|
||||
reasoning = `Strong buy signal: %K (${k.toFixed(1)}) crossed above %D (${d.toFixed(1)}) in oversold territory (<20), likely upward reversal`;
|
||||
} else if (k > 80 && prevK > 80 && k < d) {
|
||||
signalType = SIGNAL_TYPES.SELL;
|
||||
strength = 80;
|
||||
reasoning = `Strong sell signal: %K (${k.toFixed(1)}) crossed below %D (${d.toFixed(1)}) in overbought territory (>80), likely downward reversal`;
|
||||
} else if (k < 20) {
|
||||
signalType = SIGNAL_TYPES.BUY;
|
||||
strength = 60;
|
||||
reasoning = `%K (${k.toFixed(1)}) is in oversold zone (<20), price may be near a bottom and ready to bounce`;
|
||||
} else if (k > 80) {
|
||||
signalType = SIGNAL_TYPES.SELL;
|
||||
strength = 60;
|
||||
reasoning = `%K (${k.toFixed(1)}) is in overbought zone (>80), price may be overextended and ready for correction`;
|
||||
} else {
|
||||
signalType = SIGNAL_TYPES.HOLD;
|
||||
strength = 30;
|
||||
reasoning = `Stochastic (${k.toFixed(1)}) is in neutral range (20-80) with no clear directional signal`;
|
||||
}
|
||||
|
||||
return { type: signalType, strength, value: k, reasoning };
|
||||
}
|
||||
|
||||
/**
|
||||
* Bollinger Bands Signal Calculation
|
||||
*/
|
||||
function calculateBollingerBandsSignal(indicator, lastCandle, values) {
|
||||
const upper = values?.upper;
|
||||
const lower = values?.lower;
|
||||
const middle = values?.middle;
|
||||
|
||||
if (!upper || !lower || !middle) {
|
||||
return { type: SIGNAL_TYPES.HOLD, strength: 0, value: null, reasoning: 'No BB data' };
|
||||
}
|
||||
|
||||
const price = lastCandle.close;
|
||||
const range = upper - lower;
|
||||
const position = (price - lower) / range;
|
||||
|
||||
let signalType, strength, reasoning;
|
||||
|
||||
if (position <= 0.1 || price <= lower) {
|
||||
signalType = SIGNAL_TYPES.BUY;
|
||||
strength = Math.floor(70 + (0.1 - position) * 300);
|
||||
reasoning = `Price (${price.toFixed(2)}) is at or touching the lower Bollinger Band (${lower.toFixed(2)}), potential oversold bounce opportunity`;
|
||||
} else if (position >= 0.9 || price >= upper) {
|
||||
signalType = SIGNAL_TYPES.SELL;
|
||||
strength = Math.floor(70 + (position - 0.9) * 300);
|
||||
reasoning = `Price (${price.toFixed(2)}) is at or touching the upper Bollinger Band (${upper.toFixed(2)}), potential overextended sell signal`;
|
||||
} else if (middle && price > middle) {
|
||||
signalType = SIGNAL_TYPES.HOLD;
|
||||
strength = 40;
|
||||
reasoning = `Price (${price.toFixed(2)}) is above the middle band (${middle.toFixed(2)}), generally bullish but not extreme`;
|
||||
} else {
|
||||
signalType = SIGNAL_TYPES.HOLD;
|
||||
strength = 40;
|
||||
reasoning = `Price (${price.toFixed(2)}) is within normal Bollinger Band range, no extreme signals`;
|
||||
}
|
||||
|
||||
strength = Math.min(Math.max(strength, 0), 100);
|
||||
|
||||
return { type: signalType, strength, value: position * 100, reasoning };
|
||||
}
|
||||
|
||||
/**
|
||||
* Moving Average Signal Calculation (SMA/EMA)
|
||||
*/
|
||||
function calculateMASignal(indicator, lastCandle, prevCandle, values) {
|
||||
const close = lastCandle.close;
|
||||
const ma = values?.ma;
|
||||
|
||||
console.log('[calculateMASignal] values:', values, 'ma:', ma, 'close:', close);
|
||||
|
||||
if (!ma && ma !== 0) {
|
||||
console.log('[calculateMASignal] No valid MA value');
|
||||
return { type: SIGNAL_TYPES.HOLD, strength: 0, value: null, reasoning: 'No MA data' };
|
||||
}
|
||||
|
||||
const prevClose = prevCandle?.close;
|
||||
const period = indicator.params?.period || 44;
|
||||
const maLabel = indicator.name || `MA (${period})`;
|
||||
|
||||
let signalType, strength, reasoning;
|
||||
|
||||
if (close > ma * 1.02) {
|
||||
signalType = SIGNAL_TYPES.BUY;
|
||||
strength = Math.min(60 + ((close - ma) / ma) * 500, 100);
|
||||
reasoning = `Price (${close.toFixed(2)}) is strongly above ${maLabel} (${ma.toFixed(2)}), bullish trend`;
|
||||
} else if (close < ma * 0.98) {
|
||||
signalType = SIGNAL_TYPES.SELL;
|
||||
strength = Math.min(60 + ((ma - close) / ma) * 500, 100);
|
||||
reasoning = `Price (${close.toFixed(2)}) is strongly below ${maLabel} (${ma.toFixed(2)}), bearish trend`;
|
||||
} else {
|
||||
signalType = SIGNAL_TYPES.HOLD;
|
||||
strength = 30;
|
||||
reasoning = `Price (${close.toFixed(2)}) is near ${maLabel} (${ma.toFixed(2)}), sideways/consolidating`;
|
||||
}
|
||||
|
||||
console.log('[calculateMASignal] Result:', signalType, strength);
|
||||
return { type: signalType, strength, value: close, reasoning };
|
||||
}
|
||||
|
||||
/**
|
||||
* ATR Signal Calculation
|
||||
*/
|
||||
function calculateATRSignal(indicator, values) {
|
||||
const atr = values?.atr;
|
||||
|
||||
if (!atr) {
|
||||
return { type: SIGNAL_TYPES.HOLD, strength: 0, value: null, reasoning: 'No ATR data' };
|
||||
}
|
||||
|
||||
const period = indicator.params?.period || 14;
|
||||
|
||||
// ATR is volatility indicator, used with other signals
|
||||
let signalType, strength, reasoning;
|
||||
|
||||
if (atr > 0) {
|
||||
signalType = SIGNAL_TYPES.HOLD;
|
||||
strength = Math.min(atr * 10, 100);
|
||||
|
||||
if (atr > 100) {
|
||||
reasoning = `High volatility detected (ATR: ${atr.toFixed(2)}), expect larger moves and wider stop-losses`;
|
||||
} else if (atr > 50) {
|
||||
reasoning = `Moderate volatility (ATR: ${atr.toFixed(2)}), normal market conditions`;
|
||||
} else {
|
||||
reasoning = `Low volatility (ATR: ${atr.toFixed(2)}), market may be consolidating`;
|
||||
}
|
||||
} else {
|
||||
signalType = SIGNAL_TYPES.HOLD;
|
||||
strength = 0;
|
||||
reasoning = 'No volatility data available';
|
||||
}
|
||||
|
||||
return { type: signalType, strength, value: atr, reasoning };
|
||||
}
|
||||
|
||||
/**
|
||||
* HTS (Hull Trend System) Signal Calculation
|
||||
*/
|
||||
function calculateHTSSignal(indicator, lastCandle, prevCandle, values) {
|
||||
const fastHigh = values?.fastHigh;
|
||||
const fastLow = values?.fastLow;
|
||||
const slowHigh = values?.slowHigh;
|
||||
const slowLow = values?.slowLow;
|
||||
|
||||
if (!fastHigh || !slowLow) {
|
||||
return { type: SIGNAL_TYPES.HOLD, strength: 0, value: null, reasoning: 'No HTS data' };
|
||||
}
|
||||
|
||||
const price = lastCandle.close;
|
||||
const midpointLow = (slowHigh[slowHigh.length - 1] + slowLow[slowLow.length - 1]) / 2;
|
||||
const midpointHigh = (fastHigh[fastHigh.length - 1] + fastLow[fastLow.length - 1]) / 2;
|
||||
|
||||
let signalType, strength, reasoning;
|
||||
|
||||
if (price > midpointHigh) {
|
||||
signalType = SIGNAL_TYPES.BUY;
|
||||
strength = Math.min(50 + ((price - midpointHigh) / midpointHigh) * 200, 100);
|
||||
reasoning = `Price (${price.toFixed(2)}) is above the fast channel (${midpointHigh.toFixed(2)}), strong bullish trend in place`;
|
||||
} else if (price < midpointLow) {
|
||||
signalType = SIGNAL_TYPES.SELL;
|
||||
strength = Math.min(50 + ((midpointLow - price) / midpointLow) * 200, 100);
|
||||
reasoning = `Price (${price.toFixed(2)}) is below the slow channel (${midpointLow.toFixed(2)}), strong bearish trend in place`;
|
||||
} else if (midpointHigh > midpointLow) {
|
||||
signalType = SIGNAL_TYPES.HOLD;
|
||||
strength = 40;
|
||||
reasoning = `Fast and slow channels are wide apart (${midpointHigh.toFixed(2)} vs ${midpointLow.toFixed(2)}), trend is established but price is in neutral zone`;
|
||||
} else {
|
||||
signalType = SIGNAL_TYPES.HOLD;
|
||||
strength = 30;
|
||||
reasoning = `Channels are close together, no clear directional trend yet`;
|
||||
}
|
||||
|
||||
return { type: signalType, strength, value: price, reasoning };
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculate signals for all active indicators
|
||||
* @returns {Array} Array of indicator signals
|
||||
*/
|
||||
export function calculateAllIndicatorSignals() {
|
||||
const activeIndicators = window.getActiveIndicators?.() || [];
|
||||
const candles = window.dashboard?.allData?.get(window.dashboard?.currentInterval);
|
||||
|
||||
console.log('[Signals] ========== calculateAllIndicatorSignals START ==========');
|
||||
console.log('[Signals] Active indicators:', activeIndicators.length, 'Candles:', candles?.length || 0);
|
||||
|
||||
if (!candles || candles.length < 2) {
|
||||
console.log('[Signals] Insufficient candles available:', candles?.length || 0);
|
||||
return [];
|
||||
}
|
||||
|
||||
if (!activeIndicators || activeIndicators.length === 0) {
|
||||
console.log('[Signals] No active indicators');
|
||||
return [];
|
||||
}
|
||||
|
||||
console.log('[Signals] Calculating for', activeIndicators.length, 'indicators with', candles.length, 'candles');
|
||||
const signals = [];
|
||||
|
||||
for (const indicator of activeIndicators) {
|
||||
const IndicatorClass = IR?.[indicator.type];
|
||||
if (!IndicatorClass) {
|
||||
console.log('[Signals] No class for indicator type:', indicator.type);
|
||||
continue;
|
||||
}
|
||||
|
||||
// Use cached results if available, otherwise calculate
|
||||
let results = indicator.cachedResults;
|
||||
let meta = indicator.cachedMeta;
|
||||
|
||||
console.log(`[Signals] ${indicator.name}: indicator.cachedResults length = ${results?.length || 0}`);
|
||||
|
||||
if (!results || !meta || results.length !== candles.length) {
|
||||
console.log(`[Signals] ${indicator.name}: Results mismatch or missing - recalculating`);
|
||||
console.log(`[Signals] ${indicator.name}: candles.length=${candles.length}, results.length=${results?.length || 0}`);
|
||||
const instance = new IndicatorClass(indicator);
|
||||
meta = instance.getMetadata();
|
||||
results = instance.calculate(candles);
|
||||
console.log(`[Signals] ${indicator.name}: New results length = ${results?.length || 0}`);
|
||||
indicator.cachedResults = results;
|
||||
indicator.cachedMeta = meta;
|
||||
}
|
||||
|
||||
console.log('[Signals]', indicator.type, '- Results length:', results?.length, 'Last result:', results?.[results.length - 1]);
|
||||
|
||||
if (!results || results.length === 0) {
|
||||
console.log('[Signals] No results for indicator:', indicator.type);
|
||||
continue;
|
||||
}
|
||||
|
||||
const lastResult = results[results.length - 1];
|
||||
if (lastResult === null || lastResult === undefined) {
|
||||
console.log('[Signals] No valid last result for indicator:', indicator.type);
|
||||
continue;
|
||||
}
|
||||
|
||||
let values;
|
||||
if (typeof lastResult === 'object' && lastResult !== null && !Array.isArray(lastResult)) {
|
||||
values = lastResult;
|
||||
} else if (typeof lastResult === 'number') {
|
||||
values = { ma: lastResult };
|
||||
} else {
|
||||
console.log('[Signals] Unexpected result type for', indicator.type, ':', typeof lastResult, lastResult);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (indicator.type === 'sma') {
|
||||
console.log('[Signals] SMA result:', lastResult, 'values:', values);
|
||||
}
|
||||
|
||||
const signal = calculateIndicatorSignal(indicator, candles, values);
|
||||
|
||||
const label = indicator.type?.toUpperCase();
|
||||
const params = indicator.params && typeof indicator.params === 'object'
|
||||
? Object.entries(indicator.params)
|
||||
.filter(([k, v]) => !k.startsWith('_') && v !== undefined && v !== null)
|
||||
.map(([k, v]) => `${k}=${v}`)
|
||||
.join(', ')
|
||||
: null;
|
||||
|
||||
signals.push({
|
||||
id: indicator.id,
|
||||
name: meta?.name || indicator.type,
|
||||
label: label,
|
||||
params: params || null,
|
||||
type: indicator.type,
|
||||
signal: signal.type,
|
||||
strength: Math.round(signal.strength),
|
||||
value: signal.value,
|
||||
reasoning: signal.reasoning,
|
||||
color: SIGNAL_COLORS[signal.type]
|
||||
});
|
||||
}
|
||||
|
||||
console.log('[Signals] ========== calculateAllIndicatorSignals END ==========');
|
||||
console.log('[Signals] Total signals calculated:', signals.length);
|
||||
return signals;
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculate aggregate summary signal from all indicators
|
||||
*/
|
||||
export function calculateSummarySignal(signals) {
|
||||
console.log('[calculateSummarySignal] Input signals:', signals?.length);
|
||||
|
||||
if (!signals || signals.length === 0) {
|
||||
return {
|
||||
signal: SIGNAL_TYPES.HOLD,
|
||||
strength: 0,
|
||||
reasoning: 'No active indicators',
|
||||
buyCount: 0,
|
||||
sellCount: 0,
|
||||
holdCount: 0
|
||||
};
|
||||
}
|
||||
|
||||
const buySignals = signals.filter(s => s.signal === SIGNAL_TYPES.BUY);
|
||||
const sellSignals = signals.filter(s => s.signal === SIGNAL_TYPES.SELL);
|
||||
const holdSignals = signals.filter(s => s.signal === SIGNAL_TYPES.HOLD);
|
||||
|
||||
const buyCount = buySignals.length;
|
||||
const sellCount = sellSignals.length;
|
||||
const holdCount = holdSignals.length;
|
||||
const total = signals.length;
|
||||
|
||||
console.log('[calculateSummarySignal] BUY:', buyCount, 'SELL:', sellCount, 'HOLD:', holdCount);
|
||||
|
||||
const buyWeight = buySignals.reduce((sum, s) => sum + (s.strength || 0), 0);
|
||||
const sellWeight = sellSignals.reduce((sum, s) => sum + (s.strength || 0), 0);
|
||||
|
||||
let summarySignal, strength, reasoning;
|
||||
|
||||
if (buyCount > sellCount && buyCount > holdCount) {
|
||||
summarySignal = SIGNAL_TYPES.BUY;
|
||||
const avgBuyStrength = buyWeight / buyCount;
|
||||
strength = Math.round(avgBuyStrength * (buyCount / total));
|
||||
reasoning = `${buyCount} buy signals, ${sellCount} sell, ${holdCount} hold`;
|
||||
} else if (sellCount > buyCount && sellCount > holdCount) {
|
||||
summarySignal = SIGNAL_TYPES.SELL;
|
||||
const avgSellStrength = sellWeight / sellCount;
|
||||
strength = Math.round(avgSellStrength * (sellCount / total));
|
||||
reasoning = `${sellCount} sell signals, ${buyCount} buy, ${holdCount} hold`;
|
||||
} else {
|
||||
summarySignal = SIGNAL_TYPES.HOLD;
|
||||
strength = 30;
|
||||
reasoning = `Mixed signals: ${buyCount} buy, ${sellCount} sell, ${holdCount} hold`;
|
||||
}
|
||||
|
||||
const result = {
|
||||
signal: summarySignal,
|
||||
strength: Math.min(Math.max(strength, 0), 100),
|
||||
reasoning,
|
||||
buyCount,
|
||||
sellCount,
|
||||
holdCount,
|
||||
color: SIGNAL_COLORS[summarySignal]
|
||||
};
|
||||
|
||||
console.log('[calculateSummarySignal] Result:', result);
|
||||
return result;
|
||||
}
|
||||
|
||||
export { SIGNAL_TYPES, SIGNAL_COLORS };
|
||||
Reference in New Issue
Block a user