@pjmendonca/devflow 1.13.2 → 1.19.0

package/tooling/scripts/lib/cost_config.py

@@ -24,6 +24,36 @@ DEFAULT_WARNING_PERCENT = 75
 DEFAULT_CRITICAL_PERCENT = 90
 DEFAULT_AUTO_STOP = True
 
+# Subscription defaults (monthly token limits)
+# Set to 0 to disable subscription tracking
+DEFAULT_SUBSCRIPTION_TOKEN_LIMIT = 0  # No default limit - user must configure
+DEFAULT_SUBSCRIPTION_BILLING_PERIOD_DAYS = 30
+
+# Common subscription plan presets (tokens per month)
+# Based on typical Anthropic API plans as of December 2025
+SUBSCRIPTION_PLANS = {
+    "free": {
+        "token_limit": 100_000,  # 100K tokens/month
+        "description": "Free tier / Trial",
+    },
+    "developer": {
+        "token_limit": 1_000_000,  # 1M tokens/month
+        "description": "Developer plan",
+    },
+    "pro": {
+        "token_limit": 5_000_000,  # 5M tokens/month
+        "description": "Pro / Team plan",
+    },
+    "scale": {
+        "token_limit": 20_000_000,  # 20M tokens/month
+        "description": "Scale plan",
+    },
+    "enterprise": {
+        "token_limit": 100_000_000,  # 100M tokens/month
+        "description": "Enterprise plan",
+    },
+}
+
 DEFAULT_CURRENCY_RATES = {
     "USD": 1.0,
     "EUR": 0.92,
@@ -51,6 +81,13 @@ class CostConfig:
     critical_percent: int = DEFAULT_CRITICAL_PERCENT
     auto_stop: bool = DEFAULT_AUTO_STOP
 
+    # Subscription settings (for tracking usage against API plan limits)
+    subscription_token_limit: int = DEFAULT_SUBSCRIPTION_TOKEN_LIMIT
+    subscription_billing_period_days: int = DEFAULT_SUBSCRIPTION_BILLING_PERIOD_DAYS
+    subscription_plan: str = (
+        ""  # Plan name if using preset (free, developer, pro, scale, enterprise)
+    )
+
     # Currency settings
     display_currency: str = "USD"
     currency_rates: dict[str, float] = field(default_factory=lambda: DEFAULT_CURRENCY_RATES.copy())
@@ -61,33 +98,84 @@ class CostConfig:
         """Load configuration from environment variables."""
         config = cls()
 
+        def _safe_float(env_var: str, default: float) -> float:
+            """Safely convert env var to float, returning default on failure."""
+            value = os.getenv(env_var)
+            if not value:
+                return default
+            try:
+                return float(value)
+            except ValueError:
+                print(f"Warning: Invalid float value for {env_var}: '{value}', using default")
+                return default
+
+        def _safe_int(env_var: str, default: int) -> int:
+            """Safely convert env var to int, returning default on failure."""
+            value = os.getenv(env_var)
+            if not value:
+                return default
+            try:
+                return int(value)
+            except ValueError:
+                print(f"Warning: Invalid int value for {env_var}: '{value}', using default")
+                return default
+
         # Budget limits
         if os.getenv("MAX_BUDGET_CONTEXT"):
-            config.budget_context = float(os.getenv("MAX_BUDGET_CONTEXT"))
+            config.budget_context = _safe_float("MAX_BUDGET_CONTEXT", config.budget_context)
         if os.getenv("MAX_BUDGET_DEV"):
-            config.budget_dev = float(os.getenv("MAX_BUDGET_DEV"))
+            config.budget_dev = _safe_float("MAX_BUDGET_DEV", config.budget_dev)
         if os.getenv("MAX_BUDGET_REVIEW"):
-            config.budget_review = float(os.getenv("MAX_BUDGET_REVIEW"))
+            config.budget_review = _safe_float("MAX_BUDGET_REVIEW", config.budget_review)
 
         # Alert thresholds
         if os.getenv("COST_WARNING_PERCENT"):
-            config.warning_percent = int(os.getenv("COST_WARNING_PERCENT"))
+            config.warning_percent = _safe_int("COST_WARNING_PERCENT", config.warning_percent)
         if os.getenv("COST_CRITICAL_PERCENT"):
-            config.critical_percent = int(os.getenv("COST_CRITICAL_PERCENT"))
+            config.critical_percent = _safe_int("COST_CRITICAL_PERCENT", config.critical_percent)
         if os.getenv("COST_AUTO_STOP"):
             config.auto_stop = os.getenv("COST_AUTO_STOP").lower() in ("true", "1", "yes")
 
+        # Subscription settings
+        # Check for plan preset first (e.g., SUBSCRIPTION_PLAN=pro)
+        if os.getenv("SUBSCRIPTION_PLAN"):
+            plan_name = os.getenv("SUBSCRIPTION_PLAN").lower()
+            if plan_name in SUBSCRIPTION_PLANS:
+                config.subscription_plan = plan_name
+                config.subscription_token_limit = SUBSCRIPTION_PLANS[plan_name]["token_limit"]
+            else:
+                print(
+                    f"Warning: Unknown subscription plan '{plan_name}'. "
+                    f"Valid plans: {', '.join(SUBSCRIPTION_PLANS.keys())}"
+                )
+
+        # Direct token limit overrides plan preset
+        if os.getenv("SUBSCRIPTION_TOKEN_LIMIT"):
+            config.subscription_token_limit = _safe_int(
+                "SUBSCRIPTION_TOKEN_LIMIT", config.subscription_token_limit
+            )
+        if os.getenv("SUBSCRIPTION_BILLING_PERIOD_DAYS"):
+            config.subscription_billing_period_days = _safe_int(
+                "SUBSCRIPTION_BILLING_PERIOD_DAYS", config.subscription_billing_period_days
+            )
+
         # 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"))
+            config.currency_rates["EUR"] = _safe_float(
+                "CURRENCY_RATE_EUR", config.currency_rates["EUR"]
+            )
         if os.getenv("CURRENCY_RATE_GBP"):
-            config.currency_rates["GBP"] = float(os.getenv("CURRENCY_RATE_GBP"))
+            config.currency_rates["GBP"] = _safe_float(
+                "CURRENCY_RATE_GBP", config.currency_rates["GBP"]
+            )
         if os.getenv("CURRENCY_RATE_BRL"):
-            config.currency_rates["BRL"] = float(os.getenv("CURRENCY_RATE_BRL"))
+            config.currency_rates["BRL"] = _safe_float(
+                "CURRENCY_RATE_BRL", config.currency_rates["BRL"]
+            )
 
         return config
 
@@ -119,6 +207,21 @@ class CostConfig:
             if "auto_stop" in data:
                 config.auto_stop = bool(data["auto_stop"])
 
+            # Subscription settings
+            # Check for plan preset first
+            if "subscription_plan" in data:
+                plan_name = data["subscription_plan"].lower()
+                if plan_name in SUBSCRIPTION_PLANS:
+                    config.subscription_plan = plan_name
+                    config.subscription_token_limit = SUBSCRIPTION_PLANS[plan_name]["token_limit"]
+            # Direct token limit overrides plan preset
+            if "subscription_token_limit" in data:
+                config.subscription_token_limit = int(data["subscription_token_limit"])
+            if "subscription_billing_period_days" in data:
+                config.subscription_billing_period_days = int(
+                    data["subscription_billing_period_days"]
+                )
+
             # Currency settings
             if "display_currency" in data:
                 config.display_currency = data["display_currency"]
@@ -127,8 +230,10 @@ class CostConfig:
             if "display_currencies" in data:
                 config.display_currencies = data["display_currencies"]
 
-        except Exception as e:
-            print(f"Warning: Could not load config file: {e}")
+        except json.JSONDecodeError as e:
+            print(f"Warning: Invalid JSON in config file: {e}")
+        except OSError as e:
+            print(f"Warning: Could not read config file: {e}")
 
         return config
 
@@ -141,6 +246,9 @@ class CostConfig:
             "warning_percent": self.warning_percent,
             "critical_percent": self.critical_percent,
             "auto_stop": self.auto_stop,
+            "subscription_plan": self.subscription_plan,
+            "subscription_token_limit": self.subscription_token_limit,
+            "subscription_billing_period_days": self.subscription_billing_period_days,
             "display_currency": self.display_currency,
             "currency_rates": self.currency_rates,
             "display_currencies": self.display_currencies,
@@ -170,6 +278,110 @@ class CostConfig:
             "stop": 1.0,
         }
 
