marketmyna 0.2.0__py3-none-any.whl

marketmyna/bot/commands/ask.py

@@ -0,0 +1,51 @@
+"""/ask <question> - a single LLM call for a free-form question, not the
+full agent pipeline (no tool use, no multi-turn memory in this phase).
+
+"/research" is registered as an alias here rather than a distinct
+command: a real deep-research capability (multi-step, tool-using, like
+daily_stock_analysis's own research agent) is real extra scope this
+phase doesn't build. Aliasing it to /ask is an honest "this exists but
+is shallower than the name implies", not a silent stand-in for
+something it isn't.
+"""
+
+from __future__ import annotations
+
+from ...llm.backend_factory import create_generation_backend
+from ...llm.protocol import GenerationConfig
+from ..models import CommandResult, IncomingMessage
+from .base import Command
+
+SYSTEM_PROMPT = (
+    "You are a stock research assistant embedded in a chat bot. Answer the "
+    "user's question concisely (a few sentences). You have no live tool "
+    "access in this mode - if the question needs a live quote or a full "
+    "technical/risk analysis, say so and suggest /analyze SYMBOL instead "
+    "of guessing at numbers you don't have."
+)
+
+
+class AskCommand(Command):
+    name = "ask"
+    aliases = ["research", "r"]
+    usage = "/ask QUESTION"
+    description = "Free-form question to the AI model (no live data)."
+    group = "AI analysis"
+    example = "/ask What does a falling RSI mean?"
+    help_text = "/ask <question> - ask a free-form question (also: /research, shallower than a full deep-research pass)"
+
+    def __init__(self, config):
+        self._config = config
+
+    def handle(self, message: IncomingMessage, args: str) -> CommandResult:
+        question = args.strip()
+        if not question:
+            return CommandResult(text=f"Usage: {self.help_text}", success=False)
+
+        try:
+            backend = create_generation_backend(self._config, tier="fast")
+            result = backend.generate(question, GenerationConfig(), system_prompt=SYSTEM_PROMPT)
+        except Exception as exc:
+            return CommandResult(text=f"Couldn't get an answer: {exc}", success=False)
+
+        return CommandResult(text=result.text.strip())

marketmyna/bot/commands/base.py

