@heylemon/lemonade 0.2.1 → 0.2.3

package/skills/stock-analysis/scripts/rumor_scanner.py

@@ -0,0 +1,330 @@
+#!/usr/bin/env python3
+"""
+🔮 RUMOR & BUZZ SCANNER
+Scans for early signals, rumors, and whispers before they become mainstream news.
+
+Sources:
+- Twitter/X: "hearing", "rumor", "sources say", unusual buzz
+- Google News: M&A, insider, upgrade/downgrade
+- Unusual keywords detection
+
+Usage: python3 rumor_scanner.py
+"""
+
+import json
+import os
+import subprocess
+import sys
+import re
+from datetime import datetime, timezone
+from pathlib import Path
+from urllib.request import urlopen, Request
+from urllib.parse import quote_plus
+import gzip
+
+CACHE_DIR = Path(__file__).parent.parent / "cache"
+CACHE_DIR.mkdir(exist_ok=True)
+
+# Bird CLI path
+BIRD_CLI = "/home/clawdbot/.nvm/versions/node/v24.12.0/bin/bird"
+BIRD_ENV = Path(__file__).parent.parent / ".env"
+
+
+def load_env():
+    """Load environment variables from .env file."""
+    if BIRD_ENV.exists():
+        for line in BIRD_ENV.read_text().splitlines():
+            if '=' in line and not line.startswith('#'):
+                key, value = line.split('=', 1)
+                os.environ[key.strip()] = value.strip().strip('"').strip("'")
+
+
+def fetch_url(url, timeout=15):
+    """Fetch URL with headers."""
+    headers = {
+        'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36',
+        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+        'Accept-Encoding': 'gzip, deflate',
+        'Accept-Language': 'en-US,en;q=0.9',
+    }
+    req = Request(url, headers=headers)
+    try:
+        with urlopen(req, timeout=timeout) as resp:
+            data = resp.read()
+        if resp.info().get('Content-Encoding') == 'gzip':
+            data = gzip.decompress(data)
+        return data.decode('utf-8', errors='ignore')
+    except Exception as e:
+        return None
+
+
+def search_twitter_rumors():
+    """Search Twitter for rumors and early signals."""
+    results = []
+
+    queries = [
+        '"hearing that" stock OR $',
+        '"sources say" stock OR company',
+        '"rumor" merger OR acquisition',
+        'insider buying stock',
+        '"upgrade" OR "downgrade" stock tomorrow',
+        '$AAPL OR $TSLA OR $NVDA rumor',
+        '"breaking" stock market',
+        'M&A rumor',
+    ]
+
+    load_env()
+
+    for query in queries[:4]:
+        try:
+            cmd = [BIRD_CLI, 'search', query, '-n', '10', '--json']
+            env = os.environ.copy()
+
+            result = subprocess.run(cmd, capture_output=True, text=True, timeout=30, env=env)
+
+            if result.returncode == 0 and result.stdout:
+                try:
+                    tweets = json.loads(result.stdout)
+                    for tweet in tweets:
+                        text = tweet.get('text', '')
+                        if any(kw in text.lower() for kw in ['hearing', 'rumor', 'source', 'insider', 'upgrade', 'downgrade', 'breaking', 'M&A', 'merger', 'acquisition']):
+                            results.append({
+                                'source': 'twitter',
+                                'type': 'rumor',
+                                'text': text[:300],
+                                'author': tweet.get('author', {}).get('username', 'unknown'),
+                                'likes': tweet.get('likes', 0),
+                                'retweets': tweet.get('retweets', 0),
+                                'query': query
+                            })
+                except json.JSONDecodeError:
+                    pass
+        except Exception as e:
+            pass
+
+    seen = set()
+    unique = []
+    for r in results:
+        key = r['text'][:100]
+        if key not in seen:
+            seen.add(key)
+            unique.append(r)
+
+    return unique
+
+
+def search_twitter_buzz():
+    """Search Twitter for general stock buzz - what are people talking about?"""
+    results = []
+
+    queries = [
+        '$SPY OR $QQQ',
+        'stock to buy',
+        'calls OR puts expiring',
+        'earnings play',
+        'short squeeze',
+    ]
+
+    load_env()
+
+    for query in queries[:3]:
+        try:
+            cmd = [BIRD_CLI, 'search', query, '-n', '15', '--json']
+            env = os.environ.copy()
+
+            result = subprocess.run(cmd, capture_output=True, text=True, timeout=30, env=env)
+
+            if result.returncode == 0 and result.stdout:
+                try:
+                    tweets = json.loads(result.stdout)
+                    for tweet in tweets:
+                        text = tweet.get('text', '')
+                        symbols = re.findall(r'\$([A-Z]{1,5})\b', text)
+                        if symbols:
+                            results.append({
+                                'source': 'twitter',
+                                'type': 'buzz',
+                                'text': text[:300],
+                                'symbols': symbols,
+                                'author': tweet.get('author', {}).get('username', 'unknown'),
+                                'engagement': tweet.get('likes', 0) + tweet.get('retweets', 0) * 2
+                            })
+                except json.JSONDecodeError:
+                    pass
+        except Exception as e:
+            pass
+
+    results.sort(key=lambda x: x.get('engagement', 0), reverse=True)
+    return results[:20]
+
+
+def search_news_rumors():
+    """Search Google News for M&A, insider, upgrade news."""
+    results = []
+
+    queries = [
+        'merger acquisition rumor',
+        'insider buying stock',
+        'analyst upgrade stock',
+        'takeover bid company',
+        'SEC investigation company',
+    ]
+
+    for query in queries:
+        url = f"https://news.google.com/rss/search?q={quote_plus(query)}&hl=en-US&gl=US&ceid=US:en"
+        content = fetch_url(url)
+
+        if content:
+            import xml.etree.ElementTree as ET
+            try:
+                root = ET.fromstring(content)
+                for item in root.findall('.//item')[:5]:
+                    title = item.find('title')
+                    link = item.find('link')
+                    pub_date = item.find('pubDate')
+
+                    if title is not None:
+                        title_text = title.text or ''
+                        results.append({
+                            'source': 'google_news',
+                            'type': 'news_rumor',
+                            'title': title_text,
+                            'link': link.text if link is not None else '',
+                            'date': pub_date.text if pub_date is not None else '',
+                            'query': query
+                        })
+            except ET.ParseError:
+                pass
+
+    return results
+
+
+def extract_symbols_from_text(text):
+    """Extract stock symbols from text."""
+    dollar_symbols = re.findall(r'\$([A-Z]{1,5})\b', text)
+
+    company_map = {
+        'apple': 'AAPL', 'tesla': 'TSLA', 'nvidia': 'NVDA', 'microsoft': 'MSFT',
+        'google': 'GOOGL', 'amazon': 'AMZN', 'meta': 'META', 'netflix': 'NFLX',
+        'coinbase': 'COIN', 'robinhood': 'HOOD', 'disney': 'DIS', 'intel': 'INTC',
+        'amd': 'AMD', 'palantir': 'PLTR', 'gamestop': 'GME', 'amc': 'AMC',
+    }
+
+    text_lower = text.lower()
+    company_symbols = [sym for name, sym in company_map.items() if name in text_lower]
+
+    return list(set(dollar_symbols + company_symbols))
+
+
+def calculate_rumor_score(item):
+    """Score a rumor by potential impact."""
+    score = 0
+    text = (item.get('text', '') + item.get('title', '')).lower()
+
+    if any(kw in text for kw in ['merger', 'acquisition', 'takeover', 'buyout']):
+        score += 5
+    if any(kw in text for kw in ['insider', 'ceo buying', 'director buying']):
+        score += 4
+    if any(kw in text for kw in ['upgrade', 'price target raised']):
+        score += 3
+    if any(kw in text for kw in ['downgrade', 'sec investigation', 'fraud']):
+        score += 3
+    if any(kw in text for kw in ['hearing', 'sources say', 'rumor']):
+        score += 2
+    if any(kw in text for kw in ['breaking', 'just in', 'alert']):
+        score += 2
+
+    if item.get('engagement', 0) > 100:
+        score += 2
+    if item.get('likes', 0) > 50:
+        score += 1
+
+    return score
+
+
+def main():
+    print("=" * 60)
+    print("🔮 RUMOR & BUZZ SCANNER")
+    print(f"📅 {datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M:%S')} UTC")
+    print("=" * 60)
+    print()
+    print("🔍 Scanning for early signals...")
+    print()
+
+    all_rumors = []
+    all_buzz = []
+
+    print(" 🐦 Twitter rumors...")
+    rumors = search_twitter_rumors()
+    print(f" ✅ {len(rumors)} potential rumors")
+    all_rumors.extend(rumors)
+
+    print(" 🐦 Twitter buzz...")
+    buzz = search_twitter_buzz()
+    print(f" ✅ {len(buzz)} buzz items")
+    all_buzz.extend(buzz)
+
+    print(" 📰 News rumors...")
+    news = search_news_rumors()
+    print(f" ✅ {len(news)} news items")
+    all_rumors.extend(news)
+
+    for item in all_rumors:
+        item['score'] = calculate_rumor_score(item)
+        item['symbols'] = extract_symbols_from_text(item.get('text', '') + item.get('title', ''))
+
+    all_rumors.sort(key=lambda x: x['score'], reverse=True)
+
+    symbol_counts = {}
+    for item in all_buzz:
+        for sym in item.get('symbols', []):
+            symbol_counts[sym] = symbol_counts.get(sym, 0) + 1
+
+    print()
+    print("=" * 60)
+    print("🔮 RESULTS")
+    print("=" * 60)
+    print()
+
+    print("🚨 TOP RUMORS (by potential impact):")
+    print()
+    for item in all_rumors[:10]:
+        if item['score'] > 0:
+            source = item['source']
+            symbols = ', '.join(item.get('symbols', [])) or 'N/A'
+            text = item.get('text', item.get('title', ''))[:80]
+            print(f"  [{item['score']}] [{source}] {symbols}")
+            print(f"    {text}...")
+            print()
+
+    print("📊 BUZZ LEADERBOARD (most discussed):")
+    print()
+    sorted_symbols = sorted(symbol_counts.items(), key=lambda x: x[1], reverse=True)
+    for symbol, count in sorted_symbols[:15]:
+        bar = "█" * min(count, 20)
+        print(f"  ${symbol:5} {bar} ({count})")
+
+    print()
+    print("💬 WHAT PEOPLE ARE SAYING:")
+    print()
+    for item in all_buzz[:8]:
+        author = item.get('author', 'anon')
+        text = item.get('text', '')[:120]
+        engagement = item.get('engagement', 0)
+        print(f"  @{author} ({engagement}♥): {text}...")
+    print()
+
+    output = {
+        'timestamp': datetime.now(timezone.utc).isoformat(),
+        'rumors': all_rumors[:20],
+        'buzz': all_buzz[:30],
+        'symbol_counts': symbol_counts,
+    }
+
+    output_file = CACHE_DIR / 'rumor_scan_latest.json'
+    output_file.write_text(json.dumps(output, indent=2, default=str))
+    print(f"💾 Saved: {output_file}")
+
+
+if __name__ == "__main__":
+    main()