+    def set_subscription_plan(self, plan_name: str) -> bool:
+        """
+        Set subscription based on a plan preset.
+
+        Args:
+            plan_name: One of: free, developer, pro, scale, enterprise
+
+        Returns:
+            True if plan was set successfully, False otherwise.
+        """
+        plan_name = plan_name.lower()
+        if plan_name not in SUBSCRIPTION_PLANS:
+            return False
+
+        self.subscription_plan = plan_name
+        self.subscription_token_limit = SUBSCRIPTION_PLANS[plan_name]["token_limit"]
+        return True
+
+    def get_subscription_plan_info(self) -> dict:
+        """Get information about the current subscription plan."""
+        if self.subscription_plan and self.subscription_plan in SUBSCRIPTION_PLANS:
+            plan = SUBSCRIPTION_PLANS[self.subscription_plan]
+            return {
+                "plan": self.subscription_plan,
+                "description": plan["description"],
+                "token_limit": self.subscription_token_limit,
+                "billing_period_days": self.subscription_billing_period_days,
+            }
+        elif self.subscription_token_limit > 0:
+            return {
+                "plan": "custom",
+                "description": "Custom token limit",
+                "token_limit": self.subscription_token_limit,
+                "billing_period_days": self.subscription_billing_period_days,
+            }
+        return {
+            "plan": "none",
+            "description": "Not configured",
+            "token_limit": 0,
+            "billing_period_days": self.subscription_billing_period_days,
+        }
+
+    @staticmethod
+    def get_available_plans() -> dict:
+        """Get all available subscription plan presets."""
+        return SUBSCRIPTION_PLANS.copy()
+
+    def auto_detect_plan(self, model: str = "sonnet") -> str:
+        """
+        Auto-detect subscription plan based on model usage.
+
+        Args:
+            model: The model being used (opus, sonnet, haiku)
+
+        Returns:
+            Detected plan name (free, developer, pro, scale, enterprise)
+        """
+        model_lower = model.lower()
+
+        # If already configured, return existing plan
+        if self.subscription_plan:
+            return self.subscription_plan
+
+        # Infer plan from model
+        if "opus" in model_lower:
+            # Opus users are typically on pro or higher
+            detected = "pro"
+        elif "sonnet" in model_lower:
+            # Sonnet could be developer or higher
+            detected = "developer"
+        elif "haiku" in model_lower:
+            # Haiku might be free tier
+            detected = "free"
+        else:
+            detected = "developer"
+
+        # Set and return the detected plan
+        self.set_subscription_plan(detected)
+        return detected
+
+    def ensure_plan_configured(
+        self, model: str = "sonnet", config_path: Optional[Path] = None
+    ) -> str:
+        """
+        Ensure a subscription plan is configured, auto-detecting if needed.
+
+        Args:
+            model: The model being used for auto-detection
+            config_path: Optional path to save config
+
+        Returns:
+            The configured or detected plan name
+        """
+        if self.subscription_plan and self.subscription_token_limit > 0:
+            return self.subscription_plan
+
+        plan = self.auto_detect_plan(model)
+
+        # Save to config file if path provided
+        if config_path:
+            self.save(config_path)
+
+        return plan
+
 
 # Global configuration instance
 _config: Optional[CostConfig] = None
