Portfolio Analyzer Skill

Portfolio Analyzer Skill

Trigger Phrases

English:

• "analyze my portfolio"
• "portfolio review"
• "analyze stock TICKER"
• "find investment opportunities"
• "check portfolio risk"
• "portfolio dashboard"
• "talk about my investments"

Korean:

• "포트폴리오 분석해줘"
• "주식 분석"
• "투자 기회 찾아줘"
• "포트폴리오 리스크"
• "포트폴리오 대시보드"

When to Use

• Stock research and deep-dive analysis
• Portfolio performance review and visualization
• Investment opportunity discovery (undervalued stocks)
• Risk assessment and correlation analysis
• Investment advisory conversations
• Portfolio rebalancing suggestions

Execution Algorithm

Step 1: Intent Detection

Parse user request to determine which command to execute:

if user_request contains ticker symbol (e.g., "AAPL", "TSLA"):
    command = "analyze-stock"
elif "review" or "dashboard" or "show portfolio":
    command = "portfolio-review"
elif "opportunity" or "find" or "discover" or "undervalued":
    command = "find-opportunities"
elif "risk" or "volatility" or "correlation" or "beta":
    command = "portfolio-risk"
elif conversational_question about portfolio:
    command = "portfolio-chat"
else:
    # Ask user for clarification
    command = "portfolio-review"  # Default to review

Step 2: Route to Appropriate Sub-Algorithm

Based on detected intent, execute one of five command algorithms:

1. analyze-stock: Deep AI analysis of a single stock
2. portfolio-review: Comprehensive portfolio overview with dashboard
3. find-opportunities: Discover undervalued stocks and rebalancing ideas
4. portfolio-risk: Risk metrics and scenario analysis
5. portfolio-chat: AI conversational portfolio advisor

---

Command 1: analyze-stock

Purpose: Perform comprehensive AI-powered analysis of a single stock with scoring and strategic insights.

Trigger: User request contains a stock ticker symbol (e.g., "analyze AAPL", "tell me about TSLA")

Algorithm

Phase 1: Data Fetching (Sequential)

# Step 1.1: Extract ticker from user input
ticker = extract_ticker_from_input(user_request)

if not ticker:
    ask_user("What stock ticker would you like to analyze?")
    ticker = user_response.upper()

# Step 1.2: Fetch stock data (multi-source)
result = Bash(f"python3 scripts/fetch_stock_data.py {ticker}")

if result.returncode != 0:
    inform_user(f"❌ Could not fetch data for {ticker}. Please verify the ticker symbol.")
    return

stock_data = parse_json(result.stdout)

Phase 2: Scoring (Sequential)

# Step 2.1: Calculate investment score
result = Bash(f"python3 scripts/calculate_score.py {ticker} --save")

if result.returncode != 0:
    inform_user("⚠️  Scoring failed, but proceeding with available data...")
    score_data = None
else:
    score_data = parse_json(result.stdout)

Phase 3: Strategic Analysis (Opus Agent)

# Step 3.1: Launch Strategic Advisor (Opus for deep reasoning)
strategic_insight = Task(
    subagent_type="strategic-advisor",
    model="opus",
    description="Generate investment thesis",
    prompt=f"""
    Analyze {ticker} and provide strategic investment insights.

    ## Stock Data
    {stock_data}

    ## Scoring Results
    {score_data}

    Provide:
    1. Executive Summary (2-3 sentences)
    2. Bull Case (3-5 points)
    3. Bear Case (3-5 points)
    4. Investment Thesis
    5. Recommendation (BUY/HOLD/SELL) with conviction level
    6. 12-month price target estimate
    """
)

Phase 4: Present Report

# Step 4.1: Format and display comprehensive report
display_to_user(f"""
# Investment Analysis: {ticker}

## Company Overview
{stock_data['company']['name']} - {stock_data['company']['sector']}
Current Price: ${stock_data['price']['current']}

## Investment Score: {score_data['overall_score']}/10 ({score_data['grade']})

### Component Scores
- Financial Health: {score_data['component_scores']['financial_health']}/10
- Valuation: {score_data['component_scores']['valuation']}/10
- Momentum: {score_data['component_scores']['momentum']}/10

{strategic_insight}

---
💡 Add to portfolio: `python3 scripts/add_to_portfolio.py {ticker} buy <shares> <price>`
""")

Duration: 30-60 seconds

---

Command 2: portfolio-review

