@aliwey/bmo 2.0.0

package/core/budget_tracker.py

@@ -0,0 +1,62 @@
+"""
+Tracks API token usage and estimates session costs in USD.
+Provides automatic warnings when a specified dollar budget is reached.
+"""
+
+from typing import Dict
+
+# Approximate pricing per 1 million tokens (Input / Output USD)
+MODEL_PRICING = {
+    "qwen3.6-plus-free": {"input": 0.0, "output": 0.0},
+    "big-pickle": {"input": 0.0, "output": 0.0},
+    "claude-3-5-sonnet": {"input": 3.0, "output": 15.0},
+    "gpt-4o": {"input": 2.5, "output": 10.0},
+    "deepseek-chat": {"input": 0.14, "output": 0.28},
+}
+
+class BudgetTracker:
+    def __init__(self, default_limit: float = 5.00):
+        self.limits: Dict[str, float] = {}  # session_id -> budget limit in USD
+        self.usage: Dict[str, Dict[str, float]] = {}  # session_id -> {"cost": float, "tokens": int}
+        self.default_limit = default_limit
+
+    def set_limit(self, session_id: str, limit: float):
+        """Sets the budget limit for a specific session."""
+        self.limits[session_id] = limit
+
+    def get_limit(self, session_id: str) -> float:
+        """Gets the budget limit for a session, fallback to default."""
+        return self.limits.get(session_id, self.default_limit)
+
+    def record_usage(self, session_id: str, model_id: str, prompt_tokens: int, completion_tokens: int) -> float:
+        """Calculates and stores cost for the current turn."""
+        model_key = model_id.lower()
+        pricing = {"input": 0.0, "output": 0.0}
+        
+        # Match substring for flexibility (e.g. claude-3-5-sonnet-latest -> claude-3-5-sonnet)
+        for key, price in MODEL_PRICING.items():
+            if key in model_key:
+                pricing = price
+                break
+                
+        cost = ((prompt_tokens / 1_000_000.0) * pricing["input"]) + \
+               ((completion_tokens / 1_000_000.0) * pricing["output"])
+               
+        if session_id not in self.usage:
+            self.usage[session_id] = {"cost": 0.0, "tokens": 0}
+            
+        self.usage[session_id]["cost"] += cost
+        self.usage[session_id]["tokens"] += (prompt_tokens + completion_tokens)
+        return cost
+
+    def get_session_cost(self, session_id: str) -> float:
+        """Gets total estimated cost for a session."""
+        if session_id in self.usage:
+            return self.usage[session_id]["cost"]
+        return 0.0
+
+    def is_exceeded(self, session_id: str) -> bool:
+        """Checks if current session cost exceeds the set limit."""
+        current_cost = self.get_session_cost(session_id)
+        limit = self.get_limit(session_id)
+        return current_cost >= limit

package/core/cli_renderer.py

