@pjmendonca/devflow 1.9.0

package/tooling/scripts/lib/cost_config.py

@@ -0,0 +1,222 @@
+#!/usr/bin/env python3
+"""
+Cost Configuration - Settings for cost tracking system.
+
+Loads configuration from environment variables and config files.
+
+Usage:
+    from lib.cost_config import CostConfig, get_config
+
+    config = get_config()
+    print(config.budget_limit)
+    print(config.currency_rates)
+"""
+
+import json
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+# Default values
+DEFAULT_BUDGET_LIMIT = 15.00
+DEFAULT_WARNING_PERCENT = 75
+DEFAULT_CRITICAL_PERCENT = 90
+DEFAULT_AUTO_STOP = True
+
+DEFAULT_CURRENCY_RATES = {
+    "USD": 1.0,
+    "EUR": 0.92,
+    "GBP": 0.79,
+    "BRL": 6.10,
+    "CAD": 1.36,
+    "AUD": 1.53,
+    "JPY": 149.50,
+}
+
+DEFAULT_DISPLAY_CURRENCIES = ["USD", "EUR", "GBP", "BRL"]
+
+
+@dataclass
+class CostConfig:
+    """Cost tracking configuration."""
+
+    # Budget settings
+    budget_context: float = 3.00
+    budget_dev: float = 15.00
+    budget_review: float = 5.00
+
+    # Alert thresholds
+    warning_percent: int = DEFAULT_WARNING_PERCENT
+    critical_percent: int = DEFAULT_CRITICAL_PERCENT
+    auto_stop: bool = DEFAULT_AUTO_STOP
+
+    # Currency settings
+    display_currency: str = "USD"
+    currency_rates: dict[str, float] = field(default_factory=lambda: DEFAULT_CURRENCY_RATES.copy())
+    display_currencies: list[str] = field(default_factory=lambda: DEFAULT_DISPLAY_CURRENCIES.copy())
+
+    @classmethod
+    def from_env(cls) -> "CostConfig":
+        """Load configuration from environment variables."""
+        config = cls()
+
+        # Budget limits
+        if os.getenv("MAX_BUDGET_CONTEXT"):
+            config.budget_context = float(os.getenv("MAX_BUDGET_CONTEXT"))
+        if os.getenv("MAX_BUDGET_DEV"):
+            config.budget_dev = float(os.getenv("MAX_BUDGET_DEV"))
+        if os.getenv("MAX_BUDGET_REVIEW"):
+            config.budget_review = float(os.getenv("MAX_BUDGET_REVIEW"))
+
+        # Alert thresholds
+        if os.getenv("COST_WARNING_PERCENT"):
+            config.warning_percent = int(os.getenv("COST_WARNING_PERCENT"))
+        if os.getenv("COST_CRITICAL_PERCENT"):
+            config.critical_percent = int(os.getenv("COST_CRITICAL_PERCENT"))
+        if os.getenv("COST_AUTO_STOP"):
+            config.auto_stop = os.getenv("COST_AUTO_STOP").lower() in ("true", "1", "yes")
+
+        # Currency settings
+        if os.getenv("COST_DISPLAY_CURRENCY"):
+            config.display_currency = os.getenv("COST_DISPLAY_CURRENCY")
+
+        # Currency rates from environment
+        if os.getenv("CURRENCY_RATE_EUR"):
+            config.currency_rates["EUR"] = float(os.getenv("CURRENCY_RATE_EUR"))
+        if os.getenv("CURRENCY_RATE_GBP"):
+            config.currency_rates["GBP"] = float(os.getenv("CURRENCY_RATE_GBP"))
+        if os.getenv("CURRENCY_RATE_BRL"):
+            config.currency_rates["BRL"] = float(os.getenv("CURRENCY_RATE_BRL"))
+
+        return config
+
+    @classmethod
+    def from_file(cls, config_path: Path) -> "CostConfig":
+        """Load configuration from JSON file."""
+        config = cls()
+
+        if not config_path.exists():
+            return config
+
+        try:
+            with open(config_path) as f:
+                data = json.load(f)
+
+            # Budget limits
+            if "budget_context" in data:
+                config.budget_context = float(data["budget_context"])
+            if "budget_dev" in data:
+                config.budget_dev = float(data["budget_dev"])
+            if "budget_review" in data:
+                config.budget_review = float(data["budget_review"])
+
+            # Alert thresholds
+            if "warning_percent" in data:
+                config.warning_percent = int(data["warning_percent"])
+            if "critical_percent" in data:
+                config.critical_percent = int(data["critical_percent"])
+            if "auto_stop" in data:
+                config.auto_stop = bool(data["auto_stop"])
+
+            # Currency settings
+            if "display_currency" in data:
+                config.display_currency = data["display_currency"]
+            if "currency_rates" in data:
+                config.currency_rates.update(data["currency_rates"])
+            if "display_currencies" in data:
+                config.display_currencies = data["display_currencies"]
+
+        except Exception as e:
+            print(f"Warning: Could not load config file: {e}")
+
+        return config
+
+    def save(self, config_path: Path):
+        """Save configuration to JSON file."""
+        data = {
+            "budget_context": self.budget_context,
+            "budget_dev": self.budget_dev,
+            "budget_review": self.budget_review,
+            "warning_percent": self.warning_percent,
+            "critical_percent": self.critical_percent,
+            "auto_stop": self.auto_stop,
+            "display_currency": self.display_currency,
+            "currency_rates": self.currency_rates,
+            "display_currencies": self.display_currencies,
+        }
+
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+
+        with open(config_path, "w") as f:
+            json.dump(data, f, indent=2)
+
+    def get_budget_for_phase(self, phase: str) -> float:
+        """Get budget limit for a specific phase."""
+        phase = phase.lower()
+        if phase in ("context", "sm"):
+            return self.budget_context
+        elif phase in ("dev", "development", "implement"):
+            return self.budget_dev
+        elif phase in ("review", "qa"):
+            return self.budget_review
+        return self.budget_dev  # Default
+
+    def get_thresholds(self) -> dict[str, float]:
+        """Get budget thresholds as decimal values."""
+        return {
+            "warning": self.warning_percent / 100.0,
+            "critical": self.critical_percent / 100.0,
+            "stop": 1.0,
+        }
+
+
+# Global configuration instance
+_config: Optional[CostConfig] = None
+
+
+def get_config() -> CostConfig:
+    """Get or create the global configuration instance."""
+    global _config
+    if _config is None:
+        # Try to load from file first, then overlay with env vars
+        config_file = Path(__file__).parent.parent.parent / ".automation" / "costs" / "config.json"
+        if config_file.exists():
+            _config = CostConfig.from_file(config_file)
+        else:
+            _config = CostConfig.from_env()
+    return _config
+
+
+def set_config(config: CostConfig):
+    """Set the global configuration instance."""
+    global _config
+    _config = config
+
+
+def reset_config():
+    """Reset the global configuration instance."""
+    global _config
+    _config = None
+
+
+if __name__ == "__main__":
+    # Demo/test
+    config = get_config()
+
+    print("Cost Configuration")
+    print("=" * 40)
+    print(f"Budget - Context: ${config.budget_context:.2f}")
+    print(f"Budget - Dev:     ${config.budget_dev:.2f}")
+    print(f"Budget - Review:  ${config.budget_review:.2f}")
+    print()
+    print(f"Warning at:  {config.warning_percent}%")
+    print(f"Critical at: {config.critical_percent}%")
+    print(f"Auto-stop:   {config.auto_stop}")
+    print()
+    print(f"Display Currency: {config.display_currency}")
+    print(f"Display Currencies: {config.display_currencies}")
+    print()
+    print("Currency Rates:")
+    for code, rate in config.currency_rates.items():
+        print(f"  {code}: {rate}")

