Stock Analysis

{
  "ownerId": "kn77fv9851hjcqe52zqx0bhhbx7z680h",
  "slug": "stock-analysis",
  "version": "6.2.0",
  "publishedAt": 1770041353575
}

#!/usr/bin/env python3
# /// script
# requires-python = ">=3.10"
# dependencies = [
#     "yfinance>=0.2.40",
#     "pandas>=2.0.0",
# ]
# ///
"""
Dividend Analysis Module.

Analyzes dividend metrics for income investors:
- Dividend Yield
- Payout Ratio
- Dividend Growth Rate (5Y CAGR)
- Dividend Safety Score
- Ex-Dividend Date

Usage:
    uv run dividends.py AAPL
    uv run dividends.py JNJ PG KO --output json
"""

import argparse
import json
import sys
from dataclasses import dataclass, asdict
from datetime import datetime

import pandas as pd
import yfinance as yf


@dataclass
class DividendAnalysis:
    ticker: str
    company_name: str
    
    # Basic metrics
    dividend_yield: float | None  # Annual yield %
    annual_dividend: float | None  # Annual dividend per share
    current_price: float | None
    
    # Payout analysis
    payout_ratio: float | None  # Dividend / EPS
    payout_status: str  # "safe", "moderate", "high", "unsustainable"
    
    # Growth
    dividend_growth_5y: float | None  # 5-year CAGR %
    consecutive_years: int | None  # Years of consecutive increases
    dividend_history: list[dict] | None  # Last 5 years
    
    # Timing
    ex_dividend_date: str | None
    payment_frequency: str | None  # "quarterly", "monthly", "annual"
    
    # Safety score (0-100)
    safety_score: int
    safety_factors: list[str]
    
    # Verdict
    income_rating: str  # "excellent", "good", "moderate", "poor", "no_dividend"
    summary: str


def analyze_dividends(ticker: str, verbose: bool = False) -> DividendAnalysis | None:
    """Analyze dividend metrics for a stock."""
    try:
        stock = yf.Ticker(ticker)
        info = stock.info
        
        company_name = info.get("longName") or info.get("shortName") or ticker
        current_price = info.get("regularMarketPrice") or info.get("currentPrice")
        
        # Basic dividend info
        dividend_yield = info.get("dividendYield")
        if dividend_yield:
            dividend_yield = dividend_yield * 100  # Convert to percentage
        
        annual_dividend = info.get("dividendRate")
        
        # No dividend
        if not annual_dividend or annual_dividend == 0:
            return DividendAnalysis(
                ticker=ticker,
                company_name=company_name,
                dividend_yield=None,
                annual_dividend=None,
                current_price=current_price,
                payout_ratio=None,
                payout_status="no_dividend",
                dividend_growth_5y=None,
                consecutive_years=None,
                dividend_history=None,
                ex_dividend_date=None,
                payment_frequency=None,
                safety_score=0,
                safety_factors=["No dividend paid"],
                income_rating="no_dividend",
                summary=f"{ticker} does not pay a dividend.",
            )
        
        # Payout ratio
        trailing_eps = info.get("trailingEps")
        payout_ratio = None
        payout_status = "unknown"
        
        if trailing_eps and trailing_eps > 0 and annual_dividend:
            payout_ratio = (annual_dividend / trailing_eps) * 100
            
            if payout_ratio < 40:
                payout_status = "safe"
            elif payout_ratio < 60:
                payout_status = "moderate"
            elif payout_ratio < 80:
                payout_status = "high"
            else:
                payout_status = "unsustainable"
        
        # Dividend history (for growth calculation)
        dividends = stock.dividends
        dividend_history = None
        dividend_growth_5y = None
        consecutive_years = None
        
        if dividends is not None and len(dividends) > 0:
            # Group by year
            dividends_df = dividends.reset_index()
            dividends_df["Year"] = pd.to_datetime(dividends_df["Date"]).dt.year
            yearly = dividends_df.groupby("Year")["Dividends"].sum().sort_index(ascending=False)
            
            # Last 5 years history
            dividend_history = []
            for year in yearly.head(5).index:
                dividend_history.append({
                    "year": int(year),
                    "total": round(float(yearly[year]), 4),
                })
            
            # Calculate 5-year CAGR
            if len(yearly) >= 5:
                current_div = yearly.iloc[0]
                div_5y_ago = yearly.iloc[4]
                
                if div_5y_ago > 0 and current_div > 0:
                    dividend_growth_5y = ((current_div / div_5y_ago) ** (1/5) - 1) * 100
            
            # Count consecutive years of increases
            consecutive_years = 0
            prev_div = None
            for div in yearly.values:
                if prev_div is not None:
                    if div >= prev_div:
                        consecutive_years += 1
                    else:
                        break
                prev_div = div
        
        # Ex-dividend date
        ex_dividend_date = info.get("exDividendDate")
        if ex_dividend_date:
            ex_dividend_date = datetime.fromtimestamp(ex_dividend_date).strftime("%Y-%m-%d")
        
        # Payment frequency
        payment_frequency = None
        if dividends is not None and len(dividends) >= 4:
            # Count dividends in last year
            one_year_ago = pd.Timestamp.now() - pd.DateOffset(years=1)
            recent_divs = dividends[dividends.index > one_year_ago]
            count = len(recent_divs)
            
            if count >= 10:
                payment_frequency = "monthly"
            elif count >= 3:
                payment_frequency = "quarterly"
            elif count >= 1:
                payment_frequency = "annual"
        
        # Safety score calculation (0-100)
        safety_score = 50  # Base score
        safety_factors = []
        
        # Payout ratio factor (+/- 20)
        if payout_ratio:
            if payout_ratio < 40:
                safety_score += 20
                safety_factors.append(f"Low payout ratio ({payout_ratio:.0f}%)")
            elif payout_ratio < 60:
                safety_score += 10
                safety_factors.append(f"Moderate payout ratio ({payout_ratio:.0f}%)")
            elif payout_ratio < 80:
                safety_score -= 10
                safety_factors.append(f"High payout ratio ({payout_ratio:.0f}%)")
            else:
                safety_score -= 20
                safety_factors.append(f"Unsustainable payout ratio ({payout_ratio:.0f}%)")
        
        # Growth factor (+/- 15)
        if dividend_growth_5y:
            if dividend_growth_5y > 10:
                safety_score += 15
                safety_factors.append(f"Strong dividend growth ({dividend_growth_5y:.1f}% CAGR)")
            elif dividend_growth_5y > 5:
                safety_score += 10
                safety_factors.append(f"Good dividend growth ({dividend_growth_5y:.1f}% CAGR)")
            elif dividend_growth_5y > 0:
                safety_score += 5
                safety_factors.append(f"Positive dividend growth ({dividend_growth_5y:.1f}% CAGR)")
            else:
                safety_score -= 15
                safety_factors.append(f"Dividend declining ({dividend_growth_5y:.1f}% CAGR)")
        
        # Consecutive years factor (+/- 15)
        if consecutive_years:
            if consecutive_years >= 25:
                safety_score += 15
                safety_factors.append(f"Dividend Aristocrat ({consecutive_years}+ years)")
            elif consecutive_years >= 10:
                safety_score += 10
                safety_factors.append(f"Long dividend history ({consecutive_years} years)")
            elif consecutive_years >= 5:
                safety_score += 5
                safety_factors.append(f"Consistent dividend ({consecutive_years} years)")
        
        # Yield factor (high yield can be risky)
        if dividend_yield:
            if dividend_yield > 8:
                safety_score -= 10
                safety_factors.append(f"Very high yield ({dividend_yield:.1f}%) - verify sustainability")
            elif dividend_yield < 1:
                safety_factors.append(f"Low yield ({dividend_yield:.2f}%)")
        
        # Clamp score
        safety_score = max(0, min(100, safety_score))
        
        # Income rating
        if safety_score >= 80:
            income_rating = "excellent"
        elif safety_score >= 60:
            income_rating = "good"
        elif safety_score >= 40:
            income_rating = "moderate"
        else:
            income_rating = "poor"
        
        # Summary
        summary_parts = []
        if dividend_yield:
            summary_parts.append(f"{dividend_yield:.2f}% yield")
        if payout_ratio:
            summary_parts.append(f"{payout_ratio:.0f}% payout")
        if dividend_growth_5y:
            summary_parts.append(f"{dividend_growth_5y:+.1f}% 5Y growth")
        if consecutive_years and consecutive_years >= 5:
            summary_parts.append(f"{consecutive_years}Y streak")
        
        summary = f"{ticker}: {', '.join(summary_parts)}. Rating: {income_rating.upper()}"
        
        return DividendAnalysis(
            ticker=ticker,
            company_name=company_name,
            dividend_yield=round(dividend_yield, 2) if dividend_yield else None,
            annual_dividend=round(annual_dividend, 4) if annual_dividend else None,
            current_price=current_price,
            payout_ratio=round(payout_ratio, 1) if payout_ratio else None,
            payout_status=payout_status,
            dividend_growth_5y=round(dividend_growth_5y, 2) if dividend_growth_5y else None,
            consecutive_years=consecutive_years,
            dividend_history=dividend_history,
            ex_dividend_date=ex_dividend_date,
            payment_frequency=payment_frequency,
            safety_score=safety_score,
            safety_factors=safety_factors,
            income_rating=income_rating,
            summary=summary,
        )
        
    except Exception as e:
        if verbose:
            print(f"Error analyzing {ticker}: {e}", file=sys.stderr)
        return None


