Upload 6 files

agents.py

@@ -0,0 +1,420 @@
+import yfinance as yf
+import requests
+from bs4 import BeautifulSoup
+import pandas as pd
+import numpy as np
+from langchain_openai import ChatOpenAI
+import os
+import pytz
+from typing import Dict, Any
+from state import TraderState
+from datetime import datetime, timedelta
+
+os.environ["OPENAI_API_KEY"] = os.getenv("OPENROUTER_API_KEY", "")
+llm = ChatOpenAI(model="openai/gpt-3.5-turbo", openai_api_base="https://openrouter.ai/api/v1", temperature=0.2)
+
+ALPHA_VANTAGE_KEY = os.getenv("ALPHA_VANTAGE_API_KEY", "")
+NEWSAPI_KEY = os.getenv("NEWSAPI_KEY", "")
+
+def fetch_data(symbol: str, horizon: str) -> pd.DataFrame:
+    """Fetch data precisely for each trading type"""
+    if horizon == "intraday":
+        period = "1d"
+        interval = "1m"  
+    elif horizon == "scalping":
+        period = "1d"
+        interval = "1m" 
+    elif horizon == "swing":
+        period = "3mo"
+        interval = "1d"  
+    elif horizon == "momentum":
+        period = "6mo"
+        interval = "1d"  
+    else:  # long_term
+        period = "2y"
+        interval = "1d" 
+    
+    try:
+        stock = yf.Ticker(symbol)
+        hist = stock.history(period=period, interval=interval)
+        if hist.empty or len(hist) < 50:
+            hist = stock.history(period="1y", interval="1d")  # Fallback
+        if hist.empty:
+            raise ValueError(f"No data from yfinance for {symbol}")
+        
+        eastern = pytz.timezone('US/Eastern')
+        ist = pytz.timezone('Asia/Kolkata')
+        hist.index = hist.index.tz_convert(eastern).tz_convert(ist)
+        
+        print(f"Data fetched for {symbol} ({horizon}): {len(hist)} rows ({interval} intervals)")
+        return hist
+    except Exception as e:
+        print(f"Yfinance failed for {symbol}: {e}")
+        return pd.DataFrame()
+
+def compute_indicators(hist: pd.DataFrame, horizon: str) -> Dict[str, Any]:
+    if hist.empty:
+        return {"error": "No data available", "current_price": 0, "rsi": 50, "macd": 0, "sma_20": 0, "ema_50": 0, "bb_upper": 0, "bb_lower": 0, "volume_avg": 0}
+    
+    try:
+        hist = hist.sort_index()
+        close = hist['Close']
+        if len(close) < 50:
+            return {"error": "Insufficient data"}
+        delta = close.diff()
+        gain = (delta.where(delta > 0, 0)).rolling(14).mean()
+        loss = (-delta.where(delta < 0, 0)).rolling(14).mean()
+        rs = gain / loss
+        rsi = 100 - (100 / (1 + rs)).iloc[-1]
+        ema12 = close.ewm(12).mean()
+        ema26 = close.ewm(26).mean()
+        macd = ema12 - ema26
+        macd_value = macd.iloc[-1]
+        sma_20 = close.rolling(20).mean().iloc[-1]
+        ema_50 = close.ewm(50).mean().iloc[-1]
+        if len(close) >= 20:
+            std_bb = close.rolling(20).std()
+            bb_upper = (sma_20 + 2 * std_bb).iloc[-1]
+            bb_lower = (sma_20 - 2 * std_bb).iloc[-1]
+        else:
+            bb_upper = bb_lower = None
+        volume_avg = hist['Volume'].rolling(20).mean().iloc[-1] if 'Volume' in hist else 0
+        return {
+            "current_price": close.iloc[-1], "rsi": rsi, "macd": macd_value,
+            "sma_20": sma_20, "ema_50": ema_50, "bb_upper": bb_upper, "bb_lower": bb_lower,
+            "volume_avg": volume_avg
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+def fetch_news_sentiment(symbol: str) -> dict:
+    """
+    Fetch recent news from NewsAPI (free forever) and analyze sentiment.
+    """
+    try:
+        base_symbol = symbol.replace(".NS", "").replace(".BO", "")
+        query = f'"{base_symbol}" OR "{base_symbol} stock"'
+        url = f"https://newsapi.org/v2/everything?q={query}&sortBy=publishedAt&apiKey={NEWSAPI_KEY}&pageSize=10&language=en"
+        response = requests.get(url, timeout=10)
+        data = response.json()
+        
+        if 'articles' in data and data['articles']:
+            articles = data['articles'][:5]
+            headlines = [art['title'] for art in articles]
+            descriptions = [art.get('description', '') for art in articles]
+            
+            positive_words = ['gain', 'rise', 'profit', 'growth', 'earnings', 'bullish', 'up', 'positive', 'strong']
+            negative_words = ['loss', 'fall', 'decline', 'drop', 'bearish', 'down', 'negative', 'weak', 'crash']
+            
+            pos_count = sum(1 for h in headlines + descriptions for word in positive_words if word in h.lower())
+            neg_count = sum(1 for h in headlines + descriptions for word in negative_words if word in h.lower())
+            
+            sentiment = 'positive' if pos_count > neg_count else 'negative' if neg_count > pos_count else 'neutral'
+            summary = f"Recent news sentiment: {sentiment}. Key headlines: {'; '.join(headlines[:3])}."
+            return {'sentiment': sentiment, 'headlines': headlines, 'summary': summary}
+        else:
+            return {'sentiment': 'neutral', 'headlines': ["No recent news found."], 'summary': "No recent news available; sentiment neutral."}
+    except Exception as e:
+        print(f"NewsAPI error: {e}")
+        return {'sentiment': 'neutral', 'headlines': ["News fetch failed."], 'summary': "News unavailable; assuming neutral sentiment."}
+
+def summarize_features(indicators: Dict[str, Any], hist: pd.DataFrame, news: list, action: str, symbol: str, news_sentiment: str = 'neutral') -> str:
+    if indicators.get("error"):
+        try:
+            stock = yf.Ticker(symbol)
+            info = stock.info
+            price = info.get('currentPrice', 0)
+            change = info.get('regularMarketChangePercent', 0)
+            signals = [f"Recent change: {change:.1f}%"]
+            if change > 0:
+                signals.append("Positive momentum")
+            else:
+                signals.append("Negative momentum")
+            return f"Fallback Signals: {', '.join(signals)}; News: {news[0] if news else 'Neutral'}"
+        except:
+            return "No reliable data; default to caution."
+    
+    rsi = indicators.get('rsi', 50)
+    macd = indicators.get('macd', 0)
+    price = indicators.get('current_price', 0)
+    sma_20 = indicators.get('sma_20', price)
+    bb_upper = indicators.get('bb_upper', price * 1.1)
+    bb_lower = indicators.get('bb_lower', price * 0.9)
+    
+    recent_prices = hist['Close'].tail(10) if not hist.empty else pd.Series([price])
+    trend = "upward" if recent_prices.iloc[-1] > recent_prices.iloc[0] else "downward"
+    change_pct = ((recent_prices.iloc[-1] - recent_prices.iloc[0]) / recent_prices.iloc[0]) * 100 if len(recent_prices) > 1 else 0
+    
+    signals = []
+    if rsi < 30:
+        signals.append("Oversold RSI (potential buy reversal)")
+    elif rsi > 70:
+        signals.append("Overbought RSI (sell risk)")
+    if macd > 0:
+        signals.append("Bullish MACD")
+    else:
+        signals.append("Bearish MACD")
+    if price < bb_lower:
+        signals.append("Price near support (buy opportunity)")
+    elif price > bb_upper:
+        signals.append("Price near resistance (sell signal)")
+    if price > sma_20:
+        signals.append("Above SMA20 (momentum)")
+    else:
+        signals.append("Below SMA20 (weakness)")
+    
+    news_sentiment_str = f"News Sentiment: {news_sentiment.capitalize()} (e.g., {news[0] if news else 'No updates'})"
+    
+    action_bias = "favorable for buying" if action == "buy" and trend == "upward" else "favorable for selling" if action == "sell" and trend == "downward" else "mixed"
+    
+    features = [
+        f"Trend: {trend} ({change_pct:.1f}% change)",
+        f"Key Signals: {', '.join(signals)}",
+        news_sentiment_str,
+        f"Overall Bias for {action}: {action_bias}"
+    ]
+    return "; ".join(features)
+
+def calculate_holding_metrics(hist: pd.DataFrame, holding_period: str, current_price: float) -> Dict[str, Any]:
+    if not holding_period or hist.empty:
+        return {}
+    
+    import re
+    match = re.search(r'(\d+)\s*(month|week|day)', holding_period.lower())
+    if match:
+        num, unit = int(match.group(1)), match.group(2)
+        days = num * 30 if unit == 'month' else num * 7 if unit == 'week' else num
+        purchase_date = datetime.now(pytz.timezone('Asia/Kolkata')) - timedelta(days=days)
+        hist_before = hist[hist.index < purchase_date]
+        if not hist_before.empty:
+            purchase_price = hist_before['Close'].iloc[-1]
+        else:
+            # Use oldest price in data if exact date not found
+            purchase_price = hist['Close'].iloc[0] if not hist.empty else 0
+        
+        try:
+            live_price = yf.Ticker(hist.index.name or 'AAPL').info.get('currentPrice', current_price)
+            if live_price <= 0:
+                live_price = current_price
+        except:
+            live_price = current_price
+        
+        if purchase_price > 0:
+            holding_return = ((live_price - purchase_price) / purchase_price) * 100
+        else:
+            holding_return = 0  
+        
+        return {
+            "purchase_price": purchase_price,
+            "holding_return": holding_return,
+            "days_held": days,
+            "pnl": "profit" if holding_return > 0 else "loss"
+        }
+    return {}
+
+def predict(horizon: str, indicators: Dict[str, Any], hist: pd.DataFrame, news: list, news_sentiment: str = 'neutral') -> str:
+    if hist.empty or indicators.get("error"):
+        return "Unable to predict due to lack of data."
+    
+    rsi = indicators.get('rsi', 50)
+    macd = indicators.get('macd', 0)
+    close = hist['Close']
+    
+    if horizon == "intraday":
+        # minute changes for same-day prediction
+        recent_change = ((close.iloc[-1] - close.iloc[-10]) / close.iloc[-10]) * 100 if len(close) >= 10 else 0  # Last 10 minutes
+        prob = 70 if (rsi < 40 and macd > 0) else 50 if rsi > 60 else 30
+        direction = "rise" if recent_change > 0 else "fall"
+        pct = abs(recent_change) * 0.8
+        sentiment_boost = 1.15 if news_sentiment == 'positive' else 0.85 if news_sentiment == 'negative' else 1.0
+        prob = min(95, int(prob * sentiment_boost))
+        return f"{prob}% chance of {pct:.1f}% {direction} in the next 1-2 hours (same-day intraday) based on RSI {rsi:.1f}, MACD {macd:.2f}, recent {recent_change:.1f}% change, and {news_sentiment} news."
+    
+    elif horizon == "scalping":
+        # Ultra-short minute prediction
+        recent_change = ((close.iloc[-1] - close.iloc[-5]) / close.iloc[-5]) * 100 if len(close) >= 5 else 0  # Last 5 minutes
+        prob = 80 if rsi < 35 else 40
+        direction = "quick rise" if rsi < 35 else "quick fall"
+        pct = 1.5
+        return f"{prob}% chance of {pct:.1f}% {direction} in the next 5-10 minutes (ultra-short scalping) based on RSI ({rsi:.1f})."
+    
+    elif horizon == "swing":
+        # Formula: Weekly changes for 1-4 week prediction
+        avg_weekly = close.tail(20).pct_change().mean() * 100 if len(close) >= 20 else 0  # Approx weekly
+        prob = 65 if avg_weekly > 0 and macd > 0 else 45 if avg_weekly < 0 else 50
+        direction = "up" if avg_weekly > 0 else "down"
+        pct = abs(avg_weekly) * 3
+        return f"{prob}% chance of {pct:.1f}% {direction} over the next 1-4 weeks (swing trading)."
+    
+    elif horizon == "momentum":
+        # Formula: Momentum over weeks
+        prob = 70 if macd > 0 and rsi < 60 else 45
+        direction = "continued rise" if macd > 0 else "fall"
+        pct = 4.0
+        return f"{prob}% chance of {pct:.1f}% {direction} over the next 2-4 weeks (momentum trading) based on MACD ({macd:.2f})."
+    
+    else:  # long_term
+        # Formula: Monthly changes for months/years
+        avg_monthly = close.tail(60).pct_change().mean() * 100 if len(close) >= 60 else 0
+        prob = 70 if avg_monthly > 1 and macd > 0 else 40 if avg_monthly < 0 else 50
+        direction = "growth" if avg_monthly > 0 else "decline"
+        pct = abs(avg_monthly) * 2
+        sentiment_boost = 1.15 if news_sentiment == 'positive' else 0.85 if news_sentiment == 'negative' else 1.0
+        prob = min(95, int(prob * sentiment_boost))
+        return f"{prob}% chance of {pct:.1f}% {direction} over months (position trading) based on {avg_monthly:.1f}% avg monthly change and {news_sentiment} news."
+
+def hunter_agent(state: TraderState) -> TraderState:
+    try:
+        symbol = state['input_symbol']
+        action = state['action']
+        horizon = state['horizon']
+        
+        if state.get('raw_data') and state['raw_data'].get('hist') is not None:
+            hist = state['raw_data']['hist']
+        else:
+            hist = fetch_data(symbol, horizon)
+            if state.get('raw_data') is None:
+                state['raw_data'] = {}
+            state['raw_data']['hist'] = hist
+        
+        indicators = compute_indicators(hist, horizon)
+        news_data = fetch_news_sentiment(symbol)
+        headlines = news_data['headlines']
+        news_sentiment = news_data['sentiment']
+        
+        features_summary = summarize_features(indicators, hist, headlines, action, symbol, news_sentiment)
+        prediction = predict(horizon, indicators, hist, headlines, news_sentiment)
+        holding_metrics = calculate_holding_metrics(hist, state.get('holding_period'), indicators.get('current_price', 0))
+        
+        state['raw_data']['indicators'] = indicators
+        state['raw_data']['news'] = headlines
+        state['raw_data']['features'] = features_summary
+        state['raw_data']['prediction'] = prediction
+        state['raw_data']['holding'] = holding_metrics
+        state['raw_data']['news_sentiment'] = news_sentiment
+        
+        if holding_metrics:
+            features_summary += f"; Holding: {holding_metrics['days_held']} days, {holding_metrics['holding_return']:.1f}% {holding_metrics['pnl']}"
+        
+        rsi = indicators.get('rsi', 50)
+        macd = indicators.get('macd', 0)
+        
+        if action == "buy":
+            if rsi < 30 and macd > 0:
+                state['claim'] = f"Strong buy signal: Oversold RSI ({rsi:.1f}) with bullish MACD ({macd:.2f}) indicates reversal."
+            elif rsi < 40 or macd > 5:
+                state['claim'] = f"Moderate buy signal: RSI at {rsi:.1f}, MACD at {macd:.2f} shows positive momentum."
+            else:
+                state['claim'] = f"Weak buy signal: RSI ({rsi:.1f}) and MACD ({macd:.2f}) don't strongly support buying now."
+        else:
+            if rsi > 70 or macd < -5:
+                state['claim'] = f"Strong sell signal: Overbought RSI ({rsi:.1f}) or weak MACD ({macd:.2f}) suggests taking profits."
+            elif rsi > 60 or macd < 0:
+                state['claim'] = f"Moderate sell signal: RSI at {rsi:.1f}, MACD at {macd:.2f} shows weakening momentum."
+            else:
+                state['claim'] = f"Weak sell signal: RSI ({rsi:.1f}) and MACD ({macd:.2f}) don't strongly support selling now."
+        
+        return state
+    except Exception as e:
+        print(f"Error in hunter_agent: {e}")
+        return state  # Always return state
+
+def skeptic_agent(state: TraderState) -> TraderState:
+    try:
+        # Use cached raw_data
+        raw_data = state.get('raw_data', {}) or {}
+        features_summary = raw_data.get("features", "No features available.")
+        action = state['action']
+        prompt = f"Counter claim '{state.get('claim', '')}' for {action}: {features_summary}. Provide 1 specific risk."
+        try:
+            state['skepticism'] = llm.invoke(prompt).content.strip()
+        except:
+            rsi = raw_data.get("indicators", {}).get('rsi', 50)
+            state['skepticism'] = f"Risk: RSI at {rsi} indicates potential reversal."
+        return state
+    except Exception as e:
+        print(f"Error in skeptic_agent: {e}")
+        return state  # Always return state
+
+def calibrator_agent(state: TraderState) -> TraderState:
+    try:
+        raw_data = state.get('raw_data', {}) or {}
+        indicators = raw_data.get("indicators", {})
+        action = state['action']
+        news_sentiment = raw_data.get('news_sentiment', 'neutral')
+        holding = raw_data.get('holding', {})
+        
+        state['iterations'] = state.get('iterations', 0) + 1
+        
+        rsi = indicators.get('rsi', 50)
+        macd = indicators.get('macd', 0)
+        
+        base = 50
+        
+        if action == "buy":
+            if rsi < 30:
+                base += 30
+            elif rsi < 40:
+                base += 15
+            elif rsi > 70:
+                base -= 25
+            elif rsi > 60:
+                base -= 10
+            
+            if macd > 5:
+                base += 20
+            elif macd > 0:
+                base += 10
+            elif macd < -5:
+                base -= 20
+            elif macd < 0:
+                base -= 10
+            
+            if news_sentiment == 'positive':
+                base += 15
+            elif news_sentiment == 'negative':
+                base -= 15
+        
+        else:
+            if rsi > 70:
+                base += 30
+            elif rsi > 60:
+                base += 15
+            elif rsi < 30:
+                base -= 25
+            elif rsi < 40:
+                base -= 10
+            
+            if macd < -5:
+                base += 20
+            elif macd < 0:
+                base += 10
+            elif macd > 5:
+                base -= 20
+            elif macd > 0:
+                base -= 10
+            
+            if news_sentiment == 'negative':
+                base += 15
+            elif news_sentiment == 'positive':
+                base -= 15
+        
+        if holding:
+            pnl_pct = holding.get('holding_return', 0)
+            if action == "sell":
+                if pnl_pct > 10:
+                    base += 15
+                elif pnl_pct > 5:
+                    base += 10
+                elif pnl_pct < -10:
+                    base += 20
+                elif pnl_pct < -5:
+                    base += 10
+        
+        state['confidence'] = min(95, max(5, base))
+        state['stop'] = state['iterations'] >= 5 or state['confidence'] >= 85 or state['confidence'] <= 15
+        
+        return state
+    except Exception as e:
+        print(f"Error in calibrator_agent: {e}")
+        return state

graph.py

@@ -0,0 +1,24 @@
+from langgraph.graph import StateGraph, END  
+from agents import hunter_agent, skeptic_agent, calibrator_agent
+from state import TraderState
+
+
+graph = StateGraph(TraderState)
+
+graph.add_node("hunter", hunter_agent)
+graph.add_node("skeptic", skeptic_agent)
+graph.add_node("calibrator", calibrator_agent)
+
+# hunter -> skeptic -> calibrator
+graph.add_edge("hunter", "skeptic")
+graph.add_edge("skeptic", "calibrator")
+
+# Conditional edge from calibrator: If stop is True that means it end and go to END; else it will loop back to hunter
+def should_continue(state: TraderState) -> str:
+    return END if state.get('stop', False) else "hunter"
+
+graph.add_conditional_edges("calibrator", should_continue)
+
+graph.set_entry_point("hunter")
+
+compiled_graph = graph.compile()

main.py

@@ -0,0 +1,325 @@
+from state import TraderState
+from agents import hunter_agent, skeptic_agent, calibrator_agent, fetch_data
+from dotenv import load_dotenv
+from langchain_openai import ChatOpenAI
+import os
+import re
+import json
+import pytz
+from datetime import datetime, timedelta
+import yfinance as yf
+
+load_dotenv()
+os.environ["OPENAI_API_KEY"] = os.getenv("OPENROUTER_API_KEY", "")
+llm_parser = ChatOpenAI(model="openai/gpt-3.5-turbo", openai_api_base="https://openrouter.ai/api/v1", temperature=0.0)
+
+def resolve_symbol(user_input: str) -> str:
+    """
+    Handles Indian stocks (.NS/.BO).
+    """
+    prompt = f"""
+    Analyze this user query: "{user_input}".
+    - Extract the company/brand name.
+    - Infer the likely stock market.
+    - Suggest the stock ticker symbol with the appropriate exchange suffix 
+      (e.g., "GOOGL" for US, "TCS.NS" for NSE India).
+    - If it is an Indian stock, it MUST end with ".NS" or ".BO".
+    - Respond only with the symbol. If unsure, say "UNKNOWN".
+    """
+    try:
+        suggested_symbol = llm_parser.invoke(prompt).content.strip().upper()
+        if suggested_symbol == "UNKNOWN":
+            return None
+        
+        if not (suggested_symbol.endswith(".NS") or suggested_symbol.endswith(".BO")):
+            is_india_prompt = f"Is the stock/company '{suggested_symbol}' from the query '{user_input}' traded on Indian exchanges? Answer only YES or NO."
+            is_india = llm_parser.invoke(is_india_prompt).content.strip().upper()
+            
+            if "YES" in is_india:
+                suggested_symbol += ".NS"
+
+        # Try NSE, fallback to BSE
+        ticker = yf.Ticker(suggested_symbol)
+
+        if not ticker.history(period="1d").empty:
+            return suggested_symbol
+        
+        # If NSE (.NS) failed, it might be a BSE-only stock
+        if suggested_symbol.endswith(".NS"):
+            bse_symbol = suggested_symbol.replace(".NS", ".BO")
+            if not yf.Ticker(bse_symbol).history(period="1d").empty:
+                return bse_symbol
+        # Fallback
+        refine_prompt = f"The symbol '{suggested_symbol}' didn't validate. Suggest the EXACT ticker for: '{user_input}'. Respond ONLY with the ticker."
+        refined_symbol = llm_parser.invoke(refine_prompt).content.strip().upper()
+        
+        # The same suffix logic
+        if not (refined_symbol.endswith(".NS") or refined_symbol.endswith(".BO")):
+            if "YES" in is_india: 
+                refined_symbol += ".NS"
+                
+        if not yf.Ticker(refined_symbol).history(period="1d").empty:
+            return refined_symbol
+            
+    except Exception as e:
+        print(f"Symbol resolution error: {e}")
+    return None
+
+
+def parse_query(user_input: str) -> tuple:
+    """FIXED: Proper horizon detection based on correct trading logic"""
+    prompt = f"""
+    Analyze this user query: "{user_input}".
+    
+    TRADING HORIZONS (CRITICAL):
+    - "intraday": same day buy and same day sell (hours)
+    - "scalping": ultra-short (minutes)
+    - "swing": buy this week, sell next week (1-4 weeks)
+    - "momentum": trend-following over weeks (2-4 weeks)
+    - "long_term": months to years (position trading, e.g., "bought 1 month ago")
+    
+    Extract:
+    - stock symbol (e.g., "HINDUNILVR.NS")
+    - action: "buy" or "sell" (default "buy")
+    - horizon: match to above definitions
+    - date: "today", "tomorrow", or future (e.g., "after 2 weeks")
+    - holding_period: If mentioned (e.g., "1 week ago", "a week ago"), provide as "X unit ago". Else, None.
+    
+    CRITICAL: If user says "bought X time ago" → horizon = "long_term"
+    If user says "tomorrow" without history → horizon = "intraday" (same-day strategy for next day)
+    
+    Respond ONLY in JSON: {{"symbol": "HINDUNILVR.NS", "action": "sell", "horizon": "long_term", "date": "2025-12-27", "holding_period": "1 week ago"}}. Respond sholud be clean.
+    """
+    try:
+        response = llm_parser.invoke(prompt).content.strip()
+        parsed = json.loads(response)
+        symbol = parsed.get("symbol")
+        action = parsed.get("action", "buy")
+        horizon = parsed.get("horizon", "intraday")
+        date_str = parsed.get("date")
+        holding_period = parsed.get("holding_period")
+        
+        # Override horizon detection with explicit logic
+        if "ago" in user_input.lower() or "bought" in user_input.lower() or "purchased" in user_input.lower():
+            horizon = "long_term"
+        elif "tomorrow" in user_input.lower() and "ago" not in user_input.lower():
+            horizon = "intraday"
+        elif "week" in user_input.lower() and "ago" not in user_input.lower():
+            horizon = "swing"
+        elif "minute" in user_input.lower() or "scalp" in user_input.lower():
+            horizon = "scalping"
+        elif "month" in user_input.lower() and "ago" in user_input.lower():
+            horizon = "long_term"
+        
+        ist = pytz.timezone('Asia/Kolkata')
+        now_ist = datetime.now(ist)
+        date = None
+        if date_str == "today":
+            date = now_ist.strftime("%Y-%m-%d")
+        elif date_str == "tomorrow":
+            date = (now_ist + timedelta(days=1)).strftime("%Y-%m-%d")
+        elif date_str and "after" in user_input.lower():
+            match = re.search(r'after\s+(\d+)\s*(week|month)', user_input.lower())
+            if match:
+                num, unit = int(match.group(1)), match.group(2)
+                days = num * 7 if unit == "week" else num * 30
+                date = (now_ist + timedelta(days=days)).strftime("%Y-%m-%d")
+        
+        return symbol, date, action, horizon, holding_period
+    except Exception as e:
+        print(f"Parsing error: {e}. Fallback.")
+        symbol = resolve_symbol(user_input)
+        action = "sell" if "sell" in user_input.lower() else "buy"
+        
+        # CRITICAL FIX: Correct horizon fallback
+        if "ago" in user_input.lower() or "month" in user_input.lower() or "bought" in user_input.lower():
+            horizon = "long_term"
+        elif "week" in user_input.lower() and "ago" not in user_input.lower():
+            horizon = "swing"
+        elif "minute" in user_input.lower():
+            horizon = "scalping"
+        elif "tomorrow" in user_input.lower():
+            horizon = "intraday"
+        else:
+            horizon = "intraday"
+        
+        ist = pytz.timezone('Asia/Kolkata')
+        now_ist = datetime.now(ist)
+        date = now_ist.strftime("%Y-%m-%d") if "today" in user_input.lower() else (now_ist + timedelta(days=1)).strftime("%Y-%m-%d") if "tomorrow" in user_input.lower() else None
+        
+        match = re.search(r'(\d+)\s*(week|month|day)\s*ago', user_input.lower())
+        holding_period = f"{match.group(1)} {match.group(2)} ago" if match else None
+        
+        return symbol, date, action, horizon, holding_period
+
+def generate_alert_message(state: TraderState, symbol: str, action: str, horizon: str) -> str:
+    confidence = state['confidence']
+    raw_data = state.get('raw_data', {}) or {}
+    indicators = raw_data.get("indicators", {})
+    news = raw_data.get("news", [])
+    prediction = raw_data.get("prediction", "No prediction available.")
+    holding = raw_data.get("holding", {})
+    claim = state.get('claim', 'No claim.')
+    skepticism = state.get('skepticism', 'No skepticism.')
+    features = raw_data.get("features", "")
+    
+    rsi = indicators.get('rsi', 50)
+    macd = indicators.get('macd', 0)
+    current_price = indicators.get('current_price', 1)
+    
+    volatility = 0
+    if current_price > 0:
+        bb_upper = indicators.get('bb_upper', current_price * 1.1)
+        bb_lower = indicators.get('bb_lower', current_price * 0.9)
+        volatility = (bb_upper - bb_lower) / current_price * 100
+    
+    risk_adjustment = min(20, volatility / 5) if volatility > 0 else 0
+    
+    if holding:
+        pnl_adjustment = 10 if holding.get('holding_return', 0) > 5 else -10 if holding.get('holding_return', 0) < -5 else 0
+        allocation = max(0, min(100, confidence - risk_adjustment + pnl_adjustment))
+    else:
+        allocation = max(0, min(100, confidence - risk_adjustment))
+    
+    if indicators.get("error") == "No data available":
+        return f" No Data Available\nSorry, we couldn't fetch reliable data for {symbol}. Check official sources like NSE or Yahoo Finance. Try searching for '{symbol}.NS' if it's an Indian stock."
+    
+    # HORIZON-AWARE best date suggestion
+    horizon_desc = {
+        "intraday": "same-day trading (hours)",
+        "scalping": "ultra-short (minutes)",
+        "swing": "1-4 weeks",
+        "momentum": "2-4 weeks",
+        "long_term": "months to years"
+    }
+    
+    best_date_prompt = f"""
+    Based on prediction: '{prediction}', indicators: RSI {rsi:.1f}, MACD {macd:.2f}, trend: {features.split(';')[0] if features else 'N/A'}.
+    User query involves '{action}' for '{horizon}' ({horizon_desc.get(horizon, horizon)}). 
+    Suggest the SPECIFIC best date/time to {action} {symbol} for maximum benefit. 
+    - For intraday/scalping: suggest time of day (e.g., "Sell tomorrow at 10:30 AM IST for 1.5% gain")
+    - For swing/momentum: suggest specific date within the horizon (e.g., "Buy on Jan 2, 2026")
+    - For long_term: suggest holding duration (e.g., "Hold until Feb 2026 for 8% gain")
+    Include % potential gain/loss. Be accurate and align with user intent.
+    """
+    try:
+        best_date = llm_parser.invoke(best_date_prompt).content.strip()
+    except:
+        best_date = f"Based on trends, {action} within {horizon_desc.get(horizon, horizon)} for potential 1-3% {'gain' if action == 'buy' else 'exit'}."
+    
+    why_prompt = f"""
+    Based on claim: '{claim}', skepticism: '{skepticism}', features: '{features}', prediction: '{prediction}', holding: '{holding}'.
+    RSI is {rsi:.1f} (low = oversold/buy signal, high = overbought/sell signal). MACD is {macd:.2f} (positive = bullish, negative = bearish).
+    Explain why the signal is Green/Yellow/Red for {action} {symbol} ({horizon} = {horizon_desc.get(horizon, horizon)}). 
+    Use layman terms, reference indicators accurately, tie to data. Be genuine—align with RSI/MACD signals.
+    """
+    try:
+        why = llm_parser.invoke(why_prompt).content.strip()
+    except:
+        why = f"Based on RSI ({rsi:.1f}) and MACD ({macd:.2f}), conditions are {'favorable' if confidence > 60 else 'mixed' if confidence > 40 else 'unfavorable'} for {action}."
+    
+    if confidence >= 70:
+        color = " Green: 'Yes, Go Ahead!'"
+        should_action = f"Yes, {action} now. Allocate {allocation:.0f}% as signals are strong."
+    elif confidence >= 40:
+        color = " Yellow: 'Wait and Watch'"
+        should_action = f"Maybe, monitor closely. Allocate {allocation:.0f}% cautiously due to mixed signals and potential risk."
+    else:
+        color = " Red: 'No, Stop!'"
+        should_action = f"No, avoid {action}. Signals are weak; wait for better conditions."
+    
+    holding_summary = ""
+    if holding:
+        h_return = holding['holding_return']
+        holding_summary = f"\n**Holding Summary**: Purchased {holding['days_held']} days ago at ₹{holding['purchase_price']:.2f}, current: ₹{holding.get('current_price', current_price):.2f}, return: {h_return:.1f}% ({holding['pnl']})."
+        
+        
+        if h_return > 0:
+            advice = "lock in gains"
+        elif h_return < 0:
+            advice = "wait for recovery or cut losses"
+        else:
+            advice = "exit at breakeven" 
+            
+        should_action += f" Based on {h_return:.1f}% {holding['pnl']}, {advice}."
+
+    report = f"""
+--- AI Trader Analyzer Report ---
+Symbol: {symbol} 
+**Current Price**: {current_price:,.4f}
+Action: {action.capitalize()} ({horizon.replace('_', '-').capitalize()} = {horizon_desc.get(horizon, horizon)}) "/n"
+Date: {state.get('query_date', 'N/A')} (IST) 
+Signal: {color} 
+Confidence: {confidence}% 
+Key Metrics: RSI {rsi:.1f}, MACD {macd:.2f}, Trend {features.split(';')[0] if features else 'N/A'} 
+{holding_summary} 
+Should I {action.capitalize()}?** {should_action}  
+Best Date/Time to {action.capitalize()}**: {best_date} 
+Why? {why} 
+Prediction: {prediction} 
+Recommendation: Allocate {allocation:.0f}% based on analysis. Not financial advice. 
+"""
+    return report.strip()
+
+def main():
+    symbol, date, action, horizon, holding_period = None, None, None, None, None
+    while not symbol:
+        user_input = input("Describe the stock (e.g., 'I want to buy Apple stock for today' or 'I purchased TCS.NS stock 1 month ago, now sell today'): ").strip()
+        symbol, date, action, horizon, holding_period = parse_query(user_input)
+        if not symbol:
+            print("No symbol detected. Try again.")
+    
+    print(f"Analyzing: {symbol} on {date or 'recent'} (IST) for {action} ({horizon})" + (f", holding: {holding_period}" if holding_period else ""))
+    
+    # Fetch data ONCE before the loop
+    hist = fetch_data(symbol, horizon)
+    
+    state = TraderState(
+        input_symbol=symbol,
+        query_date=date,
+        action=action,
+        horizon=horizon,
+        holding_period=holding_period,
+        # Pre-load data
+        raw_data={'hist': hist},  
+        claim=None,
+        skepticism=None,
+        confidence=50,
+        iterations=0,
+        stop=False,
+        alert_message=None
+    )
+    
+    max_iterations = 5
+    for _ in range(max_iterations):
+        state = hunter_agent(state)
+        state = skeptic_agent(state)
+        state = calibrator_agent(state)
+        if state['stop']:
+            break
+    
+    state['alert_message'] = generate_alert_message(state, symbol, action, horizon)
+    
+    result = {
+        "symbol": symbol,
+        "date": date,
+        "action": action,
+        "horizon": horizon,
+        "holding_period": holding_period,
+        "alert_message": state['alert_message'],
+        "iterations": state['iterations'],
+        "confidence": state['confidence']
+    }
+    
+    print("\n--- AI Trader Analyzer Result ---")
+    print(f"Symbol: {result['symbol']}")
+    print(f"Date: {result['date']} (IST)")
+    print(f"Action: {result['action']}")
+    print(f"Horizon: {result['horizon']}")
+    print(f"Holding: {result['holding_period'] or 'None'}")
+    print(f"Message:\n{result['alert_message']}")
+    print(f"Iterations: {result['iterations']}")
+    print(f"Confidence: {result['confidence']}%")
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,17 @@
+openai 
+langchain 
+langgraph 
+yfinance 
+requests 
+uvicorn
+matplotlib
+pydantic 
+beautifulsoup4 
+python-dotenv 
+numpy
+pytz
+weasyprint
+taipy
+fpdf2 
+streamlit
+fastapi

state.py

@@ -0,0 +1,18 @@
+from typing import TypedDict, Optional, List, Dict, Any
+
+class TraderState(TypedDict):
+    input_symbol: str
+    query_date: Optional[str]
+    # 'buy' or 'sell'
+    action: str  
+    # 'intraday', 'scalping', 'swing', 'momentum', 'long_term'
+    horizon: str  
+    # "1 month ago", "2 month ago",etc.
+    holding_period: Optional[str] 
+    raw_data: Optional[Dict[str, Any]]
+    claim: Optional[str]
+    skepticism: Optional[str]
+    confidence: int
+    iterations: int
+    stop: bool
+    alert_message: Optional[str]

style.css

@@ -0,0 +1,140 @@
+/* Make Comparison/Analysis subheaders white and bold */
+h3 {
+    color: white !important;
+    font-size: 1.8rem !important;
+    text-shadow: 2px 2px 4px rgba(0, 0, 0, 1);
+    margin-top: 30px !important;
+}
+
+/* Ensure stock names and "Analysis:" text stay white */
+.stMarkdown h3, .stMarkdown b, .stMarkdown strong {
+    color: white !important;
+}
+
+/* Your existing white-box result style stays for the report itself */
+[data-testid="stText"] {
+    background-color: white !important;
+    color: black !important;
+    padding: 15px !important;
+    border-radius: 10px !important;
+}
+
+/* Target the result alert blocks specifically */
+[data-testid="stText"] {
+    background-color: white !important;
+    color: black !important;
+    padding: 15px !important;
+    border-radius: 10px !important;
+    border: 1px solid #ccc !important;
+}
+
+/* Ensure the preformatted text inside the block is also black */
+[data-testid="stText"] pre {
+    color: black !important;
+}
+
+.block-container {
+    padding-top: 1rem !important;
+}
+
+h1 {
+    margin-top: -20px !important;
+    margin-bottom: 90px !important;
+    color: white !important;
+    text-shadow: 2px 2px 4px rgba(0,0,0,0.8);
+    text-align: center;
+}
+
+.stButton button:hover {
+    background-color: transparent !important;
+    color: white !important;
+    border: 1px solid white;
+}
+
+.block-container {
+    padding-top: 1rem !important; 
+    padding-bottom: 0rem;
+}
+
+/* Specifically target the heading to remove any extra margin */
+h1 {
+    margin-top: -20px !important; 
+    padding-top: 0px !important;
+    margin-bottom: 90px !important;
+    color: white !important;
+    text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.8);
+    text-align: center;
+}
+
+/* Ensures the header bar doesn't block your title */
+header.stAppHeader {
+    background-color: transparent;
+}
+
+/* Target all Streamlit buttons */
+.stButton button {
+    background-color: #0e3558; 
+    color: #FFFFFF;
+    border: 1px solid #FFFFFF; 
+    border-radius: 25px; 
+    transition: background-color 0.3s ease, color 0.3s ease;
+}
+
+
+.stButton button:hover {
+    background-color: transparent !important; 
+    color: white !important; 
+    border: 1px solid white; 
+}
+
+
+.stButton button:focus {
+    color: white !important;
+}
+/* Fix the Title (st.title) visibility */
+h1 {
+    color: white !important;
+    text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.8);
+    text-align: center;
+}
+
+/* Fix the Label for the text input box */
+.stTextInput label {
+    color: white !important;
+    font-size: 1.2rem;
+    font-weight: bold;
+    text-shadow: 1px 1px 2px rgba(0, 0, 0, 0.8);
+}
+
+.stTextInput input {
+    color: #000000; /* Keeping input text black for clarity against white box */
+    border-radius: 8px; /* Your 'br' fixing */
+}
+
+/* Target the main container for a full-screen background */
+
+[data-testid="stAppViewContainer"] {
+    background-image: url("data:image/jpg;base64,IMAGE_PLACEHOLDER");
+    background-size: cover;
+    background-position: center;
+    background-attachment: fixed;
+}
+
+/* Fix your alignment and borders (br) here */
+.main {
+    background-color: transparent;
+    padding: 2rem;
+}
+
+/* Centered container for your title */
+.centered-title-container {
+    text-align: center;
+    border-radius: 12px; 
+    background-color: rgba(0, 0, 0, 0.5); 
+    padding: 20px;
+    margin-bottom: 25px;
+}
+
+[data-testid="stSidebar"] {
+    background-color: rgba(38, 39, 48, 0.9);
+}