Purpose: Generate comprehensive portfolio overview with interactive HTML dashboard.

Trigger: "portfolio review", "show portfolio", "dashboard"

Algorithm

Phase 1: Data Collection (Sequential)

# Step 1.1: Query portfolio holdings
result = Bash("python3 scripts/query_portfolio.py --format json --with-scores")

if result.returncode != 0:
    inform_user("❌ Failed to load portfolio. Run init_portfolio.py first.")
    return

portfolio_data = parse_json(result.stdout)

if portfolio_data['summary']['count'] == 0:
    inform_user("📭 Portfolio is empty. Add holdings with add_to_portfolio.py")
    return

Phase 2: Score Update (Parallel)

# Step 2.1: Update scores for all holdings in parallel
holdings = portfolio_data['holdings']

# Launch scoring tasks in parallel for faster execution
scoring_tasks = []
for holding in holdings:
    ticker = holding['ticker']
    task_id = Task(
        subagent_type="market-analyst",
        model="sonnet",
        description=f"Score {ticker}",
        prompt=f"Run: python3 scripts/calculate_score.py {ticker} --save"
    )
    scoring_tasks.append(task_id)

# Wait for all scoring tasks to complete
wait_for_all(scoring_tasks)

Phase 3: Dashboard Generation (Sequential)

# Step 3.1: Generate HTML dashboard
result = Bash("python3 scripts/generate_dashboard.py")

if result.returncode == 0:
    inform_user("✅ Dashboard generated and opened in browser")
else:
    inform_user("⚠️  Dashboard generation failed")

Phase 4: Summary Display

# Step 4.1: Display text summary to user
summary = portfolio_data['summary']

display_to_user(f"""
# 📊 Portfolio Review

## Summary
- Total Value: ${summary['total_value']:,.2f}
- Total P&L: ${summary['total_pl']:,.2f} ({summary['total_pl_pct']:+.2f}%)
- Holdings: {summary['count']} stocks

## Top Holdings
{format_top_holdings(holdings[:5])}

## Dashboard
Interactive HTML dashboard opened in browser with:
- Sector allocation chart
- Score distribution chart
- Holdings table with scores
- Performance metrics

---
💡 Next steps:
- Update prices: `python3 scripts/update_prices.py`
- Find opportunities: Use /find-opportunities
- Check risk: Use /portfolio-risk
""")

Duration: 45-90 seconds (depends on number of holdings)

---

Command 3: find-opportunities

Purpose: Discover undervalued stocks and rebalancing suggestions using AI-powered screening.

Trigger: "find opportunities", "discover undervalued stocks", "rebalancing ideas"

Algorithm

Phase 1: Portfolio Analysis (Sequential)

# Step 1.1: Load current portfolio
result = Bash("python3 scripts/query_portfolio.py --format json --with-scores")
portfolio_data = parse_json(result.stdout)

# Step 1.2: Load target allocation from config
config = read_yaml("config/portfolio.yaml")
target_allocation = config['allocation']

Phase 2: Opportunity Scanning (Parallel)

# Step 2.1: Define screening criteria
screening_criteria = {
    'min_score': config['preferences']['min_stock_score'],
    'max_pe': 25,
    'min_roe': 0.10,
    'sectors': config['preferences']['excluded_sectors']
}

# Step 2.2: Scan for opportunities (could expand to screen broader universe)
# For now, focus on improving existing holdings

opportunities = []

for holding in portfolio_data['holdings']:
    ticker = holding['ticker']
    score = holding['overall_score']

    if score and score < screening_criteria['min_score']:
        opportunities.append({
            'type': 'SELL',
            'ticker': ticker,
            'reason': f'Score {score:.1f} below threshold {screening_criteria["min_score"]}',
            'priority': 'High' if score < 5.0 else 'Medium'
        })

Phase 3: Rebalancing Analysis (Sequential)

# Step 3.1: Calculate current allocation
current_allocation = calculate_allocation(portfolio_data)

# Step 3.2: Compare to target allocation
allocation_drift = []

for sector, target_pct in target_allocation['sectors'].items():
    current_pct = current_allocation.get(sector, 0)
    drift = current_pct - target_pct

    if abs(drift) > config['risk']['rebalance_threshold']:
        allocation_drift.append({
            'sector': sector,
            'current': current_pct,
            'target': target_pct,
            'drift': drift,
            'action': 'REDUCE' if drift > 0 else 'ADD'
        })