def format_text(analysis: DividendAnalysis) -> str:
    """Format dividend analysis as text."""
    lines = [
        "=" * 60,
        f"DIVIDEND ANALYSIS: {analysis.ticker} ({analysis.company_name})",
        "=" * 60,
        "",
    ]
    
    if analysis.income_rating == "no_dividend":
        lines.append("This stock does not pay a dividend.")
        lines.append("=" * 60)
        return "\n".join(lines)
    
    # Yield & Price
    lines.append(f"Current Price:    ${analysis.current_price:.2f}")
    lines.append(f"Annual Dividend:  ${analysis.annual_dividend:.2f}")
    lines.append(f"Dividend Yield:   {analysis.dividend_yield:.2f}%")
    lines.append(f"Payment Freq:     {analysis.payment_frequency or 'Unknown'}")
    if analysis.ex_dividend_date:
        lines.append(f"Ex-Dividend:      {analysis.ex_dividend_date}")
    
    lines.append("")
    
    # Payout & Safety
    lines.append(f"Payout Ratio:     {analysis.payout_ratio:.1f}% ({analysis.payout_status})")
    lines.append(f"5Y Div Growth:    {analysis.dividend_growth_5y:+.1f}%" if analysis.dividend_growth_5y else "5Y Div Growth:    N/A")
    if analysis.consecutive_years:
        lines.append(f"Consecutive Yrs:  {analysis.consecutive_years}")
    
    lines.append("")
    lines.append(f"SAFETY SCORE:     {analysis.safety_score}/100")
    lines.append(f"INCOME RATING:    {analysis.income_rating.upper()}")
    
    lines.append("")
    lines.append("Safety Factors:")
    for factor in analysis.safety_factors:
        lines.append(f"  • {factor}")
    
    # History
    if analysis.dividend_history:
        lines.append("")
        lines.append("Dividend History:")
        for h in analysis.dividend_history[:5]:
            lines.append(f"  {h['year']}: ${h['total']:.2f}")
    
    lines.append("")
    lines.append("=" * 60)
    
    return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(description="Dividend Analysis")
    parser.add_argument("tickers", nargs="+", help="Stock ticker(s)")
    parser.add_argument("--output", choices=["text", "json"], default="text")
    parser.add_argument("--verbose", "-v", action="store_true")
    
    args = parser.parse_args()
    
    results = []
    for ticker in args.tickers:
        analysis = analyze_dividends(ticker.upper(), verbose=args.verbose)
        if analysis:
            results.append(analysis)
        else:
            print(f"Error: Could not analyze {ticker}", file=sys.stderr)
    
    if args.output == "json":
        if len(results) == 1:
            print(json.dumps(asdict(results[0]), indent=2))
        else:
            print(json.dumps([asdict(r) for r in results], indent=2))
    else:
        for i, analysis in enumerate(results):
            if i > 0:
                print("\n")
            print(format_text(analysis))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