package/skills/stock-analysis/scripts/watchlist.py

@@ -0,0 +1,318 @@
+#!/usr/bin/env python3
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "yfinance>=0.2.40",
+# ]
+# ///
+"""
+Stock Watchlist with Price Alerts.
+
+Usage:
+ uv run watchlist.py add AAPL # Add to watchlist
+ uv run watchlist.py add AAPL --target 200 # With price target
+ uv run watchlist.py add AAPL --stop 150 # With stop loss
+ uv run watchlist.py add AAPL --alert-on signal # Alert on signal change
+ uv run watchlist.py remove AAPL # Remove from watchlist
+ uv run watchlist.py list # Show watchlist
+ uv run watchlist.py check # Check for triggered alerts
+ uv run watchlist.py check --notify # Check and format for notification
+"""
+
+import argparse
+import json
+import sys
+from dataclasses import dataclass, asdict
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Literal
+
+import yfinance as yf
+
+# Storage
+WATCHLIST_DIR = Path.home() / ".clawdbot" / "skills" / "stock-analysis"
+WATCHLIST_FILE = WATCHLIST_DIR / "watchlist.json"
+
+
+@dataclass
+class WatchlistItem:
+    ticker: str
+    added_at: str
+    price_at_add: float | None = None
+    target_price: float | None = None  # Alert when price >= target
+    stop_price: float | None = None  # Alert when price <= stop
+    alert_on_signal: bool = False  # Alert when recommendation changes
+    last_signal: str | None = None  # BUY/HOLD/SELL
+    last_check: str | None = None
+    notes: str | None = None
+
+
+@dataclass
+class Alert:
+    ticker: str
+    alert_type: Literal["target_hit", "stop_hit", "signal_change"]
+    message: str
+    current_price: float
+    trigger_value: float | str
+    timestamp: str
+
+
+def ensure_dirs():
+    """Create storage directories."""
+    WATCHLIST_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def load_watchlist() -> list[WatchlistItem]:
+    """Load watchlist from file."""
+    if WATCHLIST_FILE.exists():
+        data = json.loads(WATCHLIST_FILE.read_text())
+        return [WatchlistItem(**item) for item in data]
+    return []
+
+
+def save_watchlist(items: list[WatchlistItem]):
+    """Save watchlist to file."""
+    ensure_dirs()
+    data = [asdict(item) for item in items]
+    WATCHLIST_FILE.write_text(json.dumps(data, indent=2))
+
+
+def get_current_price(ticker: str) -> float | None:
+    """Get current price for a ticker."""
+    try:
+        stock = yf.Ticker(ticker)
+        price = stock.info.get("regularMarketPrice") or stock.info.get("currentPrice")
+        return float(price) if price else None
+    except Exception:
+        return None
+
+
+def add_to_watchlist(
+    ticker: str,
+    target_price: float | None = None,
+    stop_price: float | None = None,
+    alert_on_signal: bool = False,
+    notes: str | None = None,
+) -> dict:
+    """Add ticker to watchlist."""
+    ticker = ticker.upper()
+
+    current_price = get_current_price(ticker)
+    if current_price is None:
+        return {"success": False, "error": f"Invalid ticker: {ticker}"}
+
+    watchlist = load_watchlist()
+
+    for item in watchlist:
+        if item.ticker == ticker:
+            item.target_price = target_price or item.target_price
+            item.stop_price = stop_price or item.stop_price
+            item.alert_on_signal = alert_on_signal or item.alert_on_signal
+            item.notes = notes or item.notes
+            save_watchlist(watchlist)
+            return {
+                "success": True,
+                "action": "updated",
+                "ticker": ticker,
+                "current_price": current_price,
+                "target_price": item.target_price,
+                "stop_price": item.stop_price,
+                "alert_on_signal": item.alert_on_signal,
+            }
+
+    item = WatchlistItem(
+        ticker=ticker,
+        added_at=datetime.now(timezone.utc).isoformat(),
+        price_at_add=current_price,
+        target_price=target_price,
+        stop_price=stop_price,
+        alert_on_signal=alert_on_signal,
+        notes=notes,
+    )
+    watchlist.append(item)
+    save_watchlist(watchlist)
+
+    return {
+        "success": True,
+        "action": "added",
+        "ticker": ticker,
+        "current_price": current_price,
+        "target_price": target_price,
+        "stop_price": stop_price,
+        "alert_on_signal": alert_on_signal,
+    }
+
+
+def remove_from_watchlist(ticker: str) -> dict:
+    """Remove ticker from watchlist."""
+    ticker = ticker.upper()
+    watchlist = load_watchlist()
+
+    original_len = len(watchlist)
+    watchlist = [item for item in watchlist if item.ticker != ticker]
+
+    if len(watchlist) == original_len:
+        return {"success": False, "error": f"{ticker} not in watchlist"}
+
+    save_watchlist(watchlist)
+    return {"success": True, "removed": ticker}
+
+
+def list_watchlist() -> dict:
+    """List all watchlist items with current prices."""
+    watchlist = load_watchlist()
+
+    if not watchlist:
+        return {"success": True, "items": [], "count": 0}
+
+    items = []
+    for item in watchlist:
+        current_price = get_current_price(item.ticker)
+
+        change_pct = None
+        if current_price and item.price_at_add:
+            change_pct = ((current_price - item.price_at_add) / item.price_at_add) * 100
+
+        to_target = None
+        to_stop = None
+        if current_price:
+            if item.target_price:
+                to_target = ((item.target_price - current_price) / current_price) * 100
+            if item.stop_price:
+                to_stop = ((item.stop_price - current_price) / current_price) * 100
+
+        items.append({
+            "ticker": item.ticker,
+            "current_price": current_price,
+            "price_at_add": item.price_at_add,
+            "change_pct": round(change_pct, 2) if change_pct else None,
+            "target_price": item.target_price,
+            "to_target_pct": round(to_target, 2) if to_target else None,
+            "stop_price": item.stop_price,
+            "to_stop_pct": round(to_stop, 2) if to_stop else None,
+            "alert_on_signal": item.alert_on_signal,
+            "last_signal": item.last_signal,
+            "added_at": item.added_at[:10],
+            "notes": item.notes,
+        })
+
+    return {"success": True, "items": items, "count": len(items)}
+
+
+def check_alerts(notify_format: bool = False) -> dict:
+    """Check watchlist for triggered alerts."""
+    watchlist = load_watchlist()
+    alerts: list[Alert] = []
+    now = datetime.now(timezone.utc).isoformat()
+
+    for item in watchlist:
+        current_price = get_current_price(item.ticker)
+        if current_price is None:
+            continue
+
+        if item.target_price and current_price >= item.target_price:
+            alerts.append(Alert(
+                ticker=item.ticker,
+                alert_type="target_hit",
+                message=f"🎯 {item.ticker} hit target! ${current_price:.2f} >= ${item.target_price:.2f}",
+                current_price=current_price,
+                trigger_value=item.target_price,
+                timestamp=now,
+            ))
+
+        if item.stop_price and current_price <= item.stop_price:
+            alerts.append(Alert(
+                ticker=item.ticker,
+                alert_type="stop_hit",
+                message=f"🛑 {item.ticker} hit stop! ${current_price:.2f} <= ${item.stop_price:.2f}",
+                current_price=current_price,
+                trigger_value=item.stop_price,
+                timestamp=now,
+            ))
+
+        if item.alert_on_signal:
+            try:
+                import subprocess
+                result = subprocess.run(
+                    ["uv", "run", str(Path(__file__).parent / "analyze_stock.py"), item.ticker, "--output", "json"],
+                    capture_output=True,
+                    text=True,
+                    timeout=60,
+                )
+                if result.returncode == 0:
+                    analysis = json.loads(result.stdout)
+                    new_signal = analysis.get("recommendation")
+
+                    if item.last_signal and new_signal and new_signal != item.last_signal:
+                        alerts.append(Alert(
+                            ticker=item.ticker,
+                            alert_type="signal_change",
+                            message=f"📊 {item.ticker} signal changed: {item.last_signal} → {new_signal}",
+                            current_price=current_price,
+                            trigger_value=f"{item.last_signal} → {new_signal}",
+                            timestamp=now,
+                        ))
+
+                    item.last_signal = new_signal
+            except Exception:
+                pass
+
+        item.last_check = now
+
+    save_watchlist(watchlist)
+
+    if notify_format and alerts:
+        lines = ["📢 **Stock Alerts**\n"]
+        for alert in alerts:
+            lines.append(alert.message)
+        return {"success": True, "alerts": [asdict(a) for a in alerts], "notification": "\n".join(lines)}
+
+    return {"success": True, "alerts": [asdict(a) for a in alerts], "count": len(alerts)}
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Stock Watchlist with Alerts")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    add_parser = subparsers.add_parser("add", help="Add ticker to watchlist")
+    add_parser.add_argument("ticker", help="Stock ticker")
+    add_parser.add_argument("--target", type=float, help="Target price for alert")
+    add_parser.add_argument("--stop", type=float, help="Stop loss price for alert")
+    add_parser.add_argument("--alert-on", choices=["signal"], help="Alert on signal change")
+    add_parser.add_argument("--notes", help="Notes")
+
+    remove_parser = subparsers.add_parser("remove", help="Remove ticker from watchlist")
+    remove_parser.add_argument("ticker", help="Stock ticker")
+
+    subparsers.add_parser("list", help="List watchlist")
+
+    check_parser = subparsers.add_parser("check", help="Check for triggered alerts")
+    check_parser.add_argument("--notify", action="store_true", help="Format for notification")
+
+    args = parser.parse_args()
+
+    if args.command == "add":
+        result = add_to_watchlist(
+            args.ticker,
+            target_price=args.target,
+            stop_price=args.stop,
+            alert_on_signal=(args.alert_on == "signal"),
+            notes=args.notes,
+        )
+        print(json.dumps(result, indent=2))
+
+    elif args.command == "remove":
+        result = remove_from_watchlist(args.ticker)
+        print(json.dumps(result, indent=2))
+
+    elif args.command == "list":
+        result = list_watchlist()
+        print(json.dumps(result, indent=2))
+
+    elif args.command == "check":
+        result = check_alerts(notify_format=args.notify)
+        print(json.dumps(result, indent=2))
+
+
+if __name__ == "__main__":
+    main()