@@ -0,0 +1,177 @@
+"""
+Formatting and rendering utilities for the BMO CLI using the rich library.
+Provides colored text, panels, status tables, and markdown rendering.
+"""
+
+from typing import List, Dict, Optional
+from datetime import datetime
+from contextlib import asynccontextmanager
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+from rich.table import Table
+from rich.markdown import Markdown
+from rich.box import ROUNDED, DOUBLE_EDGE
+from rich.live import Live
+from rich.spinner import Spinner
+from rich.columns import Columns
+
+console = Console()
+
+@asynccontextmanager
+async def bmo_spinner(message: str = "BMO is thinking..."):
+    """Async context manager that shows a live animated spinner while awaiting something."""
+    import asyncio
+    spinner = Spinner("dots", text=f"[bold cyan] {message}[/bold cyan]", style="cyan")
+    done = asyncio.Event()
+
+    async def _animate():
+        with Live(spinner, console=console, refresh_per_second=12, transient=True):
+            await done.wait()
+
+    task = asyncio.ensure_future(_animate())
+    try:
+        yield
+    finally:
+        done.set()
+        try:
+            await asyncio.wait_for(task, timeout=0.5)
+        except Exception:
+            pass
+
+BANNER_TEXT = """\
+ ██████╗ ███╗   ███╗ ██████╗ 
+ ██╔══██╗████╗ ████║██╔═══██╗
+ ██████╔╝██╔████╔██║██║   ██║  [dim]v2.0[/dim]
+ ██╔══██╗██║╚██╔╝██║██║   ██║  [dim]CLI Client[/dim]
+ ██████╔╝██║ ╚═╝ ██║╚██████╔╝  [dim]OpenCode Integration[/dim]
+ ╚═════╝ ╚═╝     ╚═╝ ╚═════╝ \
+"""
+
+def print_banner(active_model: str, is_connected: bool):
+    """Renders the startup banner inside a neat rounded panel."""
+    status_indicator = "[bold green]● Connected[/bold green]" if is_connected else "[bold red]● Offline[/bold red]"
+
+    content = (
+        f"[bold cyan]{BANNER_TEXT}[/bold cyan]\n\n"
+        f"  [dim]Model:[/dim]  [bold white]{active_model}[/bold white]\n"
+        f"  [dim]Status:[/dim] {status_indicator}\n"
+    )
+
+    panel = Panel(
+        content,
+        box=ROUNDED,
+        title="[bold cyan]BMO Terminal User Interface[/bold cyan]",
+        border_style="cyan",
+        padding=(1, 4),
+        expand=False,
+    )
+    console.print()
+    console.print(panel)
+    console.print()
+
+def _html_to_md(text: str) -> str:
+    """Convert Telegram HTML tags to Markdown and strip remaining HTML."""
+    import re
+    # Code blocks before inline code (order matters)
+    text = re.sub(r'<pre><code[^>]*>(.*?)</code></pre>', r'```\n\1\n```', text, flags=re.DOTALL)
+    text = re.sub(r'<pre>(.*?)</pre>', r'```\n\1\n```', text, flags=re.DOTALL)
+    text = re.sub(r'<code>(.*?)</code>', r'`\1`', text, flags=re.DOTALL)
+    # Inline formatting
+    text = re.sub(r'<b>(.*?)</b>', r'**\1**', text, flags=re.DOTALL)
+    text = re.sub(r'<strong>(.*?)</strong>', r'**\1**', text, flags=re.DOTALL)
+    text = re.sub(r'<i>(.*?)</i>', r'*\1*', text, flags=re.DOTALL)
+    text = re.sub(r'<em>(.*?)</em>', r'*\1*', text, flags=re.DOTALL)
+    text = re.sub(r'<u>(.*?)</u>', r'__\1__', text, flags=re.DOTALL)
+    text = re.sub(r'<s>(.*?)</s>', r'~~\1~~', text, flags=re.DOTALL)
+    # Links
+    text = re.sub(r'<a href="(.*?)">(.*?)</a>', r'[\2](\1)', text, flags=re.DOTALL)
+    # Line breaks
+    text = text.replace('<br>', '\n').replace('<br/>', '\n').replace('<br />', '\n')
+    # Strip remaining HTML tags
+    text = re.sub(r'<[^>]+>', '', text)
+    # Unescape HTML entities
+    text = text.replace('&amp;', '&').replace('&lt;', '<').replace('&gt;', '>').replace('&quot;', '"').replace('&#39;', "'")
+    return text
+
+
+def render_markdown(text: str):
+    """Renders markdown text inside the terminal."""
+    console.print(Markdown(_html_to_md(text), code_theme="monokai"))
+
+
+def print_assistant_message(content: str, elapsed_secs: float = None):
+    """Displays the assistant's message with full Markdown rendering — tables, code, headings, bold."""
+    cleaned = _html_to_md(content)
+    time_label = f"  [dim]⏱ {elapsed_secs:.1f}s[/dim]" if elapsed_secs is not None else ""
+    panel = Panel(
+        Markdown(cleaned, code_theme="monokai", justify="left"),
+        border_style="cyan",
+        title=f"[bold cyan]BMO[/bold cyan]{time_label}",
+        title_align="left",
+        padding=(1, 3),
+    )
+    console.print()
+    console.print(panel)
+    console.print()
+
+def print_system_status(status: dict, active_model: str):
+    """Prints the status of BMO and the OpenCode server in a table."""
+    table = Table(title="BMO System Status", box=ROUNDED, show_header=True, header_style="bold cyan", padding=(0, 2))
+    table.add_column("Property", style="bold cyan")
+    table.add_column("Value")
+
+    conn_status = "[bold green]● Connected[/bold green]" if status.get("connected") else "[bold red]● Disconnected[/bold red]"
+    table.add_row("OpenCode Connection", conn_status)
+    table.add_row("OpenCode Endpoint", status.get("base_url", "Unknown"))
+    table.add_row("Active Model", f"[bold white]{active_model}[/bold white]")
+    
+    db_stats = status.get("stats", {})
+    table.add_row("Total Conversations", str(db_stats.get("sessions", 0)))
+    table.add_row("Total Messages", str(db_stats.get("messages", 0)))
+    
+    console.print()
+    console.print(table)
+    console.print()
+
+def print_sessions_list(sessions: List[dict]):
+    """Renders the list of available sessions in a table."""
+    table = Table(title="Conversation Sessions History", box=ROUNDED, show_header=True, header_style="bold cyan", padding=(0, 2))
+    table.add_column("#", justify="right", style="cyan")
+    table.add_column("Status", justify="center")
+    table.add_column("Session Title", style="bold")
+    table.add_column("Messages", justify="right")
+    table.add_column("Last Updated", style="dim")
+
+    for idx, s in enumerate(sessions):
+        active_marker = "[bold green]★ Active[/bold green]" if s.get("is_active") else "[dim]○[/dim]"
+        title = s.get("title") or s.get("session_id")[:8]
+        msg_count = str(s.get("msg_count", 0))
+        
+        updated_time = "Unknown"
+        if s.get("updated_at"):
+            updated_time = datetime.fromtimestamp(s["updated_at"]).strftime("%Y-%m-%d %H:%M")
+
+        table.add_row(
+            str(idx + 1),
+            active_marker,
+            title,
+            msg_count,
+            updated_time
+        )
+
+    console.print()
+    console.print(table)
+    console.print()
+
+def print_error(message: str):
+    """Prints an error message in red."""
+    console.print(f"\n  [bold red]❌  {message}[/bold red]\n")
+
+def print_success(message: str):
+    """Prints a success message in green."""
+    console.print(f"\n  [bold green]✅  {message}[/bold green]\n")
+
+def print_info(message: str):
+    """Prints an informational message in yellow/dim."""
+    console.print(f"[yellow]ℹ️ {message}[/yellow]")