🔥 HOT SCANNER v2 - Find viral stocks & crypto trends
Now with Twitter/X, Reddit, and improved Yahoo Finance
"""

import json
import urllib.request
import urllib.error
import xml.etree.ElementTree as ET
import gzip
import io
import subprocess
import os
from datetime import datetime, timezone
from pathlib import Path
import re
import ssl
from collections import defaultdict
from concurrent.futures import ThreadPoolExecutor, as_completed

# Load .env file if exists
ENV_FILE = Path(__file__).parent.parent / ".env"
if ENV_FILE.exists():
    with open(ENV_FILE) as f:
        for line in f:
            line = line.strip()
            if line and not line.startswith("#") and "=" in line:
                key, value = line.split("=", 1)
                os.environ[key] = value

# Cache directory
CACHE_DIR = Path(__file__).parent.parent / "cache"
CACHE_DIR.mkdir(exist_ok=True)

# SSL context
SSL_CONTEXT = ssl.create_default_context()

class HotScanner:
    def __init__(self, include_social=True):
        self.include_social = include_social
        self.results = {
            "timestamp": datetime.now(timezone.utc).isoformat(),
            "crypto": [],
            "stocks": [],
            "news": [],
            "movers": [],
            "social": []
        }
        self.mentions = defaultdict(lambda: {"count": 0, "sources": [], "sentiment_hints": []})
        self.headers = {
            "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
            "Accept-Language": "en-US,en;q=0.5",
            "Accept-Encoding": "gzip, deflate",
        }
    
    def _fetch(self, url, timeout=15):
        """Fetch URL with gzip support."""
        req = urllib.request.Request(url, headers=self.headers)
        with urllib.request.urlopen(req, timeout=timeout, context=SSL_CONTEXT) as resp:
            data = resp.read()
            # Handle gzip
            if resp.info().get('Content-Encoding') == 'gzip' or data[:2] == b'\x1f\x8b':
                data = gzip.decompress(data)
            return data.decode('utf-8', errors='replace')
    
    def _fetch_json(self, url, timeout=15):
        """Fetch and parse JSON."""
        return json.loads(self._fetch(url, timeout))
    
    def scan_all(self):
        """Run all scans in parallel."""
        print("🔍 Scanning for hot trends...\n")
        
        tasks = [
            ("CoinGecko Trending", self.scan_coingecko_trending),
            ("CoinGecko Movers", self.scan_coingecko_gainers_losers),
            ("Google News Finance", self.scan_google_news_finance),
            ("Google News Crypto", self.scan_google_news_crypto),
            ("Yahoo Movers", self.scan_yahoo_movers),
        ]
        
        if self.include_social:
            tasks.extend([
                ("Reddit WSB", self.scan_reddit_wsb),
                ("Reddit Crypto", self.scan_reddit_crypto),
                ("Twitter/X", self.scan_twitter),
            ])
        
        with ThreadPoolExecutor(max_workers=8) as executor:
            futures = {executor.submit(task[1]): task[0] for task in tasks}
            for future in as_completed(futures):
                name = futures[future]
                try:
                    future.result()
                except Exception as e:
                    print(f"    ❌ {name}: {str(e)[:50]}")
        
        return self.results
    
    def scan_coingecko_trending(self):
        """Get trending crypto from CoinGecko."""
        print("  📊 CoinGecko Trending...")
        try:
            url = "https://api.coingecko.com/api/v3/search/trending"
            data = self._fetch_json(url)
            
            for item in data.get("coins", [])[:10]:
                coin = item.get("item", {})
                price_data = coin.get("data", {})
                price_change = price_data.get("price_change_percentage_24h", {}).get("usd", 0)
                
                entry = {
                    "symbol": coin.get("symbol", "").upper(),
                    "name": coin.get("name", ""),
                    "rank": coin.get("market_cap_rank"),
                    "price_change_24h": round(price_change, 2) if price_change else None,
                    "source": "coingecko_trending"
                }
                self.results["crypto"].append(entry)
                
                sym = entry["symbol"]
                self.mentions[sym]["count"] += 2  # Trending gets extra weight
                self.mentions[sym]["sources"].append("CoinGecko Trending")
                if price_change:
                    direction = "🚀 bullish" if price_change > 0 else "📉 bearish"
                    self.mentions[sym]["sentiment_hints"].append(f"{direction} ({price_change:+.1f}%)")
            
            print(f"    ✅ {len(data.get('coins', []))} trending coins")
        except Exception as e:
            print(f"    ❌ CoinGecko trending: {e}")
    
    def scan_coingecko_gainers_losers(self):
        """Get top gainers/losers."""
        print("  📈 CoinGecko Movers...")
        try:
            url = "https://api.coingecko.com/api/v3/coins/markets?vs_currency=usd&order=market_cap_desc&per_page=100&page=1&price_change_percentage=24h"
            data = self._fetch_json(url)
            
            sorted_data = sorted(data, key=lambda x: abs(x.get("price_change_percentage_24h") or 0), reverse=True)
            
            count = 0
            for coin in sorted_data[:20]:
                change = coin.get("price_change_percentage_24h", 0)
                if abs(change or 0) > 3:
                    entry = {
                        "symbol": coin.get("symbol", "").upper(),
                        "name": coin.get("name", ""),
                        "price": coin.get("current_price"),
                        "change_24h": round(change, 2) if change else None,
                        "volume": coin.get("total_volume"),
                        "source": "coingecko_movers"
                    }
                    self.results["movers"].append(entry)
                    count += 1
                    
                    sym = entry["symbol"]
                    self.mentions[sym]["count"] += 1
                    self.mentions[sym]["sources"].append("CoinGecko Movers")
                    direction = "🚀 pumping" if change > 0 else "📉 dumping"
                    self.mentions[sym]["sentiment_hints"].append(f"{direction} ({change:+.1f}%)")
            
            print(f"    ✅ {count} significant movers")
        except Exception as e:
            print(f"    ❌ CoinGecko movers: {e}")
    
    def scan_google_news_finance(self):
        """Get finance news from Google News RSS."""
        print("  📰 Google News Finance...")
        try:
            # Business news topic
            url = "https://news.google.com/rss/topics/CAAqJggKIiBDQkFTRWdvSUwyMHZNRGx6TVdZU0FtVnVHZ0pWVXlnQVAB?hl=en-US&gl=US&ceid=US:en"
            text = self._fetch(url)
            root = ET.fromstring(text)
            items = root.findall(".//item")
            
            for item in items[:15]:
                title_elem = item.find("title")
                title = title_elem.text if title_elem is not None else ""
                tickers = self._extract_tickers(title)
                
                news_entry = {
                    "title": title,
                    "tickers_mentioned": tickers,
                    "source": "google_news_finance"
                }
                self.results["news"].append(news_entry)
                
                for ticker in tickers:
                    self.mentions[ticker]["count"] += 1
                    self.mentions[ticker]["sources"].append("Google News")
                    self.mentions[ticker]["sentiment_hints"].append(f"📰 {title[:40]}...")
            
            print(f"    ✅ {len(items)} news items")
        except Exception as e:
            print(f"    ❌ Google News Finance: {e}")
    
    def scan_google_news_crypto(self):
        """Search for crypto news."""
        print("  📰 Google News Crypto...")
        try:
            url = "https://news.google.com/rss/search?q=bitcoin+OR+ethereum+OR+crypto+crash+OR+crypto+pump&hl=en-US&gl=US&ceid=US:en"
            text = self._fetch(url)
            root = ET.fromstring(text)
            items = root.findall(".//item")
            
            crypto_keywords = {
                "bitcoin": "BTC", "btc": "BTC", "ethereum": "ETH", "eth": "ETH",
                "solana": "SOL", "xrp": "XRP", "ripple": "XRP", "dogecoin": "DOGE",
                "cardano": "ADA", "polkadot": "DOT", "avalanche": "AVAX",
            }
            
            for item in items[:12]:
                title_elem = item.find("title")
                title = title_elem.text if title_elem is not None else ""
                tickers = self._extract_tickers(title)
                
                for word, ticker in crypto_keywords.items():
                    if word in title.lower():
                        tickers.append(ticker)
                tickers = list(set(tickers))
                
                if tickers:
                    news_entry = {
                        "title": title,
                        "tickers_mentioned": tickers,
                        "source": "google_news_crypto"
                    }
                    self.results["news"].append(news_entry)
                    
                    for ticker in tickers:
                        self.mentions[ticker]["count"] += 1
                        self.mentions[ticker]["sources"].append("Google News Crypto")
            
            print(f"    ✅ Processed crypto news")
        except Exception as e:
            print(f"    ❌ Google News Crypto: {e}")
    
    def scan_yahoo_movers(self):
        """Scrape Yahoo Finance movers with gzip support."""
        print("  📈 Yahoo Finance Movers...")
        categories = [
            ("gainers", "https://finance.yahoo.com/gainers/"),
            ("losers", "https://finance.yahoo.com/losers/"),
            ("most_active", "https://finance.yahoo.com/most-active/")
        ]
        
        for category, url in categories:
            try:
                text = self._fetch(url, timeout=12)
                
                # Multiple patterns for ticker extraction
                tickers = []
                # Pattern 1: data-symbol attribute
                tickers.extend(re.findall(r'data-symbol="([A-Z]{1,5})"', text))
                # Pattern 2: ticker in URL
                tickers.extend(re.findall(r'/quote/([A-Z]{1,5})[/"\?]', text))
                # Pattern 3: fin-streamer
                tickers.extend(re.findall(r'fin-streamer[^>]*symbol="([A-Z]{1,5})"', text))
                
                unique_tickers = list(dict.fromkeys(tickers))[:15]
                
                for ticker in unique_tickers:
                    # Skip common false positives
                    if ticker in ['USA', 'CEO', 'IPO', 'ETF', 'SEC', 'FDA', 'NYSE', 'API']:
                        continue
                    self.results["stocks"].append({
                        "symbol": ticker,
                        "category": category,
                        "source": f"yahoo_{category}"
                    })
                    self.mentions[ticker]["count"] += 1
                    self.mentions[ticker]["sources"].append(f"Yahoo {category.replace('_', ' ').title()}")
                
                if unique_tickers:
                    print(f"    ✅ Yahoo {category}: {len(unique_tickers)} tickers")
            except Exception as e:
                print(f"    ⚠️ Yahoo {category}: {str(e)[:30]}")
    
    def scan_reddit_wsb(self):
        """Scrape r/wallstreetbets for hot stocks."""
        print("  🦍 Reddit r/wallstreetbets...")
        try:
            # Use old.reddit.com (more scrape-friendly)
            url = "https://old.reddit.com/r/wallstreetbets/hot/.json"
            headers = {**self.headers, "Accept": "application/json"}
            req = urllib.request.Request(url, headers=headers)
            
            with urllib.request.urlopen(req, timeout=15, context=SSL_CONTEXT) as resp:
                data = resp.read()
                if data[:2] == b'\x1f\x8b':
                    data = gzip.decompress(data)
                posts = json.loads(data.decode('utf-8'))
            
            tickers_found = []
            for post in posts.get("data", {}).get("children", [])[:25]:
                title = post.get("data", {}).get("title", "")
                score = post.get("data", {}).get("score", 0)
                
                # Extract tickers
                tickers = self._extract_tickers(title)
                for ticker in tickers:
                    if ticker not in ['USA', 'CEO', 'IPO', 'DD', 'WSB', 'YOLO', 'FD']:
                        weight = 2 if score > 1000 else 1
                        self.mentions[ticker]["count"] += weight
                        self.mentions[ticker]["sources"].append("Reddit WSB")
                        self.mentions[ticker]["sentiment_hints"].append(f"🦍 WSB: {title[:35]}...")
                        tickers_found.append(ticker)
                        
                        self.results["social"].append({
                            "platform": "reddit_wsb",
                            "title": title[:100],
                            "score": score,
                            "tickers": tickers
                        })
            
            print(f"    ✅ WSB: {len(set(tickers_found))} tickers mentioned")
        except Exception as e:
            print(f"    ❌ Reddit WSB: {str(e)[:40]}")
    
    def scan_reddit_crypto(self):
        """Scrape r/cryptocurrency for hot coins."""
        print("  💎 Reddit r/cryptocurrency...")
        try:
            url = "https://old.reddit.com/r/cryptocurrency/hot/.json"
            headers = {**self.headers, "Accept": "application/json"}
            req = urllib.request.Request(url, headers=headers)
            
            with urllib.request.urlopen(req, timeout=15, context=SSL_CONTEXT) as resp:
                data = resp.read()
                if data[:2] == b'\x1f\x8b':
                    data = gzip.decompress(data)
                posts = json.loads(data.decode('utf-8'))
            
            crypto_keywords = {
                "bitcoin": "BTC", "btc": "BTC", "ethereum": "ETH", "eth": "ETH",
                "solana": "SOL", "sol": "SOL", "xrp": "XRP", "cardano": "ADA",
                "dogecoin": "DOGE", "doge": "DOGE", "shiba": "SHIB", "pepe": "PEPE",
                "avalanche": "AVAX", "polkadot": "DOT", "chainlink": "LINK",
            }
            
            tickers_found = []
            for post in posts.get("data", {}).get("children", [])[:20]:
                title = post.get("data", {}).get("title", "").lower()
                score = post.get("data", {}).get("score", 0)
                
                for word, ticker in crypto_keywords.items():
                    if word in title:
                        weight = 2 if score > 500 else 1
                        self.mentions[ticker]["count"] += weight
                        self.mentions[ticker]["sources"].append("Reddit Crypto")
                        tickers_found.append(ticker)
            
            print(f"    ✅ r/crypto: {len(set(tickers_found))} coins mentioned")
        except Exception as e:
            print(f"    ❌ Reddit Crypto: {str(e)[:40]}")
    
    def scan_twitter(self):
        """Use bird CLI to get trending finance/crypto tweets."""
        print("  🐦 Twitter/X...")
        try:
            # Find bird binary
            bird_paths = [
                "/home/clawdbot/.nvm/versions/node/v24.12.0/bin/bird",
                "/usr/local/bin/bird",
                "bird"
            ]
            bird_bin = None
            for p in bird_paths:
                if Path(p).exists() or p == "bird":
                    bird_bin = p
                    break
            
            if not bird_bin:
                print("    ⚠️ Twitter: bird not found")
                return
            
            # Search for finance tweets
            searches = [
                ("stocks", "stock OR $SPY OR $QQQ OR earnings"),
                ("crypto", "bitcoin OR ethereum OR crypto OR $BTC"),
            ]
            
            for category, query in searches:
                try:
                    env = os.environ.copy()
                    result = subprocess.run(
                        [bird_bin, "search", query, "-n", "15", "--json"],
                        capture_output=True, text=True, timeout=30, env=env
                    )
                    
                    if result.returncode == 0 and result.stdout.strip():
                        tweets = json.loads(result.stdout)
                        for tweet in tweets[:10]:
                            text = tweet.get("text", "")
                            tickers = self._extract_tickers(text)
                            
                            # Add crypto keywords
                            crypto_map = {"bitcoin": "BTC", "ethereum": "ETH", "solana": "SOL"}
                            for word, ticker in crypto_map.items():
                                if word in text.lower():
                                    tickers.append(ticker)
                            
                            for ticker in set(tickers):
                                self.mentions[ticker]["count"] += 1
                                self.mentions[ticker]["sources"].append("Twitter/X")
                                self.mentions[ticker]["sentiment_hints"].append(f"🐦 {text[:35]}...")
                                
                                self.results["social"].append({
                                    "platform": "twitter",
                                    "text": text[:100],
                                    "tickers": list(set(tickers))
                                })
                        
                        print(f"    ✅ Twitter {category}: processed")
                except subprocess.TimeoutExpired:
                    print(f"    ⚠️ Twitter {category}: timeout")
                except json.JSONDecodeError:
                    print(f"    ⚠️ Twitter {category}: no auth?")
        except FileNotFoundError:
            print("    ⚠️ Twitter: bird CLI not found")
        except Exception as e:
            print(f"    ❌ Twitter: {str(e)[:40]}")
    
    def _extract_tickers(self, text):
        """Extract stock/crypto tickers from text."""
        patterns = [
            r'\$([A-Z]{1,5})\b',  # $AAPL
            r'\(([A-Z]{2,5})\)',   # (AAPL)
            r'(?:^|\s)([A-Z]{2,4})(?:\s|$|[,.])',  # Standalone caps
        ]
        
        tickers = []
        for pattern in patterns:
            matches = re.findall(pattern, text)
            tickers.extend(matches)
        
        # Company mappings
        companies = {
            "Apple": "AAPL", "Microsoft": "MSFT", "Google": "GOOGL", "Alphabet": "GOOGL",
            "Amazon": "AMZN", "Tesla": "TSLA", "Nvidia": "NVDA", "Meta": "META",
            "Netflix": "NFLX", "GameStop": "GME", "AMD": "AMD", "Intel": "INTC",
            "Palantir": "PLTR", "Coinbase": "COIN", "MicroStrategy": "MSTR",
        }
        
        for company, ticker in companies.items():
            if company.lower() in text.lower():
                tickers.append(ticker)
        
        # Filter out common words
        skip = {'USA', 'CEO', 'IPO', 'ETF', 'SEC', 'FDA', 'NYSE', 'API', 'USD', 'EU', 
                'UK', 'US', 'AI', 'IT', 'AT', 'TO', 'IN', 'ON', 'IS', 'IF', 'OR', 'AN',
                'DD', 'WSB', 'YOLO', 'FD', 'OP', 'PM', 'AM'}
        
        return list(set(t for t in tickers if t not in skip and len(t) >= 2))
    
    def get_hot_summary(self):
        """Generate summary."""
        sorted_mentions = sorted(
            self.mentions.items(),
            key=lambda x: x[1]["count"],
            reverse=True
        )
        
        summary = {
            "scan_time": self.results["timestamp"],
            "top_trending": [],
            "crypto_highlights": [],
            "stock_highlights": [],
            "social_buzz": [],
            "breaking_news": []
        }
        
        for symbol, data in sorted_mentions[:20]:
            summary["top_trending"].append({
                "symbol": symbol,
                "mentions": data["count"],
                "sources": list(set(data["sources"])),
                "signals": data["sentiment_hints"][:3]
            })
        
        # Crypto
        seen = set()
        for coin in self.results["crypto"] + self.results["movers"]:
            if coin["symbol"] not in seen:
                summary["crypto_highlights"].append(coin)
                seen.add(coin["symbol"])
        
        # Stocks
        seen = set()
        for stock in self.results["stocks"]:
            if stock["symbol"] not in seen:
                summary["stock_highlights"].append(stock)
                seen.add(stock["symbol"])
        
        # Social
        for item in self.results["social"][:15]:
            summary["social_buzz"].append(item)
        
        # News
        for news in self.results["news"][:10]:
            if news.get("tickers_mentioned"):
                summary["breaking_news"].append({
                    "title": news["title"],
                    "tickers": news["tickers_mentioned"]
                })
        
        return summary


def main():
    import argparse
    parser = argparse.ArgumentParser(description="🔥 Hot Scanner - Find trending stocks & crypto")
    parser.add_argument("--no-social", action="store_true", help="Skip social media scans")
    parser.add_argument("--json", action="store_true", help="Output only JSON")
    args = parser.parse_args()
    
    scanner = HotScanner(include_social=not args.no_social)
    
    if not args.json:
        print("=" * 60)
        print("🔥 HOT SCANNER v2 - What's Trending Right Now?")
        print(f"📅 {datetime.now().strftime('%Y-%m-%d %H:%M:%S')} UTC")
        print("=" * 60)
        print()
    
    scanner.scan_all()
    summary = scanner.get_hot_summary()
    
    # Save
    output_file = CACHE_DIR / "hot_scan_latest.json"
    with open(output_file, "w") as f:
        json.dump(summary, f, indent=2, default=str)
    
    if args.json:
        print(json.dumps(summary, indent=2, default=str))
        return
    
    print()
    print("=" * 60)
    print("🔥 RESULTS")
    print("=" * 60)
    
    print("\n📊 TOP TRENDING (by buzz):\n")
    for i, item in enumerate(summary["top_trending"][:12], 1):
        sources = ", ".join(item["sources"][:2])
        signal = item["signals"][0][:30] if item["signals"] else ""
        print(f"  {i:2}. {item['symbol']:8} ({item['mentions']:2} pts) [{sources}] {signal}")
    
    print("\n🪙 CRYPTO:\n")
    for coin in summary["crypto_highlights"][:8]:
        change = coin.get("change_24h") or coin.get("price_change_24h")
        change_str = f"{change:+.1f}%" if change else "🔥"
        emoji = "🚀" if (change or 0) > 0 else "📉" if (change or 0) < 0 else "🔥"
        print(f"  {emoji} {coin.get('symbol', '?'):8} {coin.get('name', '')[:16]:16} {change_str:>8}")
    
    print("\n📈 STOCKS:\n")
    cat_emoji = {"gainers": "🟢", "losers": "🔴", "most_active": "📊"}
    for stock in summary["stock_highlights"][:10]:
        emoji = cat_emoji.get(stock.get("category"), "•")
        print(f"  {emoji} {stock['symbol']:6} ({stock.get('category', 'N/A').replace('_', ' ')})")
    
    if summary["social_buzz"]:
        print("\n🐦 SOCIAL BUZZ:\n")
        for item in summary["social_buzz"][:5]:
            platform = item.get("platform", "?")
            text = item.get("title") or item.get("text", "")
            text = text[:55] + "..." if len(text) > 55 else text
            print(f"  [{platform}] {text}")
    
    print("\n📰 NEWS:\n")
    for news in summary["breaking_news"][:5]:
        tickers = ", ".join(news["tickers"][:3])
        title = news["title"][:55] + "..." if len(news["title"]) > 55 else news["title"]
        print(f"  [{tickers}] {title}")
    
    print(f"\n💾 Saved: {output_file}\n")


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
# /// script
# requires-python = ">=3.10"
# dependencies = ["yfinance>=0.2.40"]
# ///
"""
Portfolio management for stock-analysis skill.