package/tooling/scripts/lib/cost_display.py

@@ -0,0 +1,443 @@
+#!/usr/bin/env python3
+"""
+Cost Display - Real-time terminal display for cost monitoring.
+
+Provides a rich, updating display of cost information during agent runs.
+
+Usage:
+    from lib.cost_display import CostDisplay
+    from lib.cost_tracker import CostTracker
+
+    tracker = CostTracker(story_key="3-5", budget_limit_usd=15.00)
+    display = CostDisplay(tracker)
+    display.refresh()  # Update display
+"""
+
+import os
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+# Add parent for imports
+sys.path.insert(0, str(Path(__file__).parent))
+
+from cost_tracker import PRICING, CostTracker
+from currency_converter import CurrencyConverter, get_converter
+
+
+class Colors:
+    """ANSI color codes for terminal output."""
+
+    # Reset
+    RESET = "\033[0m"
+
+    # Regular colors
+    BLACK = "\033[30m"
+    RED = "\033[31m"
+    GREEN = "\033[32m"
+    YELLOW = "\033[33m"
+    BLUE = "\033[34m"
+    MAGENTA = "\033[35m"
+    CYAN = "\033[36m"
+    WHITE = "\033[37m"
+
+    # Bold colors
+    BOLD = "\033[1m"
+    BOLD_RED = "\033[1;31m"
+    BOLD_GREEN = "\033[1;32m"
+    BOLD_YELLOW = "\033[1;33m"
+    BOLD_BLUE = "\033[1;34m"
+    BOLD_CYAN = "\033[1;36m"
+    BOLD_WHITE = "\033[1;37m"
+
+    # Background
+    BG_RED = "\033[41m"
+    BG_GREEN = "\033[42m"
+    BG_YELLOW = "\033[43m"
+
+    # Dim
+    DIM = "\033[2m"
+
+    @staticmethod
+    def strip(text: str) -> str:
+        """Remove ANSI codes from text."""
+        import re
+
+        return re.sub(r"\033\[[0-9;]*m", "", text)
+
+
+class CostDisplay:
+    """
+    Real-time cost display for terminal.
+
+    Shows live updating cost information, token usage, and budget status.
+    """
+
+    # Box drawing characters
+    BOX_TOP_LEFT = "╔"
+    BOX_TOP_RIGHT = "╗"
+    BOX_BOTTOM_LEFT = "╚"
+    BOX_BOTTOM_RIGHT = "╝"
+    BOX_HORIZONTAL = "═"
+    BOX_VERTICAL = "║"
+    BOX_T_LEFT = "╠"
+    BOX_T_RIGHT = "╣"
+    BOX_LINE = "─"
+
+    def __init__(
+        self,
+        tracker: CostTracker,
+        converter: Optional[CurrencyConverter] = None,
+        width: int = 70,
+        compact: bool = False,
+        display_currency: Optional[str] = None,
+    ):
+        """
+        Initialize display.
+
+        Args:
+            tracker: CostTracker instance to display
+            converter: CurrencyConverter for multi-currency display
+            width: Display width in characters
+            compact: Use compact display mode
+            display_currency: Single currency to display (e.g., "USD", "EUR")
+                            If None, shows all currencies
+        """
+        self.tracker = tracker
+        self.converter = converter or get_converter()
+        self.width = width
+        self.compact = compact
+        self.start_time = datetime.now()
+        self.last_refresh = None
+
+        # Get display currency from environment or parameter
+        self.display_currency = display_currency or os.environ.get("COST_DISPLAY_CURRENCY")
+
+    def _box_line(self, left: str, right: str, fill: str = BOX_HORIZONTAL) -> str:
+        """Create a box line."""
+        return f"{left}{fill * (self.width - 2)}{right}"
+
+    def _content_line(self, content: str, align: str = "left") -> str:
+        """Create a content line within the box."""
+        # Remove color codes for length calculation
+        clean_content = Colors.strip(content)
+        padding = self.width - 4 - len(clean_content)
+
+        if align == "center":
+            left_pad = padding // 2
+            right_pad = padding - left_pad
+            return f"{self.BOX_VERTICAL} {' ' * left_pad}{content}{' ' * right_pad} {self.BOX_VERTICAL}"
+        elif align == "right":
+            return f"{self.BOX_VERTICAL} {' ' * padding}{content} {self.BOX_VERTICAL}"
+        else:  # left
+            return f"{self.BOX_VERTICAL} {content}{' ' * padding} {self.BOX_VERTICAL}"
+
+    def _empty_line(self) -> str:
+        """Create an empty content line."""
+        return self._content_line("")
+
+    def _section_header(self, title: str) -> str:
+        """Create a section header."""
+        line = f"{self.BOX_LINE * 3} {title} "
+        remaining = self.width - 6 - len(title)
+        return self._content_line(f"{Colors.BOLD}{line}{self.BOX_LINE * remaining}{Colors.RESET}")
+
+    def _progress_bar(self, percent: float, width: int = 40) -> str:
+        """Create a progress bar."""
+        filled = int((percent / 100) * width)
+        empty = width - filled
+
+        # Color based on percentage
+        if percent >= 90:
+            color = Colors.RED
+        elif percent >= 75:
+            color = Colors.YELLOW
+        else:
+            color = Colors.GREEN
+
+        bar = f"{color}{'█' * filled}{'░' * empty}{Colors.RESET}"
+        return f"[{bar}] {percent:.0f}%"
+
+    def _format_tokens(self, tokens: int) -> str:
+        """Format token count with K/M suffix."""
+        if tokens >= 1_000_000:
+            return f"{tokens / 1_000_000:.1f}M"
+        elif tokens >= 1_000:
+            return f"{tokens / 1_000:.1f}K"
+        return str(tokens)
+
+    def _format_elapsed(self) -> str:
+        """Format elapsed time."""
+        elapsed = datetime.now() - self.start_time
+        minutes = int(elapsed.total_seconds() // 60)
+        seconds = int(elapsed.total_seconds() % 60)
+        return f"{minutes:02d}:{seconds:02d}"
+
+    def _get_budget_color(self, percent: float) -> str:
+        """Get color based on budget usage."""
+        if percent >= 90:
+            return Colors.BOLD_RED
+        elif percent >= 75:
+            return Colors.BOLD_YELLOW
+        return Colors.BOLD_GREEN
+
+    def render(self) -> str:
+        """Render the full display as a string."""
+        session = self.tracker.session
+        lines = []
+
+        # Header
+        lines.append(
+            f"{Colors.CYAN}{self._box_line(self.BOX_TOP_LEFT, self.BOX_TOP_RIGHT)}{Colors.RESET}"
+        )
+        title = f"COST MONITOR - Story: {session.story_key}"
+        lines.append(
+            f"{Colors.CYAN}{self._content_line(Colors.BOLD + title + Colors.RESET, 'center')}{Colors.RESET}"
+        )
+        lines.append(
+            f"{Colors.CYAN}{self._box_line(self.BOX_T_LEFT, self.BOX_T_RIGHT)}{Colors.RESET}"
+        )
+
+        # Current Session Info
+        lines.append(self._empty_line())
+        lines.append(self._section_header("CURRENT SESSION"))
+
+        agent = self.tracker.current_agent or "N/A"
+        model = self.tracker.current_model or "N/A"
+        elapsed = self._format_elapsed()
+
+        lines.append(
+            self._content_line(
+                f"Agent: {Colors.BOLD_CYAN}{agent:20}{Colors.RESET} Model: {Colors.BOLD_BLUE}{model}{Colors.RESET}"
+            )
+        )
+        lines.append(
+            self._content_line(
+                f"Status: {Colors.BOLD_GREEN}Running{Colors.RESET}               Elapsed: {Colors.BOLD}{elapsed}{Colors.RESET}"
+            )
+        )
+
+        # Tokens
+        lines.append(self._empty_line())
+        lines.append(self._section_header("TOKENS"))
+
+        input_tokens = self._format_tokens(session.total_input_tokens)
+        output_tokens = self._format_tokens(session.total_output_tokens)
+        total_tokens = self._format_tokens(session.total_tokens)
+
+        lines.append(
+            self._content_line(
+                f"Input:  {Colors.BOLD}{input_tokens:>12} tokens{Colors.RESET}    "
+                f"Output: {Colors.BOLD}{output_tokens:>12} tokens{Colors.RESET}"
+            )
+        )
+        lines.append(
+            self._content_line(
+                f"Total:  {Colors.BOLD_WHITE}{total_tokens:>12} tokens{Colors.RESET}"
+            )
+        )
+
+        # Cost Breakdown by Agent
+        if not self.compact:
+            lines.append(self._empty_line())
+            lines.append(self._section_header("COST BREAKDOWN"))
+
+            # Table header
+            lines.append(
+                self._content_line(
+                    f"{Colors.DIM}{'Agent':<10} {'Model':<10} {'Input $':>10} {'Output $':>10} {'Total':>10}{Colors.RESET}"
+                )
+            )
+            lines.append(self._content_line(f"{Colors.DIM}{self.BOX_LINE * 54}{Colors.RESET}"))
+
+            # Aggregate by agent+model
+            breakdown = {}
+            for entry in session.entries:
+                key = (entry.agent, entry.model)
+                if key not in breakdown:
+                    breakdown[key] = {
+                        "input": 0,
+                        "output": 0,
+                        "cost": 0,
+                        "input_tokens": 0,
+                        "output_tokens": 0,
+                    }
+
+                breakdown[key]["input_tokens"] += entry.input_tokens
+                breakdown[key]["output_tokens"] += entry.output_tokens
+                breakdown[key]["cost"] += entry.cost_usd
+
+            # Calculate actual input/output costs based on model pricing
+            for (_agent, model), data in breakdown.items():
+                model_lower = model.lower()
+                pricing = PRICING.get(model_lower, PRICING.get("sonnet"))
+                if pricing:
+                    input_cost = (data["input_tokens"] / 1_000_000) * pricing["input"]
+                    output_cost = (data["output_tokens"] / 1_000_000) * pricing["output"]
+                else:
+                    # Fallback: estimate based on token ratio
+                    total_tokens = data["input_tokens"] + data["output_tokens"]
+                    if total_tokens > 0:
+                        input_ratio = data["input_tokens"] / total_tokens
+                        input_cost = data["cost"] * input_ratio
+                        output_cost = data["cost"] * (1 - input_ratio)
+                    else:
+                        input_cost = output_cost = 0
+                data["input"] = input_cost
+                data["output"] = output_cost
+
+            for (agent, model), data in breakdown.items():
+                lines.append(
+                    self._content_line(
+                        f"{agent:<10} {model:<10} "
+                        f"${data['input']:>8.2f} ${data['output']:>8.2f} "
+                        f"{Colors.BOLD}${data['cost']:>8.2f}{Colors.RESET}"
+                    )
+                )
+
+            # Total row
+            total_cost = session.total_cost_usd
+            lines.append(self._content_line(f"{Colors.DIM}{self.BOX_LINE * 54}{Colors.RESET}"))
+            lines.append(
+                self._content_line(
+                    f"{Colors.BOLD}{'TOTAL':<10} {'':10} "
+                    f"{'':>10} {'':>10} ${total_cost:>8.2f}{Colors.RESET}"
+                )
+            )
+
+        # Budget
+        lines.append(self._empty_line())
+        lines.append(self._section_header("BUDGET"))
+
+        budget_pct = session.budget_used_percent
+        budget_color = self._get_budget_color(budget_pct)
+
+        lines.append(
+            self._content_line(
+                f"Limit: {Colors.BOLD}${session.budget_limit_usd:.2f}{Colors.RESET}    "
+                f"Used: {budget_color}${session.total_cost_usd:.2f}{Colors.RESET}    "
+                f"Remaining: {Colors.BOLD}${session.budget_remaining:.2f}{Colors.RESET}"
+            )
+        )
+        lines.append(self._content_line(self._progress_bar(budget_pct)))
+
+        # Budget status message
+        ok, level, msg = self.tracker.check_budget()
+        if level == "critical":
+            lines.append(self._content_line(f"{Colors.BG_RED}{Colors.WHITE} {msg} {Colors.RESET}"))
+        elif level == "warning":
+            lines.append(self._content_line(f"{Colors.YELLOW}{msg}{Colors.RESET}"))
+
+        # Currency display
+        lines.append(self._empty_line())
+        if self.display_currency:
+            # Show single selected currency
+            lines.append(self._section_header("COST"))
+            formatted = self.converter.format(session.total_cost_usd, self.display_currency)
+            lines.append(self._content_line(f"Total: {Colors.BOLD_GREEN}{formatted}{Colors.RESET}"))
+        else:
+            # Show all currencies
+            lines.append(self._section_header("MULTI-CURRENCY"))
+            lines.append(
+                self._content_line(self.converter.format_all(session.total_cost_usd, " │ "))
+            )
+
+        # Footer
+        lines.append(self._empty_line())
+        lines.append(
+            f"{Colors.CYAN}{self._box_line(self.BOX_BOTTOM_LEFT, self.BOX_BOTTOM_RIGHT)}{Colors.RESET}"
+        )
+        lines.append(f"{Colors.DIM}Press Ctrl+C to stop monitoring{Colors.RESET}")
+
+        return "\n".join(lines)
+
+    def refresh(self, clear: bool = True):
+        """Refresh the display."""
+        if clear:
+            self.clear_screen()
+
+        print(self.render())
+        self.last_refresh = datetime.now()
+
+    def clear_screen(self):
+        """Clear the terminal screen."""
+        if sys.platform == "win32":
+            os.system("cls")
+        else:
+            os.system("clear")
+            # Alternative: print ANSI escape
+            # print('\033[2J\033[H', end='')
+
+    def update_in_place(self):
+        """Update display in place without full clear."""
+        # Move cursor to top
+        lines = self.render().count("\n") + 1
+        print(f"\033[{lines}A", end="")
+        print(self.render())
+
+
+class CompactCostDisplay:
+    """Compact single-line cost display for inline monitoring."""
+
+    def __init__(
+        self,
+        tracker: CostTracker,
+        converter: Optional[CurrencyConverter] = None,
+        display_currency: Optional[str] = None,
+    ):
+        self.tracker = tracker
+        self.converter = converter or get_converter()
+        # Get display currency from environment or parameter
+        self.display_currency = display_currency or os.environ.get("COST_DISPLAY_CURRENCY", "USD")
+
+    def render(self) -> str:
+        """Render compact display."""
+        session = self.tracker.session
+        pct = session.budget_used_percent
+
+        # Color based on budget
+        if pct >= 90:
+            color = Colors.RED
+        elif pct >= 75:
+            color = Colors.YELLOW
+        else:
+            color = Colors.GREEN
+
+        tokens = f"{session.total_tokens:,}"
+        cost = self.converter.format(session.total_cost_usd, self.display_currency)
+        budget = f"{pct:.0f}%"
+
+        return (
+            f"{Colors.BOLD}Cost:{Colors.RESET} {color}{cost}{Colors.RESET} "
+            f"({budget}) │ "
+            f"{Colors.BOLD}Tokens:{Colors.RESET} {tokens}"
+        )
+
+    def print(self):
+        """Print compact display."""
+        print(f"\r{self.render()}", end="", flush=True)
+
+
+if __name__ == "__main__":
+    # Demo
+    from cost_tracker import CostTracker
+
+    tracker = CostTracker(story_key="demo-story", budget_limit_usd=15.00)
+
+    # Simulate usage
+    tracker.log_usage("SM", "sonnet", 15000, 3000)
+    tracker.set_current_agent("DEV", "opus")
+    tracker.log_usage("DEV", "opus", 50000, 15000)
+
+    # Full display
+    display = CostDisplay(tracker)
+    display.refresh()
+
+    print("\n" + "=" * 70 + "\n")
+
+    # Compact display
+    compact = CompactCostDisplay(tracker)
+    print("Compact: ", end="")
+    compact.print()
+    print()