package/core/goal_runner.py

@@ -0,0 +1,129 @@
+"""
+Autonomous task runner for BMO.
+Decomposes a user objective into subtasks and executes them iteratively.
+Bridges status and blocker notifications to Telegram.
+"""
+
+import asyncio
+import os
+import time
+import logging
+from typing import Optional, List
+
+from core.bmo_engine import BMOEngine
+from core.cli_renderer import print_info, print_success, print_error, console, bmo_spinner
+from rich.rule import Rule
+from rich.text import Text
+
+logger = logging.getLogger(__name__)
+
+class GoalRunner:
+    def __init__(self, engine: BMOEngine):
+        self.engine = engine
+        self.is_running = False
+
+    async def run_goal(self, chat_id: int, user_id: int, objective: str, max_steps: int = 10):
+        """Runs the autonomous goal execution loop."""
+        self.is_running = True
+
+        console.print()
+        console.print(Rule(f"[bold cyan]🎯 BMO AUTONOMOUS GOAL[/bold cyan]", style="cyan"))
+        console.print(f"  [bold white]{objective}[/bold white]")
+        console.print(Rule(style="dim"))
+        console.print()
+
+        # 1. Ask BMO to create a step-by-step checklist
+        planning_prompt = (
+            f"Objective: {objective}\n\n"
+            "Create a numbered list of subtasks needed to accomplish this objective. "
+            "Respond ONLY with the list of subtasks."
+        )
+
+        async with bmo_spinner("Decomposing objective into subtasks..."):
+            plan_response = await self.engine.send_message(chat_id, user_id, planning_prompt, interface="cli")
+
+        console.print(f"  [bold cyan]📋 Plan:[/bold cyan]")
+        for line in plan_response.strip().split("\n"):
+            if line.strip():
+                console.print(f"    [dim]{line.strip()}[/dim]")
+        console.print()
+
+        # Parse subtasks (basic newline parsing)
+        subtasks = [
+            line.strip()
+            for line in plan_response.split("\n")
+            if line.strip() and (line.strip()[0].isdigit() or line.strip().startswith("-"))
+        ]
+
+        if not subtasks:
+            subtasks = [objective]  # Fallback to single objective
+
+        total = len(subtasks)
+
+        # 2. Iterate through subtasks
+        for idx, task in enumerate(subtasks):
+            if not self.is_running:
+                break
+
+            step_num = idx + 1
+            console.print(Rule(
+                f"[bold cyan]Step {step_num}/{total}[/bold cyan]  [white]{task}[/white]",
+                style="dim cyan"
+            ))
+
+            step_prompt = (
+                f"Currently working on step {step_num} of {total}: {task}\n"
+                f"Objective context: {objective}\n\n"
+                "Please execute this step now. If you need any tool execution, run it. "
+                "Report back when complete."
+            )
+
+            # Send notification to Telegram (Bridge status)
+            await self._notify_telegram(chat_id, f"🚀 Working on step {step_num}/{total}: {task}")
+
+            t0 = time.time()
+            async with bmo_spinner(f"Executing step {step_num}/{total}..."):
+                response = await self.engine.send_message(chat_id, user_id, step_prompt, interface="cli")
+            elapsed = time.time() - t0
+
+            console.print()
+            console.print(response)
+            console.print(f"\n  [dim]⏱ Step completed in {elapsed:.1f}s[/dim]")
+            console.print()
+
+            # Simple heuristic checking for failure
+            lower_resp = response.lower()
+            if "error" in lower_resp or "fail" in lower_resp or "blocked" in lower_resp:
+                print_error(f"Goal blocked at step {step_num}!")
+                await self._notify_telegram(chat_id, f"⚠️ Goal Blocked: {task}\nError: {response[:150]}...")
+                print_info("Waiting for user intervention...")
+                self.is_running = False
+                break
+            else:
+                print_success(f"Step {step_num} complete.")
+
+        console.print()
+        console.print(Rule("[bold green]🏁 Goal Execution Complete![/bold green]", style="green"))
+        console.print()
+        await self._notify_telegram(chat_id, f"🏁 Goal completed successfully: {objective[:100]}")
+        self.is_running = False
+
+    async def _notify_telegram(self, chat_id: int, message: str):
+        """Uses python-telegram-bot wrapper to send progress messages to the Telegram chat."""
+        token = os.getenv("TELEGRAM_BOT_TOKEN") or os.getenv("TELEGRAM_TOKEN")
+        if not token:
+            logger.info("[Telegram Bridge Notification] %s", message)
+            return
+
+        import httpx
+        url = f"https://api.telegram.org/bot{token}/sendMessage"
+        payload = {
+            "chat_id": chat_id,
+            "text": f"🤖 <b>BMO Goal Bridge:</b>\n{message}",
+            "parse_mode": "HTML"
+        }
+        try:
+            async with httpx.AsyncClient() as client:
+                await client.post(url, json=payload, timeout=5)
+        except Exception as e:
+            logger.error("Failed to send Telegram Bridge notification: %s", e)