package/skills/tavily-search/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: tavily
+description: AI-optimized web search via Tavily API. Returns concise, relevant results for AI agents.
+homepage: https://tavily.com
+metadata: {"lemonade":{"emoji":"🔍","requires":{"bins":["node"],"env":["TAVILY_API_KEY"]},"primaryEnv":"TAVILY_API_KEY"}}
+---
+
+# Tavily Search
+
+AI-optimized web search using Tavily API. Designed for AI agents - returns clean, relevant content.
+
+## Search
+
+```bash
+node {baseDir}/scripts/search.mjs "query"
+node {baseDir}/scripts/search.mjs "query" -n 10
+node {baseDir}/scripts/search.mjs "query" --deep
+node {baseDir}/scripts/search.mjs "query" --topic news
+```
+
+## Options
+
+- `-n <count>`: Number of results (default: 5, max: 20)
+- `--deep`: Use advanced search for deeper research (slower, more comprehensive)
+- `--topic <type>`: Search topic - `general` (default) or `news`
+- `--days <n>`: For news topic, limit to last n days
+
+## Extract content from URL
+
+```bash
+node {baseDir}/scripts/extract.mjs "https://example.com/article"
+```
+
+Notes:
+- Needs `TAVILY_API_KEY` from https://tavily.com
+- Tavily is optimized for AI - returns clean, relevant snippets
+- Use `--deep` for complex research questions
+- Use `--topic news` for current events