@@ -0,0 +1,35 @@
+"""Command protocol every bot command implements."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import List
+
+from ..models import CommandResult, IncomingMessage
+
+
+class Command(ABC):
+    name: str = ""
+    aliases: List[str] = []
+    # Shown by /help, the web console's reference and its "/" menu.
+    usage: str = ""  # "/quote SYMBOL [market]"
+    description: str = ""  # one line, what it does
+    group: str = "Other"  # heading in the reference (Research, Markets, ...)
+    example: str = ""  # a runnable example, "/quote RELIANCE india"
+    help_text: str = ""  # legacy one-liner; derived from usage + description when empty
+
+    def help_line(self) -> str:
+        if self.help_text:
+            return self.help_text
+        return f"{self.usage or '/' + self.name} - {self.description}".rstrip(" -")
+
+    def describe(self) -> dict:
+        return {"name": self.name, "aliases": list(self.aliases), "usage": self.usage or f"/{self.name}",
+                "description": self.description or self.help_line(), "group": self.group,
+                "example": self.example or self.usage or f"/{self.name}"}
+
+    @abstractmethod
+    def handle(self, message: IncomingMessage, args: str) -> CommandResult:
+        """`args` is the raw text after the command word, unparsed - each
+        command splits/validates it however it needs to."""
+        ...

marketmyna/bot/commands/batch.py

@@ -0,0 +1,53 @@
+"""/batch SYM1,SYM2,SYM3 [market] [mode] - runs the agent pipeline over
+several symbols sequentially (same no-concurrency approach as the
+runtime scheduler) and replies with one combined summary."""
+
+from __future__ import annotations
+
+from ...agent.dashboard import build_dashboard
+from ...agent.orchestrator import AgentOrchestrator
+from ..formatting import format_dashboard
+from ..models import CommandResult, IncomingMessage
+from .base import Command
+
+MAX_SYMBOLS = 10
+
+
+class BatchCommand(Command):
+    name = "batch"
+    aliases = ["b"]
+    usage = "/batch SYM1,SYM2 [market] [mode]"
+    description = "AI analysis of several stocks in one go (max 10)."
+    group = "AI analysis"
+    example = "/batch TCS,INFY india quick"
+    help_text = "/batch SYM1,SYM2,SYM3 [market] [mode] - run the agent pipeline over several symbols (max 10)"
+
+    def __init__(self, config):
+        self._config = config
+
+    def handle(self, message: IncomingMessage, args: str) -> CommandResult:
+        parts = args.split()
+        if not parts:
+            return CommandResult(text=f"Usage: {self.help_text}", success=False)
+
+        symbols = [s.strip() for s in parts[0].split(",") if s.strip()]
+        if not symbols:
+            return CommandResult(text=f"Usage: {self.help_text}", success=False)
+        if len(symbols) > MAX_SYMBOLS:
+            return CommandResult(text=f"Too many symbols (max {MAX_SYMBOLS}).", success=False)
+
+        market = parts[1] if len(parts) > 1 else "us"
+        mode = parts[2] if len(parts) > 2 else "standard"
+
+        orchestrator = AgentOrchestrator(config=self._config)
+        blocks = []
+        any_ok = False
+        for symbol in symbols:
+            try:
+                ctx = orchestrator.run(symbol, market, mode=mode)
+                blocks.append(format_dashboard(build_dashboard(ctx)))
+                any_ok = True
+            except Exception as exc:
+                blocks.append(f"{symbol}: failed ({exc})")
+
+        return CommandResult(text="\n\n".join(blocks), success=any_ok)

marketmyna/bot/commands/common.py

@@ -0,0 +1,84 @@
+"""Shared parsing and number formatting for the research / market / portfolio commands."""
+
+from __future__ import annotations
+
+import math
+from typing import Optional
+
+MARKETS = ("us", "india", "china_a", "hong_kong", "crypto", "global")
+MARKET_WORDS = {"in": "india", "nse": "india", "bse": "india", "usa": "us", "hk": "hong_kong", "cn": "china_a",
+                "china": "china_a"}
+
+
+def market_word(token: str) -> Optional[str]:
+    t = token.lower()
+    return t if t in MARKETS else MARKET_WORDS.get(t)
+
+
+def default_market(config) -> str:
+    """The Trade tab's market, as the trading commands use."""
+    try:
+        from ...trading.risk import load_settings
+
+        return load_settings(config).get("market") or "india"
+    except Exception:
+        return "india"
+
+
+def guess_market(symbol: str, config) -> str:
+    """No market given: look the symbol up in the listings, preferring the
+    user's default market; fall back to the default."""
+    first = default_market(config)
+    order = [first] + [m for m in ("india", "us") if m != first]
+    if symbol.endswith("-USD"):
+        return "crypto"
+    try:
+        from ...data.listings import get_store
+
+        found = get_store().lookup([(m, kind, symbol) for m in order for kind in ("stock", "etf")])
+    except Exception:
+        return first
+    for m in order:
+        if any((m, kind, symbol) in found for kind in ("stock", "etf")):
+            return m
+    return first
+
+
+def parse_symbol(args: str, config) -> tuple[Optional[str], str, list[str]]:
+    """"AAPL", "AAPL us", "us:AAPL", "RELIANCE india annual" ->
+    (symbol, market, remaining words). Symbol None when args are empty."""
+    parts = args.split()
+    if not parts:
+        return None, default_market(config), []
+    head, rest = parts[0], parts[1:]
+    market = None
+    if ":" in head:
+        m, _, sym = head.partition(":")
+        if market_word(m):
+            market, head = market_word(m), sym
+    if market is None and rest and market_word(rest[0]):
+        market, rest = market_word(rest[0]), rest[1:]
+    symbol = head.upper()
+    return symbol, market or guess_market(symbol, config), rest
+
+
+def num(v, digits: int = 2) -> str:
+    if v is None or (isinstance(v, float) and not math.isfinite(v)):
+        return "n/a"
+    return f"{v:,.{digits}f}"
+
+
+def pct(v, digits: int = 1, sign: bool = True) -> str:
+    if v is None or (isinstance(v, float) and not math.isfinite(v)):
+        return "n/a"
+    return f"{v:+.{digits}f}%" if sign else f"{v:.{digits}f}%"
+
+
+def big(v) -> str:
+    """4.87e12 -> 4.87T"""
+    if v is None:
+        return "n/a"
+    for unit, size in (("T", 1e12), ("B", 1e9), ("M", 1e6), ("K", 1e3)):
+        if abs(v) >= size:
+            return f"{v / size:,.2f}{unit}"
+    return f"{v:,.0f}"