package/core/request_worker.py

@@ -0,0 +1,242 @@
+import asyncio
+import json
+import logging
+import multiprocessing
+import os
+import sys
+from typing import Optional
+
+import httpx
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from core.worker_protocol import (
+    encode_msg, decode_msg, MSG_QUERY, MSG_RESULT, MSG_UPDATE,
+    MSG_ERROR, MSG_CANCELLED, MSG_CONNECT, MSG_SHUTDOWN,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class RequestWorker:
+    """Runs in a child process. Handles all OpenCode API HTTP calls.
+    Supports both multiprocessing.Queue transport and stdin/stdout JSON-RPC.
+    """
+
+    def __init__(self, task_queue: Optional[multiprocessing.Queue] = None,
+                 result_queue: Optional[multiprocessing.Queue] = None):
+        self.task_queue = task_queue
+        self.result_queue = result_queue
+        self._send_fn = None
+        self.http_client: Optional[httpx.AsyncClient] = None
+        self._running = False
+        self._msg_id_counter = 0
+
+    def _set_stdio_transport(self, writer):
+        self._send_fn = writer
+
+    async def _send_result(self, data: dict):
+        if self._send_fn:
+            await self._send_fn(data)
+        elif self.result_queue:
+            loop = asyncio.get_event_loop()
+            await loop.run_in_executor(None, self.result_queue.put, data)
+
+    async def _init_client(self):
+        self.http_client = httpx.AsyncClient(
+            timeout=httpx.Timeout(600.0, connect=30.0),
+            follow_redirects=True
+        )
+
+    async def _handle_query(self, task: dict):
+        session_id = task["session_id"]
+        payload = task["payload"]
+        base_url = task["base_url"]
+        poll_interval = task.get("poll_interval", 2.0)
+        poll_timeout = task.get("poll_timeout", 600.0)
+
+        try:
+            post_url = f"{base_url}/session/{session_id}/message"
+            resp = await self.http_client.post(post_url, json=payload)
+            if resp.status_code != 200:
+                await self._send_result({
+                    "type": "error",
+                    "message": f"POST failed: {resp.status_code} {resp.text[:200]}"
+                })
+                return
+
+            get_url = f"{base_url}/session/{session_id}/message?limit=20"
+            start = asyncio.get_event_loop().time()
+            last_text = ""
+
+            while True:
+                elapsed = asyncio.get_event_loop().time() - start
+                if elapsed > poll_timeout:
+                    await self._send_result({
+                        "type": "error",
+                        "message": f"Poll timeout after {poll_timeout}s"
+                    })
+                    return
+
+                resp = await self.http_client.get(get_url)
+                if resp.status_code != 200:
+                    await asyncio.sleep(poll_interval)
+                    continue
+
+                data = resp.json()
+                messages = data if isinstance(data, list) else data.get("messages", [])
+                if not messages:
+                    await asyncio.sleep(poll_interval)
+                    continue
+
+                latest = messages[-1]
+                role = latest.get("role", "")
+                content = latest.get("content", "") or ""
+                parts = latest.get("parts", [])
+                text_parts = [p.get("text", "") for p in parts if p.get("type") == "text"]
+                full_text = content or "".join(text_parts)
+
+                status = latest.get("status", "")
+                if status == "completed" or latest.get("completed", False):
+                    await self._send_result({
+                        "type": "result",
+                        "content": full_text,
+                        "message_id": latest.get("id", ""),
+                        "done": True
+                    })
+                    return
+
+                if full_text != last_text:
+                    diff = full_text[len(last_text):] if len(full_text) > len(last_text) else full_text
+                    await self._send_result({
+                        "type": "update",
+                        "content": diff,
+                        "full_text": full_text,
+                        "done": False
+                    })
+                    last_text = full_text
+
+                await asyncio.sleep(poll_interval)
+
+        except asyncio.CancelledError:
+            await self._send_result({"type": "cancelled"})
+        except Exception as e:
+            await self._send_result({
+                "type": "error",
+                "message": f"{type(e).__name__}: {str(e)}"
+            })
+
+    async def _handle_connect(self, base_url: str):
+        try:
+            resp = await self.http_client.get(f"{base_url}/session", timeout=10.0)
+            ok = resp.status_code < 500
+            await self._send_result({"type": "connect_result", "ok": ok})
+        except Exception as e:
+            await self._send_result({"type": "connect_result", "ok": False, "error": str(e)})
+
+    async def run(self):
+        self._running = True
+        await self._init_client()
+
+        while self._running:
+            try:
+                task = None
+                if self.task_queue is not None:
+                    try:
+                        task = self.task_queue.get_nowait()
+                    except Exception:
+                        await asyncio.sleep(0.1)
+                        continue
+                else:
+                    await asyncio.sleep(0.1)
+                    continue
+
+                task_type = task.get("type", "")
+                if task_type == "query":
+                    await self._handle_query(task)
+                elif task_type == "connect":
+                    await self._handle_connect(task["base_url"])
+                elif task_type == "shutdown":
+                    self._running = False
+                    break
+
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                logger.error(f"Worker error: {e}")
+                await asyncio.sleep(1)
+
+        if self.http_client:
+            await self.http_client.aclose()
+
+    async def run_stdio(self):
+        """Run worker reading JSON-RPC from stdin, writing to stdout.
+        Uses run_in_executor for stdin reads (Windows proactor compatible).
+        """
+        self._running = True
+        await self._init_client()
+
+        loop = asyncio.get_event_loop()
+
+        async def write_json(data):
+            line = json.dumps(data, default=str) + "\n"
+            sys.stdout.write(line)
+            sys.stdout.flush()
+
+        self._send_fn = write_json
+
+        while self._running:
+            try:
+                line = await asyncio.wait_for(
+                    loop.run_in_executor(None, sys.stdin.readline),
+                    timeout=0.5,
+                )
+            except asyncio.TimeoutError:
+                continue
+            except Exception:
+                break
+
+            if not line:
+                await asyncio.sleep(0.1)
+                continue
+
+            cmd = decode_msg(line)
+            if not cmd:
+                continue
+
+            task_type = cmd.get("type")
+            if task_type == MSG_QUERY:
+                await self._handle_query(cmd)
+            elif task_type == MSG_CONNECT:
+                await self._handle_connect(cmd["base_url"])
+            elif task_type == MSG_SHUTDOWN:
+                self._running = False
+                break
+
+        if self.http_client:
+            await self.http_client.aclose()
+
+
+def worker_main(task_queue, result_queue):
+    """Entry point for multiprocessing.Process worker."""
+    worker = RequestWorker(task_queue, result_queue)
+    asyncio.run(worker.run())
+
+
+def worker_main_stdio():
+    """Entry point for subprocess worker (stdin/stdout JSON-RPC)."""
+    worker = RequestWorker(task_queue=None, result_queue=None)
+    asyncio.run(worker.run_stdio())
+
+
+if __name__ == "__main__":
+    if "--mode" in sys.argv:
+        idx = sys.argv.index("--mode")
+        if idx + 1 < len(sys.argv) and sys.argv[idx + 1] == "stdio":
+            worker_main_stdio()
+        else:
+            print("Usage: request_worker.py --mode stdio")
+            sys.exit(1)
+    else:
+        print("Usage: request_worker.py --mode stdio")
+        sys.exit(1)

package/core/security.py

@@ -0,0 +1,42 @@
+import os
+import base64
+from cryptography.fernet import Fernet
+from config.settings import DATA_DIR
+
+KEY_FILE = DATA_DIR / ".master.key"
+
+def _get_or_create_master_key():
+    """Retrieves existing master key or creates a new one."""
+    if os.path.exists(KEY_FILE):
+        with open(KEY_FILE, "rb") as f:
+            return f.read()
+    else:
+        # Generate a new random key
+        key = Fernet.generate_key()
+        with open(KEY_FILE, "wb") as f:
+            f.write(key)
+        
+        # Try to make the file hidden on Windows
+        try:
+            import ctypes
+            ctypes.windll.kernel32.SetFileAttributesW(str(KEY_FILE), 0x02) # FILE_ATTRIBUTE_HIDDEN
+        except:
+            pass
+            
+        return key
+
+_MASTER_KEY = _get_or_create_master_key()
+_FERNET = Fernet(_MASTER_KEY)
+
+def encrypt_value(value: str) -> str:
+    """Encrypts a string value."""
+    if not value: return ""
+    return _FERNET.encrypt(value.encode()).decode()
+
+def decrypt_value(encrypted_value: str) -> str:
+    """Decrypts an encrypted string value."""
+    if not encrypted_value: return ""
+    try:
+        return _FERNET.decrypt(encrypted_value.encode()).decode()
+    except Exception:
+        return "" # Return empty if decryption fails (e.g. wrong key)

package/core/shared_state.py

@@ -0,0 +1,4 @@
+import asyncio
+
+# key: (chat_id, scope), value: {"event": asyncio.Event, "result": str}
+pending_permissions = {}