FrancyJGLisboa/agent-skills-platform / references/examples/stock-analyzer
stock-analyzer
UnverifiedProvides comprehensive technical analysis for stocks and ETFs using RSI, MACD, Bollinger Bands, and other indicators. Activates when user requests stock analysis, technical indicators, trading signals, or market data for specific ticker symbols.
scripts/main.py
View on GitHub"""
Stock Analyzer Skill - Main Orchestrator
This is a simplified reference implementation demonstrating the structure
of a skill with robust 3-layer activation. For a production version,
integrate with actual data sources and indicator libraries.
Example Usage:
analyzer = StockAnalyzer()
result = analyzer.analyze("AAPL", ["RSI", "MACD"])
print(result)
"""
from typing import List, Dict, Optional, Any
from datetime import datetime
class StockAnalyzer:
"""
Main orchestrator for technical stock analysis
Capabilities:
- Technical indicator calculation (RSI, MACD, Bollinger)
- Buy/sell signal generation
- Multi-stock comparison
- Price monitoring and alerts
"""
def __init__(self, config: Optional[Dict] = None):
"""
Initialize stock analyzer with optional configuration
Args:
config: Optional configuration dict with indicator parameters
"""
self.config = config or self._default_config()
print(f"[StockAnalyzer] Initialized with config: {self.config['data_source']}")
def analyze(
self,
ticker: str,
indicators: Optional[List[str]] = None,
period: str = "1y"
) -> Dict[str, Any]:
"""
Perform technical analysis on a stock
Args:
ticker: Stock symbol (e.g., "AAPL", "MSFT")
indicators: List of indicators to calculate (default: ["RSI", "MACD"])
period: Time period for analysis (default: "1y")
Returns:
Dict containing:
- ticker: Stock symbol
- current_price: Latest price
- indicators: Dict of indicator results
- signal: Buy/sell/hold recommendation
- timestamp: Analysis timestamp
Example:
>>> analyzer = StockAnalyzer()
>>> result = analyzer.analyze("AAPL", ["RSI", "MACD"])
>>> print(result['signal']['action'])
BUY
"""
indicators = indicators or ["RSI", "MACD"]
print(f"\n[StockAnalyzer] Analyzing {ticker}...")
print(f" - Indicators: {indicators}")
print(f" - Period: {period}")
# Step 1: Fetch price data (simplified - production would use yfinance)
price_data = self._fetch_data(ticker, period)
# Step 2: Calculate indicators
indicator_results = {}
for indicator_name in indicators:
indicator_results[indicator_name] = self._calculate_indicator(
indicator_name,
price_data
)
# Step 3: Generate trading signal
signal = self._generate_signal(ticker, price_data, indicator_results)
# Step 4: Compile results
result = {
'ticker': ticker.upper(),
'current_price': price_data['close'],
'indicators': indicator_results,
'signal': signal,
'timestamp': datetime.now().isoformat(),
'period': period
}
print(f"[StockAnalyzer] Analysis complete for {ticker}")
print(f" → Signal: {signal['action']} (confidence: {signal['confidence']})")
return result
def compare(
self,
tickers: List[str],
rank_by: str = "momentum",
indicators: Optional[List[str]] = None
) -> Dict[str, Any]:
"""
Compare multiple stocks and rank by technical strength
Args:
tickers: List of stock symbols
rank_by: Ranking method ("momentum", "rsi", "composite")
indicators: Indicators to use for comparison
Returns:
Dict containing ranked stocks with scores and analysis
Example:
>>> analyzer = StockAnalyzer()
>>> result = analyzer.compare(["AAPL", "MSFT", "GOOGL"])
>>> for stock in result['ranked_stocks']:
>>> print(f"{stock['ticker']}: {stock['score']}")
"""
indicators = indicators or ["RSI", "MACD"]
print(f"\n[StockAnalyzer] Comparing {len(tickers)} stocks...")
print(f" - Tickers: {', '.join(tickers)}")
print(f" - Rank by: {rank_by}")
comparisons = []
for ticker in tickers:
# Analyze each stock
analysis = self.analyze(ticker, indicators, period="6mo")
# Calculate ranking score
score = self._calculate_ranking_score(analysis, rank_by)
comparisons.append({
'ticker': ticker.upper(),
'analysis': analysis,
'score': score,
'rank': 0 # Will be set after sorting
})
# Sort by score (highest first)
comparisons.sort(key=lambda x: x['score'], reverse=True)
# Assign ranks
for idx, comparison in enumerate(comparisons, 1):
comparison['rank'] = idx
result = {
'ranked_stocks': comparisons,
'ranking_method': rank_by,
'total_analyzed': len(tickers),
'timestamp': datetime.now().isoformat()
}
print("[StockAnalyzer] Comparison complete")
print(" Rankings:")
for comp in comparisons:
print(f" #{comp['rank']}: {comp['ticker']} (score: {comp['score']:.2f})")
return result
def monitor(
self,
ticker: str,
condition: str,
action: str = "notify"
) -> Dict[str, Any]:
"""
Set up monitoring and alerts for a stock
Args:
ticker: Stock symbol to monitor
condition: Alert condition (e.g., "RSI < 30", "MACD crossover")
action: Action to take when condition met (default: "notify")
Returns:
Dict with monitoring configuration
Example:
>>> analyzer = StockAnalyzer()
>>> alert = analyzer.monitor("AAPL", "RSI < 30", "notify")
>>> print(alert['status'])
active
"""
print("\n[StockAnalyzer] Setting up monitoring...")
print(f" - Ticker: {ticker}")
print(f" - Condition: {condition}")
print(f" - Action: {action}")
return {
'ticker': ticker.upper(),
'condition': condition,
'action': action,
'status': 'active',
'created': datetime.now().isoformat()
}
# Private helper methods
def _default_config(self) -> Dict:
"""Default configuration for indicators and data sources"""
return {
'data_source': 'yahoo_finance',
'indicators': {
'RSI': {
'period': 14,
'overbought': 70,
'oversold': 30
},
'MACD': {
'fast_period': 12,
'slow_period': 26,
'signal_period': 9
},
'Bollinger': {
'period': 20,
'std_dev': 2
}
},
'signals': {
'confidence_threshold': 0.7
}
}
def _fetch_data(self, ticker: str, period: str) -> Dict[str, float]:
"""
Fetch price data for ticker (simplified mock)
Production version would use yfinance or similar
"""
# Mock data - production would fetch real data
return {
'open': 175.20,
'high': 178.90,
'low': 174.50,
'close': 178.45,
'volume': 52_000_000
}
def _calculate_indicator(
self,
indicator_name: str,
price_data: Dict
) -> Dict[str, Any]:
"""
Calculate technical indicator (simplified mock)
Production version would use ta-lib or pandas-ta
"""
if indicator_name == "RSI":
return {
'value': 62.3,
'signal': 'neutral',
'interpretation': 'RSI above 50 indicates bullish momentum, but not overbought'
}
elif indicator_name == "MACD":
return {
'macd_line': 2.15,
'signal_line': 1.89,
'histogram': 0.26,
'signal': 'buy',
'interpretation': 'MACD line crossed above signal line - bullish crossover'
}
elif indicator_name == "Bollinger":
return {
'upper_band': 185.20,
'middle_band': 178.45,
'lower_band': 171.70,
'position': 'middle',
'interpretation': 'Price near middle band - neutral volatility'
}
else:
return {'error': f'Unknown indicator: {indicator_name}'}
def _generate_signal(
self,
ticker: str,
price_data: Dict,
indicators: Dict
) -> Dict[str, Any]:
"""
Generate trading signal from indicator combination
Strategy: Combined RSI + MACD approach
- BUY: RSI healthy and MACD bullish crossover
- SELL: RSI overbought and MACD bearish
- HOLD: Otherwise
"""
rsi = indicators.get('RSI', {}).get('value', 50)
macd_signal = indicators.get('MACD', {}).get('signal', 'neutral')
reasoning = []
# RSI analysis
if rsi < 30:
reasoning.append("RSI oversold (< 30) - potential buy opportunity")
base_signal = "BUY"
confidence = "moderate"
elif rsi > 70:
reasoning.append("RSI overbought (> 70) - potential sell signal")
base_signal = "SELL"
confidence = "moderate"
else:
reasoning.append(f"RSI at {rsi:.1f} - neutral zone")
base_signal = "HOLD"
confidence = "low"
# MACD analysis
if macd_signal == "buy":
reasoning.append("MACD bullish crossover detected")
if base_signal == "BUY":
confidence = "high"
else:
base_signal = "BUY"
confidence = "moderate"
return {
'action': base_signal,
'confidence': confidence,
'reasoning': reasoning,
'price': price_data['close']
}
def _calculate_ranking_score(
self,
analysis: Dict,
method: str
) -> float:
"""
Calculate ranking score based on method
Args:
analysis: Stock analysis results
method: Ranking method (momentum, rsi, composite)
Returns:
Numeric score (higher is better)
"""
if method == "rsi":
# Higher RSI = higher score (up to 70)
rsi = analysis['indicators'].get('RSI', {}).get('value', 50)
return min(rsi, 70)
elif method == "momentum":
# Composite momentum score
rsi = analysis['indicators'].get('RSI', {}).get('value', 50)
macd_signal = analysis['indicators'].get('MACD', {}).get('signal', 'neutral')
score = rsi
if macd_signal == "buy":
score += 10
elif macd_signal == "sell":
score -= 10
return score
else: # composite
# Weighted combination of indicators
rsi = analysis['indicators'].get('RSI', {}).get('value', 50)
macd_hist = analysis['indicators'].get('MACD', {}).get('histogram', 0)
return (rsi * 0.6) + (macd_hist * 20 * 0.4)
def main():
"""Demo usage of StockAnalyzer skill"""
print("=" * 60)
print("Stock Analyzer Skill - Demo")
print("=" * 60)
analyzer = StockAnalyzer()
# Example 1: Single stock analysis
print("\n--- Example 1: Analyze AAPL ---")
result = analyzer.analyze("AAPL", ["RSI", "MACD"])
print(f"\nResult: {result['signal']['action']}")
print(f"Reasoning: {', '.join(result['signal']['reasoning'])}")
# Example 2: Multi-stock comparison
print("\n\n--- Example 2: Compare Tech Stocks ---")
comparison = analyzer.compare(["AAPL", "MSFT", "GOOGL"], rank_by="momentum")
for stock in comparison["ranked_stocks"]:
print(f" {stock['ticker']}: {stock['score']}")
# Example 3: Set up monitoring
print("\n\n--- Example 3: Monitor Stock ---")
alert = analyzer.monitor("TSLA", "RSI < 30", "notify")
print(f"\nMonitoring status: {alert['status']}")
print("\n" + "=" * 60)
print("Demo complete!")
print("=" * 60)
if __name__ == "__main__":
main()
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack." | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |