Add comprehensive trading statistics and analysis buttons

Added 6 powerful calculation buttons with detailed analytics:

📈 Sequential Reinvestment P&L% - Simulates reinvesting profits sequentially
⚖️ Equal Weight Portfolio P&L% - Calculates returns if equal $ invested in all
🏆 Best vs Worst Performers - Ranks top/bottom 5 with win/loss stats
🎯 Win Rate & Avg Returns - Shows hit rate, average wins/losses, risk/reward
⚠️ Risk Metrics & Volatility - Standard deviation, Sharpe ratio, drawdowns
⏰ Time-based Performance - Monthly breakdown and trend analysis

Each button provides detailed mathematical analysis of trading performance with:
- Actual order history processing
- Current position values
- Statistical calculations (mean, median, std dev)
- Risk metrics and concentration analysis
- Time-series trend analysis

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

app.py

@@ -764,6 +764,493 @@ def debug_account_info():
     except Exception as e:
         return f"ERROR getting account info: {str(e)}"
 
+def calculate_sequential_reinvestment():
+    """Calculate P&L% if reinvesting same amount sequentially in each stock"""
+    try:
+        orders = get_order_history()
+        if not orders:
+            return "No order data available for calculation"
+        
+        # Get unique symbols with their first buy date
+        symbols_by_date = {}
+        for order in orders:
+            if order.side.value == 'buy' and order.status.value == 'filled':
+                symbol = order.symbol
+                fill_date = order.filled_at
+                if symbol not in symbols_by_date or fill_date < symbols_by_date[symbol]:
+                    symbols_by_date[symbol] = fill_date
+        
+        # Sort by first buy date
+        sorted_symbols = sorted(symbols_by_date.items(), key=lambda x: x[1])
+        
+        # Calculate sequential reinvestment returns
+        initial_investment = 1000  # Start with $1000
+        current_value = initial_investment
+        
+        results = []
+        total_return = 0
+        
+        for symbol, first_date in sorted_symbols:
+            # Get all orders for this symbol
+            symbol_orders = [o for o in orders if o.symbol == symbol]
+            buy_orders = [o for o in symbol_orders if o.side.value == 'buy']
+            sell_orders = [o for o in symbol_orders if o.side.value == 'sell']
+            
+            if buy_orders:
+                # Calculate actual P&L for this symbol
+                total_bought = sum(float(o.filled_qty or 0) for o in buy_orders)
+                total_cost = sum(float(o.filled_qty or 0) * float(o.filled_avg_price or 0) for o in buy_orders)
+                
+                if sell_orders:
+                    # Sold - use actual sell proceeds
+                    sold_value = sum(float(o.filled_qty or 0) * float(o.filled_avg_price or 0) for o in sell_orders)
+                    pl_percent = ((sold_value - total_cost) / total_cost) if total_cost > 0 else 0
+                else:
+                    # Still holding - estimate current value
+                    positions = get_current_positions()
+                    pos = next((p for p in positions if p['symbol'] == symbol), None)
+                    if pos:
+                        current_price = pos['current_price']
+                        current_symbol_value = total_bought * current_price
+                        pl_percent = ((current_symbol_value - total_cost) / total_cost) if total_cost > 0 else 0
+                    else:
+                        pl_percent = 0
+                
+                # Apply return to current value
+                new_value = current_value * (1 + pl_percent)
+                gain_loss = new_value - current_value
+                
+                results.append(f"{symbol}: {pl_percent*100:+.2f}% | ${current_value:.2f} → ${new_value:.2f} ({gain_loss:+.2f})")
+                current_value = new_value
+                total_return += pl_percent
+        
+        final_return_pct = ((current_value - initial_investment) / initial_investment) * 100
+        
+        output = f"🧮 SEQUENTIAL REINVESTMENT ANALYSIS\n"
+        output += f"Starting Investment: ${initial_investment:.2f}\n"
+        output += f"Final Value: ${current_value:.2f}\n"
+        output += f"Total Return: {final_return_pct:+.2f}%\n"
+        output += f"Number of Trades: {len(sorted_symbols)}\n\n"
+        output += "Trade Sequence:\n"
+        output += "\n".join(results)
+        
+        return output
+        
+    except Exception as e:
+        return f"ERROR calculating sequential reinvestment: {str(e)}"
+
+def calculate_equal_weight_portfolio():
+    """Calculate P&L% if investing equal amounts in all stocks simultaneously"""
+    try:
+        orders = get_order_history()
+        if not orders:
+            return "No order data available for calculation"
+        
+        # Get unique symbols
+        symbols = set()
+        for order in orders:
+            if order.side.value == 'buy':
+                symbols.add(order.symbol)
+        
+        total_pl = 0
+        valid_symbols = 0
+        results = []
+        
+        for symbol in sorted(symbols):
+            symbol_orders = [o for o in orders if o.symbol == symbol]
+            buy_orders = [o for o in symbol_orders if o.side.value == 'buy']
+            sell_orders = [o for o in symbol_orders if o.side.value == 'sell']
+            
+            if buy_orders:
+                total_bought = sum(float(o.filled_qty or 0) for o in buy_orders)
+                total_cost = sum(float(o.filled_qty or 0) * float(o.filled_avg_price or 0) for o in buy_orders)
+                avg_buy_price = total_cost / total_bought if total_bought > 0 else 0
+                
+                if sell_orders:
+                    # Sold
+                    sold_value = sum(float(o.filled_qty or 0) * float(o.filled_avg_price or 0) for o in sell_orders)
+                    pl_percent = ((sold_value - total_cost) / total_cost) if total_cost > 0 else 0
+                    status = "SOLD"
+                else:
+                    # Still holding
+                    positions = get_current_positions()
+                    pos = next((p for p in positions if p['symbol'] == symbol), None)
+                    if pos:
+                        current_price = pos['current_price']
+                        current_value = total_bought * current_price
+                        pl_percent = ((current_value - total_cost) / total_cost) if total_cost > 0 else 0
+                        status = "HOLDING"
+                    else:
+                        pl_percent = 0
+                        status = "UNKNOWN"
+                
+                total_pl += pl_percent
+                valid_symbols += 1
+                
+                results.append(f"{symbol}: {pl_percent*100:+.2f}% ({status})")
+        
+        avg_return = (total_pl / valid_symbols) * 100 if valid_symbols > 0 else 0
+        
+        output = f"⚖️ EQUAL WEIGHT PORTFOLIO ANALYSIS\n"
+        output += f"Total Symbols: {valid_symbols}\n"
+        output += f"Average Return per Symbol: {avg_return:+.2f}%\n"
+        output += f"Portfolio Return (equal weights): {avg_return:+.2f}%\n\n"
+        output += "Individual Returns:\n"
+        output += "\n".join(results)
+        
+        return output
+        
+    except Exception as e:
+        return f"ERROR calculating equal weight portfolio: {str(e)}"
+
+def calculate_best_worst_performers():
+    """Find best and worst performing stocks"""
+    try:
+        orders = get_order_history()
+        if not orders:
+            return "No order data available for calculation"
+        
+        symbols = set()
+        for order in orders:
+            if order.side.value == 'buy':
+                symbols.add(order.symbol)
+        
+        performance = []
+        
+        for symbol in symbols:
+            symbol_orders = [o for o in orders if o.symbol == symbol]
+            buy_orders = [o for o in symbol_orders if o.side.value == 'buy']
+            sell_orders = [o for o in symbol_orders if o.side.value == 'sell']
+            
+            if buy_orders:
+                total_bought = sum(float(o.filled_qty or 0) for o in buy_orders)
+                total_cost = sum(float(o.filled_qty or 0) * float(o.filled_avg_price or 0) for o in buy_orders)
+                
+                if sell_orders:
+                    sold_value = sum(float(o.filled_qty or 0) * float(o.filled_avg_price or 0) for o in sell_orders)
+                    pl_percent = ((sold_value - total_cost) / total_cost) if total_cost > 0 else 0
+                    pl_dollars = sold_value - total_cost
+                    status = "SOLD"
+                else:
+                    positions = get_current_positions()
+                    pos = next((p for p in positions if p['symbol'] == symbol), None)
+                    if pos:
+                        current_price = pos['current_price']
+                        current_value = total_bought * current_price
+                        pl_percent = ((current_value - total_cost) / total_cost) if total_cost > 0 else 0
+                        pl_dollars = current_value - total_cost
+                        status = "HOLDING"
+                    else:
+                        pl_percent = 0
+                        pl_dollars = 0
+                        status = "UNKNOWN"
+                
+                performance.append({
+                    'symbol': symbol,
+                    'pl_percent': pl_percent,
+                    'pl_dollars': pl_dollars,
+                    'investment': total_cost,
+                    'status': status
+                })
+        
+        # Sort by percentage return
+        performance.sort(key=lambda x: x['pl_percent'], reverse=True)
+        
+        output = f"🏆 BEST vs WORST PERFORMERS\n\n"
+        
+        if performance:
+            output += "🥇 TOP 5 PERFORMERS:\n"
+            for i, perf in enumerate(performance[:5]):
+                output += f"{i+1}. {perf['symbol']}: {perf['pl_percent']*100:+.2f}% (${perf['pl_dollars']:+.2f}) - {perf['status']}\n"
+            
+            output += "\n🥉 BOTTOM 5 PERFORMERS:\n"
+            for i, perf in enumerate(performance[-5:]):
+                rank = len(performance) - 4 + i
+                output += f"{rank}. {perf['symbol']}: {perf['pl_percent']*100:+.2f}% (${perf['pl_dollars']:+.2f}) - {perf['status']}\n"
+            
+            # Calculate some stats
+            total_winners = len([p for p in performance if p['pl_percent'] > 0])
+            total_losers = len([p for p in performance if p['pl_percent'] < 0])
+            
+            output += f"\n📊 SUMMARY:\n"
+            output += f"Winners: {total_winners}/{len(performance)} ({total_winners/len(performance)*100:.1f}%)\n"
+            output += f"Losers: {total_losers}/{len(performance)} ({total_losers/len(performance)*100:.1f}%)\n"
+        
+        return output
+        
+    except Exception as e:
+        return f"ERROR calculating best/worst performers: {str(e)}"
+
+def calculate_win_rate_metrics():
+    """Calculate win rate and average returns"""
+    try:
+        orders = get_order_history()
+        if not orders:
+            return "No order data available for calculation"
+        
+        symbols = set()
+        for order in orders:
+            if order.side.value == 'buy':
+                symbols.add(order.symbol)
+        
+        performance = []
+        total_investment = 0
+        
+        for symbol in symbols:
+            symbol_orders = [o for o in orders if o.symbol == symbol]
+            buy_orders = [o for o in symbol_orders if o.side.value == 'buy']
+            sell_orders = [o for o in symbol_orders if o.side.value == 'sell']
+            
+            if buy_orders:
+                total_bought = sum(float(o.filled_qty or 0) for o in buy_orders)
+                total_cost = sum(float(o.filled_qty or 0) * float(o.filled_avg_price or 0) for o in buy_orders)
+                total_investment += total_cost
+                
+                if sell_orders:
+                    sold_value = sum(float(o.filled_qty or 0) * float(o.filled_avg_price or 0) for o in sell_orders)
+                    pl_percent = ((sold_value - total_cost) / total_cost) if total_cost > 0 else 0
+                    pl_dollars = sold_value - total_cost
+                else:
+                    positions = get_current_positions()
+                    pos = next((p for p in positions if p['symbol'] == symbol), None)
+                    if pos:
+                        current_price = pos['current_price']
+                        current_value = total_bought * current_price
+                        pl_percent = ((current_value - total_cost) / total_cost) if total_cost > 0 else 0
+                        pl_dollars = current_value - total_cost
+                    else:
+                        pl_percent = 0
+                        pl_dollars = 0
+                
+                performance.append({
+                    'symbol': symbol,
+                    'pl_percent': pl_percent,
+                    'pl_dollars': pl_dollars,
+                    'investment': total_cost
+                })
+        
+        if not performance:
+            return "No performance data available"
+        
+        # Calculate metrics
+        winners = [p for p in performance if p['pl_percent'] > 0]
+        losers = [p for p in performance if p['pl_percent'] < 0]
+        breakeven = [p for p in performance if p['pl_percent'] == 0]
+        
+        win_rate = len(winners) / len(performance) * 100
+        avg_win = sum(p['pl_percent'] for p in winners) / len(winners) * 100 if winners else 0
+        avg_loss = sum(p['pl_percent'] for p in losers) / len(losers) * 100 if losers else 0
+        
+        total_pl_dollars = sum(p['pl_dollars'] for p in performance)
+        total_pl_percent = (total_pl_dollars / total_investment) * 100 if total_investment > 0 else 0
+        
+        # Risk/Reward ratio
+        risk_reward = abs(avg_win / avg_loss) if avg_loss != 0 else float('inf')
+        
+        output = f"🎯 WIN RATE & AVERAGE RETURNS\n\n"
+        output += f"Total Trades: {len(performance)}\n"
+        output += f"Win Rate: {win_rate:.1f}% ({len(winners)} winners)\n"
+        output += f"Loss Rate: {len(losers)/len(performance)*100:.1f}% ({len(losers)} losers)\n"
+        output += f"Breakeven: {len(breakeven)} trades\n\n"
+        
+        output += f"📈 AVERAGE PERFORMANCE:\n"
+        output += f"Average Winner: +{avg_win:.2f}%\n"
+        output += f"Average Loser: {avg_loss:.2f}%\n"
+        output += f"Risk/Reward Ratio: {risk_reward:.2f}:1\n\n"
+        
+        output += f"💰 TOTAL PERFORMANCE:\n"
+        output += f"Total Invested: ${total_investment:.2f}\n"
+        output += f"Total P&L: ${total_pl_dollars:+.2f}\n"
+        output += f"Total Return: {total_pl_percent:+.2f}%\n"
+        
+        return output
+        
+    except Exception as e:
+        return f"ERROR calculating win rate metrics: {str(e)}"
+
+def calculate_risk_metrics():
+    """Calculate risk metrics and volatility"""
+    try:
+        orders = get_order_history()
+        if not orders:
+            return "No order data available for calculation"
+        
+        symbols = set()
+        for order in orders:
+            if order.side.value == 'buy':
+                symbols.add(order.symbol)
+        
+        returns = []
+        investments = []
+        
+        for symbol in symbols:
+            symbol_orders = [o for o in orders if o.symbol == symbol]
+            buy_orders = [o for o in symbol_orders if o.side.value == 'buy']
+            sell_orders = [o for o in symbol_orders if o.side.value == 'sell']
+            
+            if buy_orders:
+                total_bought = sum(float(o.filled_qty or 0) for o in buy_orders)
+                total_cost = sum(float(o.filled_qty or 0) * float(o.filled_avg_price or 0) for o in buy_orders)
+                investments.append(total_cost)
+                
+                if sell_orders:
+                    sold_value = sum(float(o.filled_qty or 0) * float(o.filled_avg_price or 0) for o in sell_orders)
+                    pl_percent = ((sold_value - total_cost) / total_cost) if total_cost > 0 else 0
+                else:
+                    positions = get_current_positions()
+                    pos = next((p for p in positions if p['symbol'] == symbol), None)
+                    if pos:
+                        current_price = pos['current_price']
+                        current_value = total_bought * current_price
+                        pl_percent = ((current_value - total_cost) / total_cost) if total_cost > 0 else 0
+                    else:
+                        pl_percent = 0
+                
+                returns.append(pl_percent)
+        
+        if not returns:
+            return "No return data available"
+        
+        # Calculate statistics
+        import statistics
+        avg_return = statistics.mean(returns) * 100
+        median_return = statistics.median(returns) * 100
+        volatility = statistics.stdev(returns) * 100 if len(returns) > 1 else 0
+        
+        # Sharpe-like ratio (assuming risk-free rate = 0)
+        sharpe = avg_return / volatility if volatility > 0 else 0
+        
+        # Max drawdown
+        max_return = max(returns) * 100
+        min_return = min(returns) * 100
+        max_drawdown = max_return - min_return
+        
+        # Portfolio concentration
+        total_investment = sum(investments)
+        avg_position_size = statistics.mean(investments)
+        largest_position = max(investments)
+        concentration = (largest_position / total_investment) * 100 if total_investment > 0 else 0
+        
+        output = f"⚠️ RISK METRICS & VOLATILITY\n\n"
+        output += f"📊 RETURN STATISTICS:\n"
+        output += f"Average Return: {avg_return:+.2f}%\n"
+        output += f"Median Return: {median_return:+.2f}%\n"
+        output += f"Volatility (StdDev): {volatility:.2f}%\n"
+        output += f"Sharpe-like Ratio: {sharpe:.2f}\n\n"
+        
+        output += f"📉 RISK MEASURES:\n"
+        output += f"Best Trade: +{max_return:.2f}%\n"
+        output += f"Worst Trade: {min_return:.2f}%\n"
+        output += f"Max Range: {max_drawdown:.2f}%\n\n"
+        
+        output += f"🎯 POSITION SIZING:\n"
+        output += f"Average Position: ${avg_position_size:.2f}\n"
+        output += f"Largest Position: ${largest_position:.2f}\n"
+        output += f"Concentration Risk: {concentration:.1f}% in largest\n"
+        
+        return output
+        
+    except Exception as e:
+        return f"ERROR calculating risk metrics: {str(e)}"
+
+def calculate_time_analysis():
+    """Analyze performance by time periods"""
+    try:
+        orders = get_order_history()
+        if not orders:
+            return "No order data available for calculation"
+        
+        from datetime import datetime, timezone
+        
+        # Group orders by month
+        monthly_performance = {}
+        
+        for order in orders:
+            if order.side.value == 'buy' and order.status.value == 'filled':
+                month_key = order.filled_at.strftime('%Y-%m')
+                if month_key not in monthly_performance:
+                    monthly_performance[month_key] = {'symbols': set(), 'investment': 0, 'returns': []}
+                
+                symbol = order.symbol
+                monthly_performance[month_key]['symbols'].add(symbol)
+        
+        # Calculate returns for each month
+        symbols = set()
+        for order in orders:
+            if order.side.value == 'buy':
+                symbols.add(order.symbol)
+        
+        symbol_performance = {}
+        for symbol in symbols:
+            symbol_orders = [o for o in orders if o.symbol == symbol]
+            buy_orders = [o for o in symbol_orders if o.side.value == 'buy']
+            sell_orders = [o for o in symbol_orders if o.side.value == 'sell']
+            
+            if buy_orders:
+                first_buy = min(buy_orders, key=lambda x: x.filled_at)
+                month_key = first_buy.filled_at.strftime('%Y-%m')
+                
+                total_bought = sum(float(o.filled_qty or 0) for o in buy_orders)
+                total_cost = sum(float(o.filled_qty or 0) * float(o.filled_avg_price or 0) for o in buy_orders)
+                
+                if sell_orders:
+                    sold_value = sum(float(o.filled_qty or 0) * float(o.filled_avg_price or 0) for o in sell_orders)
+                    pl_percent = ((sold_value - total_cost) / total_cost) if total_cost > 0 else 0
+                else:
+                    positions = get_current_positions()
+                    pos = next((p for p in positions if p['symbol'] == symbol), None)
+                    if pos:
+                        current_price = pos['current_price']
+                        current_value = total_bought * current_price
+                        pl_percent = ((current_value - total_cost) / total_cost) if total_cost > 0 else 0
+                    else:
+                        pl_percent = 0
+                
+                if month_key in monthly_performance:
+                    monthly_performance[month_key]['investment'] += total_cost
+                    monthly_performance[month_key]['returns'].append(pl_percent)
+        
+        output = f"⏰ TIME-BASED PERFORMANCE ANALYSIS\n\n"
+        
+        for month in sorted(monthly_performance.keys()):
+            data = monthly_performance[month]
+            if data['returns']:
+                avg_return = sum(data['returns']) / len(data['returns']) * 100
+                total_investment = data['investment']
+                num_trades = len(data['returns'])
+                
+                output += f"📅 {month}: {avg_return:+.2f}% avg return\n"
+                output += f"   • {num_trades} trades, ${total_investment:.2f} invested\n"
+        
+        # Calculate recent vs early performance
+        sorted_months = sorted(monthly_performance.keys())
+        if len(sorted_months) >= 2:
+            early_months = sorted_months[:len(sorted_months)//2]
+            recent_months = sorted_months[len(sorted_months)//2:]
+            
+            early_returns = []
+            recent_returns = []
+            
+            for month in early_months:
+                early_returns.extend(monthly_performance[month]['returns'])
+            
+            for month in recent_months:
+                recent_returns.extend(monthly_performance[month]['returns'])
+            
+            if early_returns and recent_returns:
+                early_avg = sum(early_returns) / len(early_returns) * 100
+                recent_avg = sum(recent_returns) / len(recent_returns) * 100
+                
+                output += f"\n📈 TREND ANALYSIS:\n"
+                output += f"Early Period Avg: {early_avg:+.2f}% ({len(early_returns)} trades)\n"
+                output += f"Recent Period Avg: {recent_avg:+.2f}% ({len(recent_returns)} trades)\n"
+                output += f"Improvement: {recent_avg - early_avg:+.2f}% difference\n"
+        
+        return output
+        
+    except Exception as e:
+        return f"ERROR calculating time analysis: {str(e)}"
+
 def clear_terminal():
     """Clear terminal output"""
     return "🖥️ VM Terminal Ready\n$ "
@@ -1053,6 +1540,26 @@ def create_dashboard():
                 )
                 refresh_investment_btn = gr.Button("🔄 Refresh Investment Performance", variant="primary", size="lg")
                 
+                gr.Markdown("### 🧮 Trading Statistics & Analysis")
+                gr.Markdown("Calculate interesting metrics from your trading data")
+                
+                with gr.Row():
+                    calc_sequential_btn = gr.Button("📈 Sequential Reinvestment P&L%", variant="secondary", size="sm")
+                    calc_equal_weight_btn = gr.Button("⚖️ Equal Weight Portfolio P&L%", variant="secondary", size="sm")
+                    calc_best_worst_btn = gr.Button("🏆 Best vs Worst Performers", variant="secondary", size="sm")
+                
+                with gr.Row():
+                    calc_win_rate_btn = gr.Button("🎯 Win Rate & Avg Returns", variant="secondary", size="sm")
+                    calc_risk_metrics_btn = gr.Button("⚠️ Risk Metrics & Volatility", variant="secondary", size="sm")
+                    calc_time_analysis_btn = gr.Button("⏰ Time-based Performance", variant="secondary", size="sm")
+                
+                stats_output = gr.Textbox(
+                    label="Statistical Analysis Results",
+                    lines=8,
+                    interactive=False,
+                    elem_classes=["gr-textbox"]
+                )
+                
                 gr.Markdown("### 🔧 Debug API Calls")
                 debug_output = gr.Textbox(
                     label="Debug Output",
@@ -1205,6 +1712,32 @@ def create_dashboard():
             outputs=[debug_output]
         )
         
+        # Trading Statistics buttons
+        calc_sequential_btn.click(
+            fn=calculate_sequential_reinvestment,
+            outputs=[stats_output]
+        )
+        calc_equal_weight_btn.click(
+            fn=calculate_equal_weight_portfolio,
+            outputs=[stats_output]
+        )
+        calc_best_worst_btn.click(
+            fn=calculate_best_worst_performers,
+            outputs=[stats_output]
+        )
+        calc_win_rate_btn.click(
+            fn=calculate_win_rate_metrics,
+            outputs=[stats_output]
+        )
+        calc_risk_metrics_btn.click(
+            fn=calculate_risk_metrics,
+            outputs=[stats_output]
+        )
+        calc_time_analysis_btn.click(
+            fn=calculate_time_analysis,
+            outputs=[stats_output]
+        )
+        
         # VM Terminal tab - RADICAL FIX: Use <pre> instead of <br> and force scroll with element replacement
         def run_and_clear(cmd, output, history):
             new_output, _, new_history = run_vm_command(cmd, output, history)