Skip to content

FrancyJGLisboa/agent-skills-platform / references/examples/stock-analyzer

stock-analyzer

Unverified

Provides 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()
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: 198kUpdated Claude CodeCodexVerifiedInstall
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: 194kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report.Stars: 194kUpdated Claude CodeCodexVerifiedInstall
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: 194kUpdated Claude CodeCodexVerifiedInstall