anvil-dev-framework 0.1.6

package/global/lib/config_service.py

@@ -0,0 +1,423 @@
+#!/usr/bin/env python3
+"""
+config_service.py - Configuration management for HUD (ANV-116-118)
+
+Manages HUD configuration including budget thresholds, refresh intervals,
+and feature toggles. Supports both global defaults and per-project overrides.
+
+Usage:
+    from config_service import get_config
+
+    config = get_config()
+    print(config.budget.agent_warn_threshold)  # $5.00
+
+Configuration files:
+    - ~/.anvil/hud-config.yaml (global defaults)
+    - .anvil/hud-config.yaml (project overrides)
+"""
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Literal, Optional
+
+try:
+    import yaml
+    HAS_YAML = True
+except ImportError:
+    HAS_YAML = False
+
+
+@dataclass
+class BudgetConfig:
+    """Budget threshold configuration."""
+    # Billing model: "api" (pay-per-use) or "subscription" (Pro/Max flat rate)
+    # When "subscription", cost alerts are disabled (costs shown for info only)
+    billing_model: Literal["api", "subscription"] = "api"
+    agent_warn_threshold: float = 5.0      # Warn when agent exceeds $5
+    agent_crit_threshold: float = 10.0     # Critical when agent exceeds $10
+    total_warn_threshold: float = 15.0     # Warn when total exceeds $15
+    total_crit_threshold: float = 25.0     # Critical when total exceeds $25
+    daily_budget: Optional[float] = None   # Optional daily budget limit
+    weekly_budget: Optional[float] = None  # Optional weekly budget limit
+
+
+@dataclass
+class ContextConfig:
+    """Context usage threshold configuration."""
+    warn_threshold_pct: int = 80           # Warn at 80% context
+    crit_threshold_pct: int = 90           # Critical at 90% context
+    compaction_reminder: bool = True       # Show compaction reminders
+    estimated_turns_warn: int = 10         # Warn when <10 turns estimated
+
+
+@dataclass
+class CoordinationConfig:
+    """Coordination/branch age configuration."""
+    stale_branch_hours: int = 4            # Branch stale after 4 hours
+    conflict_detection: bool = True        # Enable conflict detection
+    lock_timeout_minutes: int = 30         # File lock timeout
+
+
+@dataclass
+class RefreshConfig:
+    """Refresh interval configuration."""
+    agent_refresh_seconds: float = 2.0     # Agent list refresh
+    quality_cache_seconds: float = 30.0    # Quality check cache TTL
+    github_cache_seconds: float = 30.0     # GitHub status cache TTL
+    coderabbit_cache_seconds: float = 60.0 # CodeRabbit cache TTL
+
+
+@dataclass
+class DisplayConfig:
+    """Display/UI configuration."""
+    show_cost_panel: bool = True
+    show_task_panel: bool = True
+    show_quality_panel: bool = True
+    show_coordination_panel: bool = True
+    truncate_agent_id_length: int = 16
+    max_issues_shown: int = 5
+    max_locks_shown: int = 5
+    max_conflicts_shown: int = 3
+
+
+@dataclass
+class IntegrationConfig:
+    """External integration configuration."""
+    enable_linear: bool = True
+    enable_github: bool = True
+    enable_coderabbit: bool = True
+    enable_quality_checks: bool = True
+
+
+@dataclass
+class HUDModeConfig:
+    """HUD v3 mode configuration (ANV-128)."""
+    default_mode: Literal["focused", "full"] = "focused"  # Default to Focused Mode
+    remember_last_tab: bool = True                        # Remember tab across sessions
+    show_tab_bar: bool = True                             # Show tab bar in Focused Mode
+
+
+@dataclass
+class HUDConfig:
+    """Main HUD configuration."""
+    budget: BudgetConfig = field(default_factory=BudgetConfig)
+    context: ContextConfig = field(default_factory=ContextConfig)
+    coordination: CoordinationConfig = field(default_factory=CoordinationConfig)
+    refresh: RefreshConfig = field(default_factory=RefreshConfig)
+    display: DisplayConfig = field(default_factory=DisplayConfig)
+    integrations: IntegrationConfig = field(default_factory=IntegrationConfig)
+    hud: HUDModeConfig = field(default_factory=HUDModeConfig)  # HUD v3 (ANV-128)
+
+    # Feature flags
+    demo_mode: bool = False
+    debug_mode: bool = False
+    notifications_enabled: bool = True
+    sound_enabled: bool = False
+
+
+def _deep_update(base: Dict[str, Any], updates: Dict[str, Any]) -> Dict[str, Any]:
+    """Recursively update a dict with another dict."""
+    result = dict(base)
+    for key, value in updates.items():
+        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+            result[key] = _deep_update(result[key], value)
+        else:
+            result[key] = value
+    return result
+
+
+def _dict_to_config(data: Dict[str, Any]) -> HUDConfig:
+    """Convert a dictionary to HUDConfig."""
+    config = HUDConfig()
+
+    if "budget" in data:
+        for key, value in data["budget"].items():
+            if hasattr(config.budget, key):
+                setattr(config.budget, key, value)
+
+    if "context" in data:
+        for key, value in data["context"].items():
+            if hasattr(config.context, key):
+                setattr(config.context, key, value)
+
+    if "coordination" in data:
+        for key, value in data["coordination"].items():
+            if hasattr(config.coordination, key):
+                setattr(config.coordination, key, value)
+
+    if "refresh" in data:
+        for key, value in data["refresh"].items():
+            if hasattr(config.refresh, key):
+                setattr(config.refresh, key, value)
+
+    if "display" in data:
+        for key, value in data["display"].items():
+            if hasattr(config.display, key):
+                setattr(config.display, key, value)
+
+    if "integrations" in data:
+        for key, value in data["integrations"].items():
+            if hasattr(config.integrations, key):
+                setattr(config.integrations, key, value)
+
+    # HUD v3 mode config (ANV-128)
+    if "hud" in data:
+        for key, value in data["hud"].items():
+            if hasattr(config.hud, key):
+                setattr(config.hud, key, value)
+
+    # Top-level flags
+    for key in ["demo_mode", "debug_mode", "notifications_enabled", "sound_enabled"]:
+        if key in data:
+            setattr(config, key, data[key])
+
+    return config
+
+
+class ConfigService:
+    """Service for loading and managing HUD configuration (ANV-116-118)."""
+
+    def __init__(self, project_path: Optional[str] = None):
+        """Initialize the config service.
+
+        Args:
+            project_path: Optional project path for project-specific config
+        """
+        self.project_path = Path(project_path) if project_path else None
+        self._config: Optional[HUDConfig] = None
+        self._config_sources: List[str] = []
+
+    @property
+    def config(self) -> HUDConfig:
+        """Get the current configuration, loading if needed."""
+        if self._config is None:
+            self._config = self._load_config()
+        return self._config
+
+    def reload(self) -> HUDConfig:
+        """Force reload configuration from disk."""
+        self._config = None
+        return self.config
+
+    def get_config_sources(self) -> List[str]:
+        """Get list of config files that were loaded."""
+        return self._config_sources
+
+    def _load_config(self) -> HUDConfig:
+        """Load configuration from files, merging global and project configs."""
+        self._config_sources = []
+        merged_data: Dict[str, Any] = {}
+
+        # Load global config from ~/.anvil/hud-config.yaml
+        global_config_path = Path.home() / ".anvil" / "hud-config.yaml"
+        if global_config_path.exists():
+            global_data = self._load_yaml_file(global_config_path)
+            if global_data:
+                merged_data = _deep_update(merged_data, global_data)
+                self._config_sources.append(str(global_config_path))
+
+        # Load project config from .anvil/hud-config.yaml
+        if self.project_path:
+            project_config_path = self.project_path / ".anvil" / "hud-config.yaml"
+            if project_config_path.exists():
+                project_data = self._load_yaml_file(project_config_path)
+                if project_data:
+                    merged_data = _deep_update(merged_data, project_data)
+                    self._config_sources.append(str(project_config_path))
+
+        # Also check for env var overrides
+        merged_data = self._apply_env_overrides(merged_data)
+
+        return _dict_to_config(merged_data)
+
+    def _load_yaml_file(self, path: Path) -> Optional[Dict[str, Any]]:
+        """Load a YAML config file."""
+        if not HAS_YAML:
+            return None
+
+        try:
+            with open(path, "r") as f:
+                return yaml.safe_load(f) or {}
+        except Exception:
+            return None
+
+    def _apply_env_overrides(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Apply environment variable overrides to config."""
+        # Support env var overrides for common settings
+        env_mappings = {
+            "ANVIL_HUD_DEMO": ("demo_mode", lambda x: x.lower() == "true"),
+            "ANVIL_HUD_DEBUG": ("debug_mode", lambda x: x.lower() == "true"),
+            # Billing model: "api" (pay-per-use) or "subscription" (Pro/Max)
+            "ANVIL_BILLING_MODEL": ("budget.billing_model", lambda x: x.lower() if x.lower() in ["api", "subscription"] else "api"),
+            "ANVIL_BUDGET_WARN": ("budget.agent_warn_threshold", float),
+            "ANVIL_BUDGET_CRIT": ("budget.agent_crit_threshold", float),
+            "ANVIL_CONTEXT_WARN": ("context.warn_threshold_pct", int),
+            "ANVIL_CONTEXT_CRIT": ("context.crit_threshold_pct", int),
+            "ANVIL_STALE_HOURS": ("coordination.stale_branch_hours", int),
+            "ANVIL_REFRESH_SECONDS": ("refresh.agent_refresh_seconds", float),
+            # HUD v3 mode (ANV-128)
+            "ANVIL_HUD_MODE": ("hud.default_mode", lambda x: x.lower() if x.lower() in ["focused", "full"] else "focused"),
+        }
+
+        for env_var, (config_path, converter) in env_mappings.items():
+            value = os.environ.get(env_var)
+            if value is not None:
+                try:
+                    converted = converter(value)
+                    # Set nested value
+                    parts = config_path.split(".")
+                    if len(parts) == 1:
+                        data[parts[0]] = converted
+                    else:
+                        if parts[0] not in data:
+                            data[parts[0]] = {}
+                        data[parts[0]][parts[1]] = converted
+                except (ValueError, TypeError):
+                    pass
+
+        return data
+
+    def save_global_config(self, config: HUDConfig) -> bool:
+        """Save configuration to global config file."""
+        if not HAS_YAML:
+            return False
+
+        config_path = Path.home() / ".anvil" / "hud-config.yaml"
+        return self._save_config(config, config_path)
+
+    def save_project_config(self, config: HUDConfig) -> bool:
+        """Save configuration to project config file."""
+        if not HAS_YAML or not self.project_path:
+            return False
+
+        config_path = self.project_path / ".anvil" / "hud-config.yaml"
+        return self._save_config(config, config_path)
+
+    def _save_config(self, config: HUDConfig, path: Path) -> bool:
+        """Save configuration to a file."""
+        try:
+            # Ensure directory exists
+            path.parent.mkdir(parents=True, exist_ok=True)
+
+            # Convert config to dict
+            data = self._config_to_dict(config)
+
+            with open(path, "w") as f:
+                yaml.dump(data, f, default_flow_style=False, sort_keys=False)
+
+            return True
+        except Exception:
+            return False
+
+    def _config_to_dict(self, config: HUDConfig) -> Dict[str, Any]:
+        """Convert HUDConfig to a dictionary for saving."""
+        return {
+            "budget": {
+                "billing_model": config.budget.billing_model,  # "api" or "subscription"
+                "agent_warn_threshold": config.budget.agent_warn_threshold,
+                "agent_crit_threshold": config.budget.agent_crit_threshold,
+                "total_warn_threshold": config.budget.total_warn_threshold,
+                "total_crit_threshold": config.budget.total_crit_threshold,
+                "daily_budget": config.budget.daily_budget,
+                "weekly_budget": config.budget.weekly_budget,
+            },
+            "context": {
+                "warn_threshold_pct": config.context.warn_threshold_pct,
+                "crit_threshold_pct": config.context.crit_threshold_pct,
+                "compaction_reminder": config.context.compaction_reminder,
+                "estimated_turns_warn": config.context.estimated_turns_warn,
+            },
+            "coordination": {
+                "stale_branch_hours": config.coordination.stale_branch_hours,
+                "conflict_detection": config.coordination.conflict_detection,
+                "lock_timeout_minutes": config.coordination.lock_timeout_minutes,
+            },
+            "refresh": {
+                "agent_refresh_seconds": config.refresh.agent_refresh_seconds,
+                "quality_cache_seconds": config.refresh.quality_cache_seconds,
+                "github_cache_seconds": config.refresh.github_cache_seconds,
+                "coderabbit_cache_seconds": config.refresh.coderabbit_cache_seconds,
+            },
+            "display": {
+                "show_cost_panel": config.display.show_cost_panel,
+                "show_task_panel": config.display.show_task_panel,
+                "show_quality_panel": config.display.show_quality_panel,
+                "show_coordination_panel": config.display.show_coordination_panel,
+                "truncate_agent_id_length": config.display.truncate_agent_id_length,
+                "max_issues_shown": config.display.max_issues_shown,
+                "max_locks_shown": config.display.max_locks_shown,
+                "max_conflicts_shown": config.display.max_conflicts_shown,
+            },
+            "integrations": {
+                "enable_linear": config.integrations.enable_linear,
+                "enable_github": config.integrations.enable_github,
+                "enable_coderabbit": config.integrations.enable_coderabbit,
+                "enable_quality_checks": config.integrations.enable_quality_checks,
+            },
+            # HUD v3 mode config (ANV-128)
+            "hud": {
+                "default_mode": config.hud.default_mode,
+                "remember_last_tab": config.hud.remember_last_tab,
+                "show_tab_bar": config.hud.show_tab_bar,
+            },
+            "demo_mode": config.demo_mode,
+            "debug_mode": config.debug_mode,
+            "notifications_enabled": config.notifications_enabled,
+            "sound_enabled": config.sound_enabled,
+        }
+
+
+# Singleton instance
+_service: Optional[ConfigService] = None
+
+
+def get_config_service(project_path: Optional[str] = None) -> ConfigService:
+    """Get singleton config service instance."""
+    global _service
+    # Normalize paths for comparison (handles relative/absolute, trailing slashes, symlinks)
+    norm_project = Path(project_path).resolve() if project_path else None
+    norm_existing = _service.project_path.resolve() if _service and _service.project_path else None
+
+    if _service is None or (norm_project and norm_project != norm_existing):
+        _service = ConfigService(project_path)
+    return _service
+
+
+def get_config(project_path: Optional[str] = None) -> HUDConfig:
+    """Convenience function to get config directly."""
+    return get_config_service(project_path).config
+
+
+def generate_default_config() -> str:
+    """Generate a default config file content."""
+    if not HAS_YAML:
+        return "# YAML not available. Install pyyaml to use config files."
+
+    config = HUDConfig()
+    service = ConfigService()
+    data = service._config_to_dict(config)
+
+    header = """# Anvil HUD Configuration
+# This file configures the Anvil HUD multi-agent dashboard.
+#
+# Location:
+#   Global: ~/.anvil/hud-config.yaml
+#   Project: .anvil/hud-config.yaml (overrides global)
+#
+# Environment variables can override settings:
+#   ANVIL_HUD_DEMO=true        - Enable demo mode
+#   ANVIL_HUD_DEBUG=true       - Enable debug mode
+#   ANVIL_HUD_MODE=focused     - Default mode: focused or full (ANV-128)
+#   ANVIL_BUDGET_WARN=5.0      - Agent budget warning threshold
+#   ANVIL_CONTEXT_WARN=80      - Context usage warning %
+#   ANVIL_STALE_HOURS=4        - Stale branch threshold hours
+#   ANVIL_REFRESH_SECONDS=2.0  - Agent refresh interval
+
+"""
+    return header + yaml.dump(data, default_flow_style=False, sort_keys=False)
+
+
+if __name__ == "__main__":
+    # Generate and print default config
+    print(generate_default_config())