marketmyna/bot/commands/help.py

@@ -0,0 +1,43 @@
+"""/help - lists every registered command.
+
+Needs a reference to the dispatcher's registry, which creates an
+ordering requirement rather than a real circular-construction problem:
+register every other command first, then construct and register
+HelpCommand(dispatcher) last - by then the dispatcher already holds
+every other command, and HelpCommand just reads from it at call time
+(not at construction time), so it also correctly lists itself.
+"""
+
+from __future__ import annotations
+
+from ..models import CommandResult, IncomingMessage
+from .base import Command
+
+
+class HelpCommand(Command):
+    name = "help"
+    aliases = ["h", "?"]
+    usage = "/help"
+    description = "List every command."
+    group = "System"
+    example = "/help"
+    help_text = "/help - list available commands"
+
+    def __init__(self, dispatcher):
+        self._dispatcher = dispatcher
+
+    def handle(self, message: IncomingMessage, args: str) -> CommandResult:
+        want = args.strip().lstrip("/").lower()
+        if want:
+            command = self._dispatcher.get_command(want)
+            if command is None:
+                return CommandResult(text=f"No command '{want}'. /help lists them.", success=False)
+            d = command.describe()
+            aliases = f"\nAlso: {', '.join('/' + a for a in d['aliases'])}" if d["aliases"] else ""
+            return CommandResult(text=f"{d['usage']}\n{d['description']}\nExample: {d['example']}{aliases}")
+        lines = []
+        for group, commands in self._dispatcher.groups().items():
+            lines.append(f"\n{group}" if lines else group)
+            lines += [f"  {c.usage or '/' + c.name} - {c.description or c.help_line()}" for c in commands]
+        lines.append("\n/help COMMAND for details and an example.")
+        return CommandResult(text="\n".join(lines))

marketmyna/bot/commands/markets.py

