sophhub 0.2.2 → 0.2.4

package/skills/sophnet-stock/src/scripts/portfolio.py

@@ -0,0 +1,548 @@
+#!/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()