Phase 4: AI Opportunity Prioritization (Sonnet Agent)

# Step 4.1: Get AI recommendations
recommendations = Task(
    subagent_type="opportunity-scanner",
    model="sonnet",
    description="Prioritize opportunities",
    prompt=f"""
    Analyze the following investment opportunities and rebalancing needs.

    ## Current Portfolio
    {portfolio_data}

    ## Identified Opportunities
    {opportunities}

    ## Allocation Drift
    {allocation_drift}

    ## User Preferences
    Risk Tolerance: {config['preferences']['risk_tolerance']}
    Investment Style: {config['preferences']['investment_style']}

    Provide:
    1. Top 3 actionable recommendations (prioritized)
    2. Rationale for each recommendation
    3. Suggested timing and position sizing
    4. Risk considerations
    """
)

Phase 5: Present Recommendations

display_to_user(f"""
# 💡 Investment Opportunities

{recommendations}

## Allocation Drift Analysis
{format_allocation_table(allocation_drift)}

---
💡 To execute:
- Add holding: `python3 scripts/add_to_portfolio.py TICKER buy <shares> <price>`
- Reduce holding: `python3 scripts/add_to_portfolio.py TICKER sell <shares> <price>`
""")

Duration: 60-90 seconds

---

Command 4: portfolio-risk

Purpose: Calculate and analyze portfolio risk metrics (beta, volatility, VaR, correlation).

Trigger: "portfolio risk", "check volatility", "risk analysis"

Algorithm

Phase 1: Calculate Metrics (Sequential)

# Step 1.1: Calculate portfolio-level risk metrics
result = Bash("python3 scripts/calculate_portfolio_metrics.py --format json")

if result.returncode != 0:
    inform_user("❌ Failed to calculate risk metrics")
    return

metrics = parse_json(result.stdout)

Phase 2: Risk Interpretation (Sonnet Agent)

# Step 2.1: Get AI risk assessment
risk_assessment = Task(
    subagent_type="risk-assessor",
    model="sonnet",
    description="Interpret risk metrics",
    prompt=f"""
    Interpret the following portfolio risk metrics and provide actionable insights.

    ## Portfolio Metrics
    {metrics}

    ## User Configuration
    Risk Tolerance: {config['preferences']['risk_tolerance']}
    Max Position Size: {config['risk']['max_position_size']}%
    Max Sector Weight: {config['risk']['max_sector_weight']}%

    Provide:
    1. Overall risk assessment (Low/Medium/High)
    2. Key risk concerns (concentration, volatility, correlation)
    3. Comparison to risk tolerance
    4. Actionable recommendations to reduce risk
    5. Scenarios to watch (market downturn, sector rotation)
    """
)

Phase 3: Present Risk Report

display_to_user(f"""
# ⚠️ Portfolio Risk Analysis

## Metrics
- Portfolio Beta: {metrics['risk']['portfolio_beta']}
- Portfolio Volatility: {metrics['risk']['portfolio_volatility']}
- Max Position Weight: {metrics['concentration']['max_position_weight']}%
- Top 3 Holdings: {metrics['concentration']['top_3_weight']}%

## Risk Alerts
{check_risk_alerts(metrics, config)}

{risk_assessment}

---
💡 Risk management actions:
- Diversify: Use /find-opportunities
- Review: Use /portfolio-review
- Discuss: Use /portfolio-chat
""")

Duration: 45-60 seconds

---

Command 5: portfolio-chat

Purpose: Multi-round conversational AI advisor for investment questions.

Trigger: Conversational questions about portfolio or investments

Algorithm

Phase 1: Initialize Conversation (Sequential)

# Step 1.1: Load portfolio context
result = Bash("python3 scripts/query_portfolio.py --format json --with-scores")
portfolio_data = parse_json(result.stdout)

result = Bash("python3 scripts/calculate_portfolio_metrics.py --format json")
metrics = parse_json(result.stdout)

# Step 1.2: Load conversation history from database
conn = sqlite3.connect("data/portfolio.db")
session_id = generate_session_id()

history = load_chat_history(conn, session_id, max_turns=10)

Phase 2: AI Advisor Response (Opus Agent)