@@ -0,0 +1,153 @@
+"""Market-wide views from chat: the Markets page's pulse and sector
+rotation, the ready-made screens and the events calendar."""
+
+from __future__ import annotations
+
+from ...utils.deadline import call_with_deadline
+from ..models import CommandResult, IncomingMessage
+from .base import Command
+from .common import default_market, market_word, num, pct
+
+GROUP = "Markets"
+
+
+class _MarketCommand(Command):
+    group = GROUP
+
+    def __init__(self, config):
+        self._config = config
+
+    def _market(self, parts: list[str]) -> str:
+        return next((market_word(p) for p in parts if market_word(p)), None) or default_market(self._config)
+
+    def handle(self, message: IncomingMessage, args: str) -> CommandResult:
+        try:
+            return CommandResult(text=self.run(args.split()))
+        except (ValueError, TimeoutError) as exc:
+            return CommandResult(text=str(exc), success=False)
+
+    def run(self, parts: list[str]) -> str:
+        raise NotImplementedError
+
+
+class MarketCommand(_MarketCommand):
+    name = "market"
+    aliases = ["pulse", "m"]
+    usage = "/market [market]"
+    description = "Market pulse: index levels, breadth, top gainers and losers, sector moves today."
+    example = "/market india"
+
+    def run(self, parts):
+        from ...services.discovery import DISCOVERY_MARKETS, build
+
+        market = self._market(parts)
+        if market not in DISCOVERY_MARKETS:
+            raise ValueError(f"Market pulse covers: {', '.join(DISCOVERY_MARKETS)}")
+        d = build(market, 500)
+        lines = [f"Market pulse · {market} (largest {d['universe']})"]
+        for i in d.get("indices") or []:
+            lines.append(f"{i['name']} {num(i.get('price'))} ({pct(i.get('change_percent'), 2)})")
+        b = d.get("breadth") or {}
+        if b.get("total"):
+            lines.append(f"Breadth: {b['advancers']} up / {b['decliners']} down of {b['total']}")
+        for key, title in (("gainers", "Top gainers"), ("losers", "Top losers")):
+            rows = (d.get(key) or [])[:5]
+            if rows:
+                lines.append(f"{title}: " + ", ".join(f"{r['symbol']} {pct(r.get('change_percent'))}" for r in rows))
+        secs = d.get("sectors") or []
+        if secs:
+            lines.append("Sectors: " + ", ".join(f"{s['sector']} {pct(s.get('change_percent'), 2)}" for s in secs[:4])
+                         + " … " + ", ".join(f"{s['sector']} {pct(s.get('change_percent'), 2)}" for s in secs[-3:]))
+        return "\n".join(lines)
+
+
+class SectorsCommand(_MarketCommand):
+    name = "sectors"
+    aliases = ["rotation", "rrg"]
+    usage = "/sectors [market]"
+    description = "Sector rotation: which sectors are leading, weakening, lagging or improving vs the index."
+    example = "/sectors india"
+
+    def run(self, parts):
+        from ...services.rotation import ROTATION_MARKETS, build
+
+        market = self._market(parts)
+        if market not in ROTATION_MARKETS:
+            raise ValueError(f"Sector rotation covers: {', '.join(ROTATION_MARKETS)}")
+        d = call_with_deadline(build, 90, market)
+        lines = [f"Sector rotation vs {d['benchmark']['name']}, weekly to {d.get('as_of')}"]
+        for q, title in (("leading", "Leading"), ("improving", "Improving"), ("weakening", "Weakening"), ("lagging", "Lagging")):
+            rows = [s for s in d.get("sectors") or [] if s.get("quadrant") == q]
+            if rows:
+                lines.append(f"{title}: " + ", ".join(f"{s['sector']} ({pct(s.get('return_4w'))} 4w)" for s in rows))
+        lines.append("Cycle: improving → leading → weakening → lagging.")
+        return "\n".join(lines)
+
+
+class ScreenCommand(_MarketCommand):
+    name = "screen"
+    aliases = ["screens"]
+    usage = "/screen [KEY] [india|us]"
+    description = "List the ready-made fundamental screens, or run one over the largest stocks."
+    example = "/screen undervalued_large india"
+
+    def run(self, parts):
+        from ...services.screens import PRESETS, list_presets, run
+
+        keys = [p for p in parts if not market_word(p)]
+        if not keys:
+            lines = ["Screens (run one with /screen KEY [india|us]):"]
+            lines += [f"• {p['key']}: {p['title']} - {p['description']}" for p in list_presets()]
+            return "\n".join(lines)
+        key = keys[0].lower()
+        if key not in PRESETS:
+            match = [k for k in PRESETS if key in k]
+            if len(match) != 1:
+                raise ValueError(f"Unknown screen '{key}'. /screen lists them.")
+            key = match[0]
+        market = self._market(parts)
+        if market not in ("india", "us"):
+            raise ValueError("Screens cover the India and US markets.")
+        d = call_with_deadline(run, 90, key, market)
+        rows = d.get("results") or []
+        lines = [f"{d['title']} ({market}): {len(rows)} of {d.get('scanned')} stocks pass",
+                 "Rules: " + "; ".join(d.get("rules") or [])]
+        for r in rows[:15]:
+            lines.append(f"• {r['symbol']} {num(r.get('price'))} · P/E {num(r.get('pe'), 1)} · "
+                         f"ROE {pct(r.get('roe'), 1, False)}")
+        return "\n".join(lines)
+
+
+class CalendarCommand(_MarketCommand):
+    name = "calendar"
+    aliases = ["events", "cal"]
+    usage = "/calendar [DAYS]"
+    description = "Upcoming results and dividends for stocks you follow, plus central bank and economic events and market holidays."
+    example = "/calendar 14"
+
+    def run(self, parts):
+        from datetime import datetime
+        from zoneinfo import ZoneInfo
+
+        from ...services import econ_calendar, market_calendar
+        from ...services.calendar import collect, followed_symbols, load_settings
+
+        days = next((int(p) for p in parts if p.isdigit()), 14)
+        days = max(1, min(days, 120))
+        settings = load_settings(self._config)
+        tz = settings.get("timezone") or "Asia/Kolkata"
+        today = datetime.now(ZoneInfo(tz)).date()
+        events = collect(followed_symbols(self._config), today, days)
+        econ = econ_calendar.collect(today, days)["events"]
+        markets = [e for e in market_calendar.collect(today, days)["events"]
+                   if e["key"] in ("market_holiday", "short_day", "special_session")]
+        lines = [f"Next {days} days"]
+        for e in econ[:10]:
+            lines.append(f"• {e['date']} {econ_calendar.local_time(e, tz) or ''} {e['title']} ({e.get('region')})".replace("  ", " "))
+        for e in markets[:10]:
+            lines.append(f"• {e['date']} {e['title']}")
+        for e in events[:15]:
+            lines.append(f"• {e['date']} {e['symbol']} ({e['market']}): {e['label']}")
+        if len(lines) == 1:
+            lines.append("Nothing scheduled. Add stocks to a watchlist or portfolio to track their results.")
+        return "\n".join(lines)