Usage:
    uv run portfolio.py create "Portfolio Name"
    uv run portfolio.py list
    uv run portfolio.py show [--portfolio NAME]
    uv run portfolio.py delete "Portfolio Name"
    uv run portfolio.py rename "Old Name" "New Name"

    uv run portfolio.py add TICKER --quantity 100 --cost 150.00 [--portfolio NAME]
    uv run portfolio.py update TICKER --quantity 150 [--portfolio NAME]
    uv run portfolio.py remove TICKER [--portfolio NAME]
"""

import argparse
import json
import os
import sys
from dataclasses import dataclass, asdict
from datetime import datetime
from pathlib import Path
from typing import Literal

import yfinance as yf


# Top 20 supported cryptocurrencies
SUPPORTED_CRYPTOS = {
    "BTC-USD", "ETH-USD", "BNB-USD", "SOL-USD", "XRP-USD",
    "ADA-USD", "DOGE-USD", "AVAX-USD", "DOT-USD", "MATIC-USD",
    "LINK-USD", "ATOM-USD", "UNI-USD", "LTC-USD", "BCH-USD",
    "XLM-USD", "ALGO-USD", "VET-USD", "FIL-USD", "NEAR-USD",
}


def get_storage_path() -> Path:
    """Get the portfolio storage path."""
    # Use ~/.clawdbot/skills/stock-analysis/portfolios.json
    state_dir = os.environ.get("CLAWDBOT_STATE_DIR", os.path.expanduser("~/.clawdbot"))
    portfolio_dir = Path(state_dir) / "skills" / "stock-analysis"
    portfolio_dir.mkdir(parents=True, exist_ok=True)
    return portfolio_dir / "portfolios.json"


def detect_asset_type(ticker: str) -> Literal["stock", "crypto"]:
    """Detect asset type from ticker format."""
    ticker_upper = ticker.upper()
    if ticker_upper.endswith("-USD"):
        base = ticker_upper[:-4]
        if base.isalpha() and f"{base}-USD" in SUPPORTED_CRYPTOS:
            return "crypto"
        # Allow any *-USD ticker as crypto (flexible)
        if base.isalpha():
            return "crypto"
    return "stock"


@dataclass
class Asset:
    ticker: str
    type: Literal["stock", "crypto"]
    quantity: float
    cost_basis: float
    added_at: str


@dataclass
class Portfolio:
    name: str
    created_at: str
    updated_at: str
    assets: list[Asset]


class PortfolioStore:
    """Manages portfolio storage with atomic writes."""

    def __init__(self, path: Path | None = None):
        self.path = path or get_storage_path()
        self._data: dict | None = None

    def _load(self) -> dict:
        """Load portfolios from disk."""
        if self._data is not None:
            return self._data

        if not self.path.exists():
            self._data = {"version": 1, "portfolios": {}}
            return self._data

        try:
            with open(self.path, "r", encoding="utf-8") as f:
                self._data = json.load(f)
                return self._data
        except (json.JSONDecodeError, IOError):
            self._data = {"version": 1, "portfolios": {}}
            return self._data

    def _save(self) -> None:
        """Save portfolios to disk with atomic write."""
        if self._data is None:
            return

        # Ensure directory exists
        self.path.parent.mkdir(parents=True, exist_ok=True)

        # Atomic write: write to temp file, then rename
        tmp_path = self.path.with_suffix(".tmp")
        try:
            with open(tmp_path, "w", encoding="utf-8") as f:
                json.dump(self._data, f, indent=2)
            tmp_path.replace(self.path)
        except Exception:
            if tmp_path.exists():
                tmp_path.unlink()
            raise

    def _get_portfolio_key(self, name: str) -> str:
        """Convert portfolio name to storage key."""
        return name.lower().replace(" ", "-")

    def list_portfolios(self) -> list[str]:
        """List all portfolio names."""
        data = self._load()
        return [p["name"] for p in data["portfolios"].values()]

    def get_portfolio(self, name: str) -> Portfolio | None:
        """Get a portfolio by name."""
        data = self._load()
        key = self._get_portfolio_key(name)

        if key not in data["portfolios"]:
            # Try case-insensitive match
            for k, v in data["portfolios"].items():
                if v["name"].lower() == name.lower():
                    key = k
                    break
            else:
                return None

        p = data["portfolios"][key]
        assets = [
            Asset(
                ticker=a["ticker"],
                type=a["type"],
                quantity=a["quantity"],
                cost_basis=a["cost_basis"],
                added_at=a["added_at"],
            )
            for a in p.get("assets", [])
        ]
        return Portfolio(
            name=p["name"],
            created_at=p["created_at"],
            updated_at=p["updated_at"],
            assets=assets,
        )

    def create_portfolio(self, name: str) -> Portfolio:
        """Create a new portfolio."""
        data = self._load()
        key = self._get_portfolio_key(name)

        if key in data["portfolios"]:
            raise ValueError(f"Portfolio '{name}' already exists")

        now = datetime.now().isoformat()
        portfolio = {
            "name": name,
            "created_at": now,
            "updated_at": now,
            "assets": [],
        }
        data["portfolios"][key] = portfolio
        self._save()

        return Portfolio(name=name, created_at=now, updated_at=now, assets=[])

    def delete_portfolio(self, name: str) -> bool:
        """Delete a portfolio."""
        data = self._load()
        key = self._get_portfolio_key(name)

        # Try case-insensitive match
        if key not in data["portfolios"]:
            for k, v in data["portfolios"].items():
                if v["name"].lower() == name.lower():
                    key = k
                    break
            else:
                return False

        del data["portfolios"][key]
        self._save()
        return True

    def rename_portfolio(self, old_name: str, new_name: str) -> bool:
        """Rename a portfolio."""
        data = self._load()
        old_key = self._get_portfolio_key(old_name)
        new_key = self._get_portfolio_key(new_name)

        # Find old portfolio
        if old_key not in data["portfolios"]:
            for k, v in data["portfolios"].items():
                if v["name"].lower() == old_name.lower():
                    old_key = k
                    break
            else:
                return False

        if new_key in data["portfolios"] and new_key != old_key:
            raise ValueError(f"Portfolio '{new_name}' already exists")

        portfolio = data["portfolios"].pop(old_key)
        portfolio["name"] = new_name
        portfolio["updated_at"] = datetime.now().isoformat()
        data["portfolios"][new_key] = portfolio
        self._save()
        return True

    def add_asset(
        self,
        portfolio_name: str,
        ticker: str,
        quantity: float,
        cost_basis: float,
    ) -> Asset:
        """Add an asset to a portfolio."""
        data = self._load()
        key = self._get_portfolio_key(portfolio_name)

        # Find portfolio
        if key not in data["portfolios"]:
            for k, v in data["portfolios"].items():
                if v["name"].lower() == portfolio_name.lower():
                    key = k
                    break
            else:
                raise ValueError(f"Portfolio '{portfolio_name}' not found")

        portfolio = data["portfolios"][key]
        ticker = ticker.upper()

        # Check if asset already exists
        for asset in portfolio["assets"]:
            if asset["ticker"] == ticker:
                raise ValueError(f"Asset '{ticker}' already in portfolio. Use 'update' to modify.")

        # Validate ticker
        asset_type = detect_asset_type(ticker)
        try:
            stock = yf.Ticker(ticker)
            info = stock.info
            if "regularMarketPrice" not in info:
                raise ValueError(f"Invalid ticker: {ticker}")
        except Exception as e:
            raise ValueError(f"Could not validate ticker '{ticker}': {e}")

        now = datetime.now().isoformat()
        asset = {
            "ticker": ticker,
            "type": asset_type,
            "quantity": quantity,
            "cost_basis": cost_basis,
            "added_at": now,
        }
        portfolio["assets"].append(asset)
        portfolio["updated_at"] = now
        self._save()

        return Asset(**asset)

    def update_asset(
        self,
        portfolio_name: str,
        ticker: str,
        quantity: float | None = None,
        cost_basis: float | None = None,
    ) -> Asset | None:
        """Update an asset in a portfolio."""
        data = self._load()
        key = self._get_portfolio_key(portfolio_name)

        # Find portfolio
        if key not in data["portfolios"]:
            for k, v in data["portfolios"].items():
                if v["name"].lower() == portfolio_name.lower():
                    key = k
                    break
            else:
                return None

        portfolio = data["portfolios"][key]
        ticker = ticker.upper()

        for asset in portfolio["assets"]:
            if asset["ticker"] == ticker:
                if quantity is not None:
                    asset["quantity"] = quantity
                if cost_basis is not None:
                    asset["cost_basis"] = cost_basis
                portfolio["updated_at"] = datetime.now().isoformat()
                self._save()
                return Asset(**asset)

        return None

    def remove_asset(self, portfolio_name: str, ticker: str) -> bool:
        """Remove an asset from a portfolio."""
        data = self._load()
        key = self._get_portfolio_key(portfolio_name)

        # Find portfolio
        if key not in data["portfolios"]:
            for k, v in data["portfolios"].items():
                if v["name"].lower() == portfolio_name.lower():
                    key = k
                    break
            else:
                return False

        portfolio = data["portfolios"][key]
        ticker = ticker.upper()

        original_len = len(portfolio["assets"])
        portfolio["assets"] = [a for a in portfolio["assets"] if a["ticker"] != ticker]

        if len(portfolio["assets"]) < original_len:
            portfolio["updated_at"] = datetime.now().isoformat()
            self._save()
            return True

        return False

    def get_default_portfolio_name(self) -> str | None:
        """Get the default (first) portfolio name, or None if empty."""
        portfolios = self.list_portfolios()
        return portfolios[0] if portfolios else None


def format_currency(value: float) -> str:
    """Format a value as currency."""
    if abs(value) >= 1_000_000:
        return f"${value/1_000_000:.2f}M"
    elif abs(value) >= 1_000:
        return f"${value/1_000:.2f}K"
    else:
        return f"${value:.2f}"


def show_portfolio(portfolio: Portfolio, verbose: bool = False) -> None:
    """Display portfolio details with current prices."""
    print(f"\n{'='*60}")
    print(f"PORTFOLIO: {portfolio.name}")
    print(f"Created: {portfolio.created_at[:10]} | Updated: {portfolio.updated_at[:10]}")
    print(f"{'='*60}\n")

    if not portfolio.assets:
        print("  No assets in portfolio. Use 'add' to add assets.\n")
        return

    total_cost = 0.0
    total_value = 0.0

    print(f"{'Ticker':<12} {'Type':<8} {'Qty':>10} {'Cost':>12} {'Current':>12} {'Value':>14} {'P&L':>12}")
    print("-" * 82)

    for asset in portfolio.assets:
        try:
            stock = yf.Ticker(asset.ticker)
            current_price = stock.info.get("regularMarketPrice", 0) or 0
        except Exception:
            current_price = 0

        cost_total = asset.quantity * asset.cost_basis
        current_value = asset.quantity * current_price
        pnl = current_value - cost_total
        pnl_pct = (pnl / cost_total * 100) if cost_total > 0 else 0

        total_cost += cost_total
        total_value += current_value

        pnl_str = f"{'+' if pnl >= 0 else ''}{format_currency(pnl)} ({pnl_pct:+.1f}%)"

        print(f"{asset.ticker:<12} {asset.type:<8} {asset.quantity:>10.4f} "
              f"{format_currency(asset.cost_basis):>12} {format_currency(current_price):>12} "
              f"{format_currency(current_value):>14} {pnl_str:>12}")

    print("-" * 82)
    total_pnl = total_value - total_cost
    total_pnl_pct = (total_pnl / total_cost * 100) if total_cost > 0 else 0
    print(f"{'TOTAL':<12} {'':<8} {'':<10} {format_currency(total_cost):>12} {'':<12} "
          f"{format_currency(total_value):>14} {'+' if total_pnl >= 0 else ''}{format_currency(total_pnl)} ({total_pnl_pct:+.1f}%)")
    print()


def main():
    parser = argparse.ArgumentParser(description="Portfolio management for stock-analysis")
    subparsers = parser.add_subparsers(dest="command", help="Commands")

    # create
    create_parser = subparsers.add_parser("create", help="Create a new portfolio")
    create_parser.add_argument("name", help="Portfolio name")

    # list
    subparsers.add_parser("list", help="List all portfolios")

    # show
    show_parser = subparsers.add_parser("show", help="Show portfolio details")
    show_parser.add_argument("--portfolio", "-p", help="Portfolio name (default: first portfolio)")

    # delete
    delete_parser = subparsers.add_parser("delete", help="Delete a portfolio")
    delete_parser.add_argument("name", help="Portfolio name")

    # rename
    rename_parser = subparsers.add_parser("rename", help="Rename a portfolio")
    rename_parser.add_argument("old_name", help="Current portfolio name")
    rename_parser.add_argument("new_name", help="New portfolio name")

    # add
    add_parser = subparsers.add_parser("add", help="Add an asset to portfolio")
    add_parser.add_argument("ticker", help="Stock/crypto ticker (e.g., AAPL, BTC-USD)")
    add_parser.add_argument("--quantity", "-q", type=float, required=True, help="Quantity")
    add_parser.add_argument("--cost", "-c", type=float, required=True, help="Cost basis per unit")
    add_parser.add_argument("--portfolio", "-p", help="Portfolio name (default: first portfolio)")

    # update
    update_parser = subparsers.add_parser("update", help="Update an asset in portfolio")
    update_parser.add_argument("ticker", help="Stock/crypto ticker")
    update_parser.add_argument("--quantity", "-q", type=float, help="New quantity")
    update_parser.add_argument("--cost", "-c", type=float, help="New cost basis per unit")
    update_parser.add_argument("--portfolio", "-p", help="Portfolio name (default: first portfolio)")

    # remove
    remove_parser = subparsers.add_parser("remove", help="Remove an asset from portfolio")
    remove_parser.add_argument("ticker", help="Stock/crypto ticker")
    remove_parser.add_argument("--portfolio", "-p", help="Portfolio name (default: first portfolio)")

    args = parser.parse_args()

    if not args.command:
        parser.print_help()
        sys.exit(1)

    store = PortfolioStore()

    try:
        if args.command == "create":
            portfolio = store.create_portfolio(args.name)
            print(f"Created portfolio: {portfolio.name}")

        elif args.command == "list":
            portfolios = store.list_portfolios()
            if not portfolios:
                print("No portfolios found. Use 'create' to create one.")
            else:
                print("\nPortfolios:")
                for name in portfolios:
                    p = store.get_portfolio(name)
                    asset_count = len(p.assets) if p else 0
                    print(f"  - {name} ({asset_count} assets)")
                print()

        elif args.command == "show":
            portfolio_name = args.portfolio or store.get_default_portfolio_name()
            if not portfolio_name:
                print("No portfolios found. Use 'create' to create one.")
                sys.exit(1)

            portfolio = store.get_portfolio(portfolio_name)
            if not portfolio:
                print(f"Portfolio '{portfolio_name}' not found.")
                sys.exit(1)

            show_portfolio(portfolio)

        elif args.command == "delete":
            if store.delete_portfolio(args.name):
                print(f"Deleted portfolio: {args.name}")
            else:
                print(f"Portfolio '{args.name}' not found.")
                sys.exit(1)

        elif args.command == "rename":
            if store.rename_portfolio(args.old_name, args.new_name):
                print(f"Renamed portfolio: {args.old_name} -> {args.new_name}")
            else:
                print(f"Portfolio '{args.old_name}' not found.")
                sys.exit(1)

        elif args.command == "add":
            portfolio_name = args.portfolio or store.get_default_portfolio_name()
            if not portfolio_name:
                print("No portfolios found. Use 'create' to create one first.")
                sys.exit(1)

            asset = store.add_asset(portfolio_name, args.ticker, args.quantity, args.cost)
            print(f"Added {asset.ticker} ({asset.type}) to {portfolio_name}: "
                  f"{asset.quantity} units @ {format_currency(asset.cost_basis)}")

        elif args.command == "update":
            portfolio_name = args.portfolio or store.get_default_portfolio_name()
            if not portfolio_name:
                print("No portfolios found.")
                sys.exit(1)

            if args.quantity is None and args.cost is None:
                print("Must specify --quantity and/or --cost to update.")
                sys.exit(1)

            asset = store.update_asset(portfolio_name, args.ticker, args.quantity, args.cost)
            if asset:
                print(f"Updated {asset.ticker} in {portfolio_name}: "
                      f"{asset.quantity} units @ {format_currency(asset.cost_basis)}")
            else:
                print(f"Asset '{args.ticker}' not found in portfolio '{portfolio_name}'.")
                sys.exit(1)

        elif args.command == "remove":
            portfolio_name = args.portfolio or store.get_default_portfolio_name()
            if not portfolio_name:
                print("No portfolios found.")
                sys.exit(1)

            if store.remove_asset(portfolio_name, args.ticker):
                print(f"Removed {args.ticker.upper()} from {portfolio_name}")
            else:
                print(f"Asset '{args.ticker}' not found in portfolio '{portfolio_name}'.")
                sys.exit(1)

    except ValueError as e:
        print(f"Error: {e}")
        sys.exit(1)
    except Exception as e:
        print(f"Unexpected error: {e}")
        sys.exit(1)


if __name__ == "__main__":
    main()