# Step 2.1: Get AI advisor response
advisor_response = Task(
    subagent_type="portfolio-advisor",
    model="opus",
    description="AI portfolio advisor",
    prompt=f"""
    You are an AI portfolio advisor. Answer the user's question with strategic insights.

    ## User Question
    {user_request}

    ## Portfolio Context
    {portfolio_data}

    ## Risk Metrics
    {metrics}

    ## Conversation History
    {history}

    ## User Preferences
    Risk Tolerance: {config['preferences']['risk_tolerance']}
    Investment Style: {config['preferences']['investment_style']}
    Time Horizon: {config['preferences']['time_horizon']}

    Provide thoughtful, personalized investment advice. Be conversational but professional.
    Ask clarifying questions if needed. Reference specific holdings when relevant.
    """
)

Phase 3: Save and Continue

# Step 3.1: Save conversation to history
save_chat_message(conn, session_id, "user", user_request)
save_chat_message(conn, session_id, "assistant", advisor_response)

# Step 3.2: Display response
display_to_user(advisor_response)

# Step 3.3: Wait for follow-up
inform_user("💡 Ask follow-up questions or type 'exit' to end conversation")

Duration: 20-40 seconds per turn

---

Error Handling

Error	Cause	Solution
Ticker not found	Invalid symbol	Suggest similar tickers, ask user to verify
Database not found	init_portfolio.py not run	Inform user to run initialization script
Database locked	Concurrent access	Retry with exponential backoff (3 attempts)
API timeout	Network/rate limit	Use cached data if available, warn user
Agent task failed	Agent error	Log error, fall back to simpler analysis without AI
Empty portfolio	No holdings	Inform user, suggest adding holdings
Missing dependencies	yfinance/pykrx not installed	Display installation instructions
Scoring failed	Insufficient data	Proceed without scores, inform user
Dashboard generation failed	Template/data issue	Display text summary instead

Error Recovery Strategy

def execute_with_retry(command, max_retries=3, backoff=2):
    for attempt in range(max_retries):
        try:
            result = execute_command(command)
            if result.success:
                return result
        except DatabaseLocked:
            if attempt < max_retries - 1:
                time.sleep(backoff ** attempt)
            else:
                raise
        except Exception as e:
            log_error(e)
            if attempt == max_retries - 1:
                return fallback_behavior()

---

Performance Optimization

Parallel Execution

Commands that benefit from parallel agent execution:

• portfolio-review: Score multiple holdings simultaneously (Step 2.1)
• find-opportunities: Screen multiple stocks in parallel

Caching Strategy

• Stock data: Cache for 1 hour (configured in portfolio.yaml)
• Scores: Persist in database, reuse if < 24 hours old
• Dashboard: Regenerate on demand

Model Selection

• Haiku: Not used in this plugin (complexity requires Sonnet minimum)
• Sonnet: Data analysis, scoring, opportunity scanning, risk assessment (cost-efficient)
• Opus: Strategic advisor, portfolio advisor (deep reasoning, 2 of 6 agents)

---

Configuration

All behavior is customizable via /plugins/portfolio-analyzer-fused/config/:

• portfolio.yaml: Target allocation, risk parameters, user preferences
• scoring.yaml: Scoring weights and thresholds
• schema.sql: Database structure

---

Quick Reference

Usage

# In Claude Code conversation:
/analyze-stock AAPL
/portfolio-review
/find-opportunities
/portfolio-risk
/portfolio-chat

# Or natural language:
"analyze apple stock"
"show me my portfolio dashboard"
"find undervalued stocks"
"what's my portfolio risk?"
"should I rebalance?"

Python Scripts (Direct Usage)

# Initialize
python3 scripts/init_portfolio.py

# Add holding
python3 scripts/add_to_portfolio.py AAPL buy 10 150.00

# Query
python3 scripts/query_portfolio.py --with-scores

# Update prices
python3 scripts/update_prices.py

# Score stock
python3 scripts/calculate_score.py TSLA --save

# Risk metrics
python3 scripts/calculate_portfolio_metrics.py

# Dashboard
python3 scripts/generate_dashboard.py

Expected Duration

• analyze-stock: 30-60 seconds
• portfolio-review: 45-90 seconds (scales with holdings)
• find-opportunities: 60-90 seconds
• portfolio-risk: 45-60 seconds
• portfolio-chat: 20-40 seconds per turn

---

Legal Disclaimer

⚠️ IMPORTANT: This tool provides informational analysis only and does NOT constitute investment advice. All investment decisions are your sole responsibility. Consult a licensed financial advisor before investing.

---

Version: 1.0.0 Generated: Competitive-Agents Fusion (Alpha + Beta) Last Updated: 2026-02-12