roadmap-cli 0.1.1__py3-none-any.whl

roadmap/common/configuration/config_loader.py

@@ -0,0 +1,264 @@
+"""Configuration loader and manager.
+
+Handles loading and merging user-level and project-level configurations
+with support for YAML files and sensible defaults.
+"""
+
+from pathlib import Path
+from typing import Any
+
+import yaml
+from structlog import get_logger
+
+from roadmap.common.models import RoadmapConfig
+
+logger = get_logger()
+
+
+class ConfigLoader:
+    """Loads and manages roadmap configuration."""
+
+    # Default configuration
+    DEFAULT_CONFIG = RoadmapConfig()
+
+    @classmethod
+    def get_user_config_path(cls) -> Path:
+        """Get the user-level config file path.
+
+        Returns:
+            Path to ~/.roadmap/config.yaml
+        """
+        home = Path.home()
+        return home / ".roadmap" / "config.yaml"
+
+    @classmethod
+    def get_project_config_path(cls, project_root: Path | None = None) -> Path:
+        """Get the project-level config file path.
+
+        Args:
+            project_root: Project root directory (defaults to cwd)
+
+        Returns:
+            Path to .roadmap/config.yaml in project
+        """
+        if project_root is None:
+            project_root = Path.cwd()
+        return project_root / ".roadmap" / "config.yaml"
+
+    @classmethod
+    def load_user_config(cls) -> RoadmapConfig | None:
+        """Load user-level configuration.
+
+        Returns:
+            RoadmapConfig from user config file, or None if not found
+        """
+        path = cls.get_user_config_path()
+        return cls._load_config_file(path)
+
+    @classmethod
+    def load_project_config(
+        cls, project_root: Path | None = None
+    ) -> RoadmapConfig | None:
+        """Load project-level configuration.
+
+        Args:
+            project_root: Project root directory (defaults to cwd)
+
+        Returns:
+            RoadmapConfig from project config file, or None if not found
+        """
+        path = cls.get_project_config_path(project_root)
+        return cls._load_config_file(path)
+
+    @classmethod
+    def _load_config_file(cls, path: Path) -> RoadmapConfig | None:
+        """Load a configuration file.
+
+        Args:
+            path: Path to config file
+
+        Returns:
+            RoadmapConfig if file exists and is valid, None otherwise
+        """
+        if not path.exists():
+            return None
+
+        try:
+            with open(path, encoding="utf-8") as f:
+                data = yaml.safe_load(f) or {}
+
+            # Ensure data is a dictionary
+            if not isinstance(data, dict):
+                logger.warning(
+                    "invalid_config_format",
+                    path=str(path),
+                    error="config is not a mapping",
+                    severity="data_error",
+                )
+                return None
+
+            # Validate and create config from data
+            config = RoadmapConfig(**data)
+            logger.info("loaded_config", path=str(path))
+            return config
+        except Exception as e:
+            logger.warning(
+                "failed_to_load_config",
+                path=str(path),
+                error=str(e),
+                severity="data_error",
+            )
+            return None
+
+    @classmethod
+    def load_config(cls, project_root: Path | None = None) -> RoadmapConfig:
+        """Load and merge all configurations.
+
+        Precedence: defaults < user config < project config
+
+        Args:
+            project_root: Project root directory (defaults to cwd)
+
+        Returns:
+            Merged RoadmapConfig with all layers applied
+        """
+        # Start with defaults
+        config = cls.DEFAULT_CONFIG
+
+        # Merge user config
+        user_config = cls.load_user_config()
+        if user_config:
+            config = config.merge(user_config)
+
+        # Merge project config
+        project_config = cls.load_project_config(project_root)
+        if project_config:
+            config = config.merge(project_config)
+
+        return config
+
+    @classmethod
+    def save_user_config(cls, config: RoadmapConfig) -> bool:
+        """Save user-level configuration.
+
+        Args:
+            config: Configuration to save
+
+        Returns:
+            True if successful, False otherwise
+        """
+        path = cls.get_user_config_path()
+        return cls._save_config_file(path, config)
+
+    @classmethod
+    def save_project_config(
+        cls, config: RoadmapConfig, project_root: Path | None = None
+    ) -> bool:
+        """Save project-level configuration.
+
+        Args:
+            config: Configuration to save
+            project_root: Project root directory (defaults to cwd)
+
+        Returns:
+            True if successful, False otherwise
+        """
+        path = cls.get_project_config_path(project_root)
+        return cls._save_config_file(path, config)
+
+    @classmethod
+    def _save_config_file(cls, path: Path, config: RoadmapConfig) -> bool:
+        """Save a configuration file.
+
+        Args:
+            path: Path to config file
+            config: Configuration to save
+
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            # Create directory if needed
+            path.parent.mkdir(parents=True, exist_ok=True)
+
+            # Convert config to dict and save as YAML
+            data = config.model_dump(exclude_none=True)
+            with open(path, "w", encoding="utf-8") as f:
+                yaml.dump(data, f, default_flow_style=False, sort_keys=False)
+
+            logger.info("saved_config", path=str(path))
+            return True
+        except Exception as e:
+            logger.error(
+                "failed_to_save_config",
+                path=str(path),
+                error=str(e),
+                severity="system_error",
+            )
+            return False
+
+    @classmethod
+    def get_config_value(cls, key_path: str, project_root: Path | None = None) -> Any:
+        """Get a configuration value by path (e.g., 'export.directory').
+
+        Args:
+            key_path: Dot-separated path to config value
+            project_root: Project root directory (defaults to cwd)
+
+        Returns:
+            Configuration value, or None if not found
+        """
+        config = cls.load_config(project_root)
+        keys = key_path.split(".")
+        value = config
+
+        for key in keys:
+            if hasattr(value, key):
+                value = getattr(value, key)
+            elif isinstance(value, dict) and key in value:
+                value = value[key]
+            else:
+                return None
+
+        return value
+
+    @classmethod
+    def set_config_value(
+        cls,
+        key_path: str,
+        value: Any,
+        project_level: bool = False,
+        project_root: Path | None = None,
+    ) -> bool:
+        """Set a configuration value by path (e.g., 'export.directory').
+
+        Args:
+            key_path: Dot-separated path to config value
+            value: Value to set
+            project_level: If True, save to project config; else user config
+            project_root: Project root directory (defaults to cwd)
+
+        Returns:
+            True if successful, False otherwise
+        """
+        # Load existing config
+        if project_level:
+            config = cls.load_project_config(project_root) or RoadmapConfig()
+        else:
+            config = cls.load_user_config() or RoadmapConfig()
+
+        # Set value in config
+        keys = key_path.split(".")
+        target = config
+        for key in keys[:-1]:
+            if not hasattr(target, key):
+                setattr(target, key, {})
+            target = getattr(target, key)
+
+        setattr(target, keys[-1], value)
+
+        # Save config
+        if project_level:
+            return cls.save_project_config(config, project_root)
+        else:
+            return cls.save_user_config(config)

roadmap/common/configuration/config_manager.py

@@ -0,0 +1,164 @@
+"""Configuration management for roadmap."""
+
+import subprocess
+from pathlib import Path
+
+import yaml
+
+from .config_schema import GitHubConfig, PathsConfig, RoadmapConfig, UserConfig
+
+
+class ConfigManager:
+    """Manages roadmap configuration files.
+
+    Supports two-level configuration:
+    - config.yaml: Team-level configuration (committed to git)
+    - config.yaml.local: User-level overrides (gitignored, local only)
+
+    When both exist, local overrides shared settings.
+    """
+
+    def __init__(self, config_file: Path):
+        """Initialize config manager with config file path."""
+        self.config_file = config_file
+        self.local_config_file = Path(str(config_file).replace(".yaml", ".yaml.local"))
+
+    def load(self) -> RoadmapConfig:
+        """Load configuration from file(s).
+
+        Loads team config first, then merges local overrides if present.
+        """
+        config_data: dict = {}
+
+        # Load shared config (team-level)
+        if self.config_file.exists():
+            with open(self.config_file) as f:
+                loaded = yaml.safe_load(f)
+                config_data = loaded if isinstance(loaded, dict) else {}
+
+        # Load and merge local config (user-level overrides)
+        if self.local_config_file.exists():
+            with open(self.local_config_file) as f:
+                loaded = yaml.safe_load(f)
+                local_data = loaded if isinstance(loaded, dict) else {}
+            # Deep merge: local overrides shared
+            config_data = self._deep_merge(config_data, local_data)
+
+        return RoadmapConfig.from_dict(config_data)
+
+    def save(self, config: RoadmapConfig, is_local: bool = False) -> None:
+        """Save configuration to file.
+
+        Args:
+            config: Configuration to save
+            is_local: If True, save to .local file (user overrides only)
+        """
+        target_file = self.local_config_file if is_local else self.config_file
+        target_file.parent.mkdir(parents=True, exist_ok=True)
+
+        with open(target_file, "w") as f:
+            yaml.dump(config.to_dict(), f, default_flow_style=False, sort_keys=False)
+
+    @staticmethod
+    def _deep_merge(base: dict, override: dict) -> dict:
+        """Deep merge override dict into base dict.
+
+        Override values take precedence over base values.
+        """
+        result = base.copy()
+        for key, value in override.items():
+            if (
+                key in result
+                and isinstance(result[key], dict)
+                and isinstance(value, dict)
+            ):
+                result[key] = ConfigManager._deep_merge(result[key], value)
+            else:
+                result[key] = value
+        return result
+
+    @staticmethod
+    def auto_detect_user() -> str | None:
+        """Auto-detect user from git config or environment."""
+        try:
+            # Try git config user.name
+            result = subprocess.run(
+                ["git", "config", "user.name"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            if result.returncode == 0 and result.stdout.strip():
+                return result.stdout.strip()
+        except (subprocess.TimeoutExpired, FileNotFoundError):
+            pass
+
+        # Try git config user.email
+        try:
+            result = subprocess.run(
+                ["git", "config", "user.email"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            if result.returncode == 0 and result.stdout.strip():
+                email = result.stdout.strip()
+                # Extract name part before @
+                if "@" in email:
+                    return email.split("@")[0]
+        except (subprocess.TimeoutExpired, FileNotFoundError):
+            pass
+
+        return None
+
+    @staticmethod
+    def auto_detect_github_username() -> str | None:
+        """Auto-detect GitHub username from git remote."""
+        try:
+            result = subprocess.run(
+                ["git", "config", "user.github"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            if result.returncode == 0 and result.stdout.strip():
+                return result.stdout.strip()
+        except (subprocess.TimeoutExpired, FileNotFoundError):
+            pass
+
+        # Try to extract from git remote origin url
+        try:
+            result = subprocess.run(
+                ["git", "config", "remote.origin.url"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            if result.returncode == 0:
+                url = result.stdout.strip()
+                # Parse github.com:owner/repo.git or https://github.com/owner/repo.git
+                if "github.com" in url:
+                    parts = url.split("/")[-2:]  # Get last 2 parts
+                    if parts and parts[0]:
+                        return parts[0]
+        except (subprocess.TimeoutExpired, FileNotFoundError):
+            pass
+
+        return None
+
+    @staticmethod
+    def create_default_config(
+        user_name: str,
+        user_email: str | None = None,
+        github_owner: str | None = None,
+        github_repo: str | None = None,
+        github_enabled: bool = False,
+    ) -> RoadmapConfig:
+        """Create a default configuration."""
+        user = UserConfig(name=user_name, email=user_email)
+        paths = PathsConfig()
+        github = GitHubConfig(
+            owner=github_owner, repo=github_repo, enabled=github_enabled
+        )
+
+        return RoadmapConfig(user=user, paths=paths, github=github)

roadmap/common/configuration/config_schema.py

@@ -0,0 +1,145 @@
+"""Configuration schema for roadmap projects.
+
+SECURITY NOTICE:
+- The config.yaml file is LOCAL ONLY and should NOT be committed to version control
+- It is added to .gitignore to prevent accidental exposure
+- It should contain only local user preferences, NOT secrets
+- GitHub tokens and other credentials should be stored in environment variables or .env files
+- The config.yaml file should have restrictive permissions (e.g., mode 0600)
+"""
+
+from dataclasses import asdict, dataclass, field
+
+
+@dataclass
+class UserConfig:
+    """User configuration - LOCAL ONLY, NEVER share or commit this file.
+
+    Contains only non-sensitive user identification for the roadmap.
+
+    SECURITY WARNING:
+    - Do NOT store passwords, API keys, or other secrets in this config
+    - Do NOT commit config.yaml to version control
+    - Use environment variables or .env files for sensitive credentials
+    - Keep config.yaml file permissions restrictive (mode 0600)
+    """
+
+    name: str  # Local username/identifier
+    email: str | None = None
+
+
+@dataclass
+class PathsConfig:
+    """Path configuration (LOCAL ONLY - relative to project root).
+
+    These are local paths on the user's machine and should never be shared.
+    """
+
+    roadmap_dir: str = ".roadmap"
+    logs_dir: str = ".roadmap/logs"
+    db_dir: str = ".roadmap/db"
+
+
+@dataclass
+class GitHubConfig:
+    """GitHub integration configuration - DOES NOT store credentials.
+
+    Contains only repository metadata and sync preferences.
+
+    SECURITY WARNING:
+    - Do NOT store GitHub tokens or PATs (Personal Access Tokens) in this config
+    - Use GITHUB_TOKEN environment variable for authentication instead
+    - webhook_secret is stored locally but should be kept secure
+    - Never commit config.yaml with webhook_secret to version control
+    """
+
+    owner: str | None = None
+    repo: str | None = None
+    enabled: bool = False
+    sync_enabled: bool = False
+    sync_backend: str = "github"  # "github" or "git"
+    webhook_secret: str | None = None
+    sync_settings: dict = field(
+        default_factory=lambda: {
+            "bidirectional": True,
+            "auto_close": True,
+            "sync_labels": True,
+            "sync_milestones": True,
+        }
+    )
+
+
+@dataclass
+class DisplayConfig:
+    """Display preferences and UI customization (LOCAL ONLY).
+
+    User-specific display settings for command output and formatting.
+    These are local preferences and should never be shared.
+    """
+
+    default_milestone: str | None = None
+    table_width: int = 100
+
+
+@dataclass
+class BehaviorConfig:
+    """Application behavior preferences.
+
+    User-specific behavior settings for CLI operations.
+    """
+
+    auto_branch_on_start: bool = False
+    confirm_destructive: bool = True
+    show_tips: bool = True
+    include_closed_in_critical_path: bool = False
+    default_project_id: str | None = None
+
+
+@dataclass
+class RoadmapConfig:
+    """Complete roadmap configuration - LOCAL ONLY, NEVER commit to version control.
+
+    This is the root configuration object stored in .roadmap/config.yaml.
+    It aggregates user, paths, GitHub, display, and behavior settings.
+
+    SECURITY REMINDER:
+    - This entire config object is user-specific and must not be shared
+    - It is added to .gitignore to prevent accidental commits
+    - Secrets (tokens, PATs) must go in environment variables, NOT here
+    - Keep the config.yaml file with restrictive permissions (mode 0600)
+    """
+
+    user: UserConfig
+    paths: PathsConfig = field(default_factory=PathsConfig)
+    github: GitHubConfig = field(default_factory=GitHubConfig)
+    display: DisplayConfig = field(default_factory=DisplayConfig)
+    behavior: BehaviorConfig = field(default_factory=BehaviorConfig)
+
+    def to_dict(self):
+        """Convert to dictionary for YAML serialization."""
+        return asdict(self)
+
+    @staticmethod
+    def from_dict(data: dict) -> "RoadmapConfig":
+        """Create from dictionary (e.g., from YAML)."""
+        user_data = data.get("user", {})
+        user = UserConfig(**user_data) if user_data else None
+
+        paths_data = data.get("paths", {}) or {}
+        paths = PathsConfig(**paths_data)
+
+        github_data = data.get("github", {}) or {}
+        github = GitHubConfig(**github_data)
+
+        display_data = data.get("display", {}) or {}
+        display = DisplayConfig(**display_data)
+
+        behavior_data = data.get("behavior", {}) or {}
+        behavior = BehaviorConfig(**behavior_data)
+
+        if not user:
+            raise ValueError("User configuration is required")
+
+        return RoadmapConfig(
+            user=user, paths=paths, github=github, display=display, behavior=behavior
+        )

roadmap/common/configuration/github/__init__.py

@@ -0,0 +1,9 @@
+"""GitHub configuration management."""
+
+from roadmap.common.configuration.github.config_manager import GitHubConfigManager
+from roadmap.common.configuration.github.token_resolver import GitHubTokenResolver
+
+__all__ = [
+    "GitHubTokenResolver",
+    "GitHubConfigManager",
+]