@@ -214,6 +426,13 @@ if __name__ == "__main__":
     print(f"Critical at: {config.critical_percent}%")
     print(f"Auto-stop:   {config.auto_stop}")
     print()
+    print("Subscription Settings:")
+    if config.subscription_token_limit > 0:
+        print(f"  Token Limit:    {config.subscription_token_limit:,} tokens")
+        print(f"  Billing Period: {config.subscription_billing_period_days} days")
+    else:
+        print("  Not configured (set SUBSCRIPTION_TOKEN_LIMIT to enable)")
+    print()
     print(f"Display Currency: {config.display_currency}")
     print(f"Display Currencies: {config.display_currencies}")
     print()

package/tooling/scripts/lib/cost_display.py

@@ -22,51 +22,13 @@ from typing import Optional
 # Add parent for imports
 sys.path.insert(0, str(Path(__file__).parent))
 
+from platform import IS_WINDOWS
+
+from colors import Colors
 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.
@@ -112,7 +74,7 @@ class CostDisplay:
         self.last_refresh = None
 
         # Get display currency from environment or parameter
-        self.display_currency = display_currency or os.environ.get("COST_DISPLAY_CURRENCY")
+        self.display_currency = display_currency or os.getenv("COST_DISPLAY_CURRENCY")
 
     def _box_line(self, left: str, right: str, fill: str = BOX_HORIZONTAL) -> str:
         """Create a box line."""
@@ -122,7 +84,20 @@ class CostDisplay:
         """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)
+        max_content_width = self.width - 4  # Account for box borders and spaces
+
+        # Truncate content if too long
+        if len(clean_content) > max_content_width:
+            # Find how much to truncate (accounting for "..." suffix)
+            truncate_at = max_content_width - 3
+            if truncate_at > 0:
+                content = content[:truncate_at] + "..."
+                clean_content = Colors.strip(content)
+            else:
+                content = "..."
+                clean_content = "..."
+
+        padding = max(0, max_content_width - len(clean_content))
 
         if align == "center":
             left_pad = padding // 2
@@ -362,7 +337,7 @@ class CostDisplay:
 
     def clear_screen(self):
         """Clear the terminal screen."""
-        if sys.platform == "win32":
+        if IS_WINDOWS:
             os.system("cls")
         else:
             os.system("clear")
@@ -389,7 +364,7 @@ class CompactCostDisplay:
         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")
+        self.display_currency = display_currency or os.getenv("COST_DISPLAY_CURRENCY", "USD")
 
     def render(self) -> str:
         """Render compact display."""