marketmyna/bot/commands/portfolio.py

@@ -0,0 +1,145 @@
+"""Your own data from chat: portfolio value and holdings, the portfolio
+review (marketmyna/portfolio/review.py) and watchlists. In accounts mode the
+caller's tenant scope (web request or the linked Telegram chat) limits
+every query to that user's rows."""
+
+from __future__ import annotations
+
+from ..models import CommandResult, IncomingMessage
+from .base import Command
+from .common import big, num, pct
+
+GROUP = "Portfolio"
+
+
+def _manager(config):
+    from ...portfolio.manager import PortfolioManager
+
+    return PortfolioManager(config.data_dir, config=config)
+
+
+def _pick(manager, args: str) -> tuple[str | None, str]:
+    """Portfolio by (case-insensitive, prefix) name; the first one when no name is given."""
+    names = manager.get_all_portfolios()
+    if not names:
+        return None, "No portfolios yet. Create one on the Portfolio page."
+    want = args.strip().lower()
+    if not want:
+        return names[0], ""
+    match = next((n for n in names if n.lower() == want), None) or next((n for n in names if n.lower().startswith(want)), None)
+    if match is None:
+        return None, f"No portfolio '{args.strip()}'. You have: {', '.join(names)}"
+    return match, ""
+
+
+class PortfolioCommand(Command):
+    name = "portfolio"
+    aliases = ["pf", "holdings"]
+    usage = "/portfolio [NAME]"
+    description = "Portfolio value, profit / loss and every holding with its weight and return."
+    example = "/portfolio"
+    group = GROUP
+
+    def __init__(self, config):
+        self._config = config
+
+    def handle(self, message: IncomingMessage, args: str) -> CommandResult:
+        manager = _manager(self._config)
+        name, error = _pick(manager, args)
+        if not name:
+            return CommandResult(text=error, success=not args.strip())
+        s = manager.get_portfolio_summary(name)
+        cur = s.get("currency") or ""
+        holdings = sorted(s["holdings"].values(), key=lambda h: -(h.get("market_value") or 0))
+        total = s.get("total_market_value") or 0
+        lines = [f"{name} · {cur} {num(s.get('total_value'))} "
+                 f"(invested {num(s.get('total_cost_basis'))}, P/L {num(s.get('total_unrealized_gain'))} "
+                 f"{pct(s.get('total_unrealized_gain_percent'))})"]
+        if s.get("cash_balance"):
+            lines.append(f"Cash {num(s['cash_balance'])}")
+        if not holdings:
+            lines.append("No holdings yet.")
+        for h in holdings[:25]:
+            w = (h.get("market_value") or 0) / total * 100 if total else 0
+            lines.append(f"• {h['symbol']} ({h.get('market')}) {num(h.get('quantity'), 4).rstrip('0').rstrip('.')} × "
+                         f"{num(h.get('current_price'))} = {big(h.get('market_value'))} · {w:.1f}% · "
+                         f"{pct(h.get('unrealized_gain_percent'))}")
+        if len(holdings) > 25:
+            lines.append(f"… and {len(holdings) - 25} more")
+        others = [n for n in manager.get_all_portfolios() if n != name]
+        if others:
+            lines.append(f"Other portfolios: {', '.join(others)}")
+        return CommandResult(text="\n".join(lines))
+
+
+class ReviewCommand(Command):
+    name = "review"
+    aliases = ["checkup"]
+    usage = "/review [NAME]"
+    description = "Portfolio review: what could be changed, why it matters and how, checked against your limits."
+    example = "/review"
+    group = GROUP
+
+    def __init__(self, config):
+        self._config = config
+
+    def handle(self, message: IncomingMessage, args: str) -> CommandResult:
+        from ...portfolio.review import for_portfolio
+
+        manager = _manager(self._config)
+        name, error = _pick(manager, args)
+        if not name:
+            return CommandResult(text=error, success=not args.strip())
+        r = for_portfolio(manager, name, self._config)
+        if r.get("score") is None:
+            return CommandResult(text=f"{name}: {r.get('summary')}")
+        lines = [f"{name} review: {r['score']}/100 ({r['grade']}) · {r['summary']}"]
+        marks = {"high": "🔴", "medium": "🟠", "low": "⚪"}
+        for i, f in enumerate(r["findings"], 1):
+            lines.append(f"\n{marks[f['severity']]} {i}. {f['title']}" + (f" ({f['rule']})" if f.get("rule") else ""))
+            lines.append(f"   {f['fact']}")
+            lines.append(f"   Why: {f['why']}")
+            for lever in f["levers"]:
+                lines.append(f"   → {lever}")
+        if r.get("good"):
+            lines.append("\nWorking well:")
+            lines += [f"✓ {g}" for g in r["good"]]
+        return CommandResult(text="\n".join(lines))
+
+
+class WatchlistCommand(Command):
+    name = "watchlist"
+    aliases = ["wl", "watch"]
+    usage = "/watchlist [NAME]"
+    description = "Your watchlists, or one list's stocks with price and day change."
+    example = "/watchlist"
+    group = GROUP
+
+    def __init__(self, config):
+        self._config = config
+
+    def handle(self, message: IncomingMessage, args: str) -> CommandResult:
+        from ...data.listings import get_store
+        from ...storage import DatabaseManager, WatchlistRecord, get_db_url
+
+        with DatabaseManager.instance(get_db_url(config=self._config)).get_session() as session:
+            lists = session.query(WatchlistRecord).order_by(WatchlistRecord.id).all()
+            if not lists:
+                return CommandResult(text="No watchlists yet. Star a stock on Markets or Analyze to start one.")
+            want = args.strip().lower()
+            record = (next((w for w in lists if w.name.lower() == want), None)
+                      or next((w for w in lists if w.name.lower().startswith(want)), None)) if want else (
+                lists[0] if len(lists) == 1 else None)
+            if record is None:
+                if want:
+                    return CommandResult(text=f"No watchlist '{args.strip()}'.", success=False)
+                return CommandResult(text="Your watchlists:\n" + "\n".join(
+                    f"• {w.name} ({len(w.items)} stocks)" for w in lists) + "\nShow one with /watchlist NAME")
+            items = [(i.symbol, i.market, i.type) for i in record.items]
+            title = record.name
+        live = get_store().lookup([(m, t, s) for s, m, t in items]) if items else {}
+        lines = [f"{title} ({len(items)})"]
+        for s, m, t in items[:40]:
+            row = live.get((m, t, s)) or {}
+            lines.append(f"• {s} ({m}) {num(row.get('price'))} {pct(row.get('change_percent'))}" if row else f"• {s} ({m})")
+        return CommandResult(text="\n".join(lines))