moai-adk 0.35.1__py3-none-any.whl

moai_adk/core/config/__init__.py

@@ -0,0 +1,19 @@
+"""Configuration management for MoAI-ADK."""
+
+from moai_adk.core.config.migration import (
+    get_conversation_language,
+    get_conversation_language_name,
+    get_report_generation_config,
+    get_spec_git_workflow,
+    migrate_config_schema_v0_17_0,
+    migrate_config_to_nested_structure,
+)
+
+__all__ = [
+    "migrate_config_to_nested_structure",
+    "migrate_config_schema_v0_17_0",
+    "get_conversation_language",
+    "get_conversation_language_name",
+    "get_report_generation_config",
+    "get_spec_git_workflow",
+]

moai_adk/core/config/auto_spec_config.py

@@ -0,0 +1,340 @@
+"""Auto-Spec Completion Configuration Reader."""
+
+import json
+import logging
+from pathlib import Path
+from typing import Any, Dict, List
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+
+class AutoSpecConfig:
+    """
+    Configuration reader for Auto-Spec Completion system.
+
+    This class reads and validates the auto-spec completion configuration
+    from the main MoAI configuration file.
+    """
+
+    def __init__(self, config_path: str = None):
+        """Initialize the configuration reader."""
+        self.config_path = config_path or self._get_default_config_path()
+        self.config: dict[str, Any] = {}
+        self.load_config()
+
+    def _get_default_config_path(self) -> str:
+        """Get the default configuration file path."""
+        # Try to find config in multiple locations
+        possible_paths = [
+            Path.cwd() / ".moai" / "config.json",
+            Path.cwd() / "config.json",
+            Path.home() / ".moai" / "config.json",
+        ]
+
+        for path in possible_paths:
+            if path.exists():
+                return str(path)
+
+        # Default to current directory
+        return str(Path.cwd() / ".moai" / "config.json")
+
+    def load_config(self) -> None:
+        """Load configuration from file."""
+        try:
+            with open(self.config_path, "r", encoding="utf-8") as f:
+                self.config = json.load(f)
+
+            # Extract auto-spec completion config
+            self.config = self.config.get("auto_spec_completion", {})
+
+            logger.info(f"Loaded auto-spec completion configuration from {self.config_path}")
+
+        except FileNotFoundError:
+            logger.warning(f"Configuration file not found: {self.config_path}")
+            self._load_default_config()
+        except json.JSONDecodeError as e:
+            logger.error(f"Invalid JSON in configuration file: {e}")
+            self._load_default_config()
+        except Exception as e:
+            logger.error(f"Error loading configuration: {e}")
+            self._load_default_config()
+
+    def _load_default_config(self) -> None:
+        """Load default configuration."""
+        logger.info("Loading default auto-spec completion configuration")
+        self.config = self._get_default_config()
+
+    def _get_default_config(self) -> Dict[str, Any]:
+        """Get default configuration."""
+        return {
+            "enabled": True,
+            "trigger_tools": ["Write", "Edit", "MultiEdit"],
+            "confidence_threshold": 0.7,
+            "execution_timeout_ms": 1500,
+            "quality_threshold": {
+                "ears_compliance": 0.85,
+                "min_content_length": 500,
+                "max_review_suggestions": 10,
+            },
+            "excluded_patterns": [
+                "test_*.py",
+                "*_test.py",
+                "*/tests/*",
+                "*/__pycache__/*",
+                "*/node_modules/*",
+                "*/dist/*",
+                "*/build/*",
+            ],
+            "domain_templates": {
+                "enabled": True,
+                "auto_detect": True,
+                "supported_domains": ["auth", "api", "data", "ui", "business"],
+                "fallback_domain": "general",
+            },
+            "spec_structure": {
+                "include_meta": True,
+                "include_traceability": True,
+                "include_edit_guide": True,
+                "required_sections": [
+                    "Overview",
+                    "Environment",
+                    "Assumptions",
+                    "Requirements",
+                    "Specifications",
+                    "Traceability",
+                ],
+            },
+            "validation": {
+                "enabled": True,
+                "quality_grades": ["A", "B", "C", "D", "F"],
+                "passing_grades": ["A", "B", "C"],
+                "auto_improve": True,
+                "max_iterations": 3,
+            },
+            "output": {
+                "auto_create_files": True,
+                "open_in_editor": True,
+                "file_format": "markdown",
+                "encoding": "utf-8",
+            },
+        }
+
+    def is_enabled(self) -> bool:
+        """Check if auto-spec completion is enabled."""
+        return self.config.get("enabled", False)
+
+    def get_trigger_tools(self) -> List[str]:
+        """Get list of tools that trigger auto-spec completion."""
+        return self.config.get("trigger_tools", [])
+
+    def get_confidence_threshold(self) -> float:
+        """Get confidence threshold for triggering auto-spec completion."""
+        return self.config.get("confidence_threshold", 0.7)
+
+    def get_execution_timeout_ms(self) -> int:
+        """Get execution timeout in milliseconds."""
+        return self.config.get("execution_timeout_ms", 1500)
+
+    def get_quality_threshold(self) -> Dict[str, Any]:
+        """Get quality threshold configuration."""
+        return self.config.get("quality_threshold", {})
+
+    def get_excluded_patterns(self) -> List[str]:
+        """Get list of file patterns to exclude from auto-spec completion."""
+        return self.config.get("excluded_patterns", [])
+
+    def get_domain_templates_config(self) -> Dict[str, Any]:
+        """Get domain templates configuration."""
+        return self.config.get("domain_templates", {})
+
+    def get_spec_structure_config(self) -> Dict[str, Any]:
+        """Get spec structure configuration."""
+        return self.config.get("spec_structure", {})
+
+    def get_validation_config(self) -> Dict[str, Any]:
+        """Get validation configuration."""
+        return self.config.get("validation", {})
+
+    def get_output_config(self) -> Dict[str, Any]:
+        """Get output configuration."""
+        return self.config.get("output", {})
+
+    def should_exclude_file(self, file_path: str) -> bool:
+        """Check if a file should be excluded from auto-spec completion."""
+        excluded_patterns = self.get_excluded_patterns()
+
+        if not excluded_patterns:
+            return False
+
+        # Convert file path to normalized string
+        normalized_path = str(Path(file_path)).lower()
+
+        for pattern in excluded_patterns:
+            # Convert pattern to lowercase for case-insensitive matching
+            pattern.lower()
+
+            # Handle directory patterns
+            if pattern.startswith("*/") and pattern.endswith("/*"):
+                dir_pattern = pattern[2:-2]  # Remove */ and /*
+                if dir_pattern in normalized_path:
+                    return True
+            # Handle file patterns
+            elif "*" in pattern:
+                # Simple wildcard matching
+                regex_pattern = pattern.replace("*", ".*")
+                import re
+
+                if re.search(regex_pattern, normalized_path):
+                    return True
+            # Exact match
+            elif pattern in normalized_path:
+                return True
+
+        return False
+
+    def get_required_sections(self) -> List[str]:
+        """Get list of required SPEC sections."""
+        return self.config.get("spec_structure", {}).get("required_sections", [])
+
+    def get_supported_domains(self) -> List[str]:
+        """Get list of supported domains."""
+        return self.config.get("domain_templates", {}).get("supported_domains", [])
+
+    def get_fallback_domain(self) -> str:
+        """Get fallback domain for unsupported domains."""
+        return self.config.get("domain_templates", {}).get("fallback_domain", "general")
+
+    def should_include_meta(self) -> bool:
+        """Check if meta information should be included."""
+        return self.config.get("spec_structure", {}).get("include_meta", True)
+
+    def should_include_traceability(self) -> bool:
+        """Check if traceability information should be included."""
+        return self.config.get("spec_structure", {}).get("include_traceability", True)
+
+    def should_include_edit_guide(self) -> bool:
+        """Check if edit guide should be included."""
+        return self.config.get("spec_structure", {}).get("include_edit_guide", True)
+
+    def get_passing_quality_grades(self) -> List[str]:
+        """Get list of passing quality grades."""
+        return self.config.get("validation", {}).get("passing_grades", ["A", "B", "C"])
+
+    def should_auto_improve(self) -> bool:
+        """Check if auto-improvement is enabled."""
+        return self.config.get("validation", {}).get("auto_improve", True)
+
+    def get_max_improvement_iterations(self) -> int:
+        """Get maximum improvement iterations."""
+        return self.config.get("validation", {}).get("max_iterations", 3)
+
+    def should_auto_create_files(self) -> bool:
+        """Check if auto-creation of files is enabled."""
+        return self.config.get("output", {}).get("auto_create_files", True)
+
+    def should_open_in_editor(self) -> bool:
+        """Check if files should be opened in editor."""
+        return self.config.get("output", {}).get("open_in_editor", True)
+
+    def get_file_format(self) -> str:
+        """Get output file format."""
+        return self.config.get("output", {}).get("file_format", "markdown")
+
+    def get_encoding(self) -> str:
+        """Get output encoding."""
+        return self.config.get("output", {}).get("encoding", "utf-8")
+
+    def is_validation_enabled(self) -> bool:
+        """Check if validation is enabled."""
+        return self.config.get("validation", {}).get("enabled", True)
+
+    def is_domain_detection_enabled(self) -> bool:
+        """Check if domain detection is enabled."""
+        return self.config.get("domain_templates", {}).get("auto_detect", True)
+
+    def validate_config(self) -> List[str]:
+        """Validate configuration and return list of errors."""
+        errors = []
+
+        # Check required fields
+        if not isinstance(self.config.get("enabled"), bool):
+            errors.append("enabled must be a boolean")
+
+        if not isinstance(self.config.get("confidence_threshold"), (int, float)):
+            errors.append("confidence_threshold must be a number")
+        elif not 0 <= self.config.get("confidence_threshold") <= 1:
+            errors.append("confidence_threshold must be between 0 and 1")
+
+        if not isinstance(self.config.get("execution_timeout_ms"), int):
+            errors.append("execution_timeout_ms must be an integer")
+        elif self.config.get("execution_timeout_ms") <= 0:
+            errors.append("execution_timeout_ms must be positive")
+
+        # Check trigger tools
+        trigger_tools = self.config.get("trigger_tools", [])
+        if not isinstance(trigger_tools, list):
+            errors.append("trigger_tools must be a list")
+        else:
+            for tool in trigger_tools:
+                if not isinstance(tool, str):
+                    errors.append("All trigger_tools must be strings")
+
+        # Check excluded patterns
+        excluded_patterns = self.config.get("excluded_patterns", [])
+        if not isinstance(excluded_patterns, list):
+            errors.append("excluded_patterns must be a list")
+        else:
+            for pattern in excluded_patterns:
+                if not isinstance(pattern, str):
+                    errors.append("All excluded_patterns must be strings")
+
+        # Check quality threshold
+        quality_threshold = self.config.get("quality_threshold", {})
+        if not isinstance(quality_threshold, dict):
+            errors.append("quality_threshold must be a dictionary")
+        else:
+            if "ears_compliance" in quality_threshold:
+                if not isinstance(quality_threshold["ears_compliance"], (int, float)):
+                    errors.append("quality_threshold.ears_compliance must be a number")
+                elif not 0 <= quality_threshold["ears_compliance"] <= 1:
+                    errors.append("quality_threshold.ears_compliance must be between 0 and 1")
+
+        return errors
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert configuration to dictionary."""
+        return self.config.copy()
+
+    def update_config(self, updates: Dict[str, Any]) -> None:
+        """Update configuration with new values."""
+        self.config.update(updates)
+        logger.info(f"Updated auto-spec completion configuration: {updates}")
+
+    def save_config(self) -> None:
+        """Save configuration to file."""
+        try:
+            # Load the full config file
+            with open(self.config_path, "r", encoding="utf-8") as f:
+                full_config = json.load(f)
+
+            # Update the auto-spec completion config
+            full_config["auto_spec_completion"] = self.config
+
+            # Save back to file
+            with open(self.config_path, "w", encoding="utf-8") as f:
+                json.dump(full_config, f, indent=2, ensure_ascii=False)
+
+            logger.info(f"Saved auto-spec completion configuration to {self.config_path}")
+
+        except Exception as e:
+            logger.error(f"Error saving configuration: {e}")
+            raise
+
+    def __str__(self) -> str:
+        """String representation of configuration."""
+        return json.dumps(self.config, indent=2, ensure_ascii=False)
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return f"AutoSpecConfig(enabled={self.is_enabled()}, config_path='{self.config_path}')"

moai_adk/core/config/migration.py

@@ -0,0 +1,244 @@
+"""Configuration migration utilities for legacy flat config structure.
+
+Supports migration from legacy flat config.json structure to new nested language structure.
+"""
+
+from typing import Any
+
+
+def migrate_config_to_nested_structure(config: dict[str, Any]) -> dict[str, Any]:
+    """Migrate legacy flat config to nested language structure.
+
+    This function handles the transition from legacy flat config:
+        "conversation_language": "ko"
+        "locale": "ko"
+
+    To new nested structure:
+        "language": {
+            "conversation_language": "ko",
+            "conversation_language_name": "한국어"
+        }
+
+    Args:
+        config: Configuration dictionary that may have legacy structure.
+
+    Returns:
+        Configuration dictionary with nested language structure.
+    """
+    # If config already has nested language structure, return as-is
+    if "language" in config and isinstance(config["language"], dict):
+        return config
+
+    # If config has legacy flat structure, migrate it
+    if "conversation_language" in config and "language" not in config:
+        # Extract conversation language from legacy location
+        conversation_language = config.pop("conversation_language", "en")
+        config.pop("locale", None)  # Remove legacy locale field
+
+        # Import enhanced language configuration
+        from ..language_config import LANGUAGE_CONFIG
+
+        # Extract language names from enhanced config
+        language_names = {code: info["native_name"] for code, info in LANGUAGE_CONFIG.items()}
+
+        language_name = language_names.get(conversation_language, "English")
+
+        # Create new nested language structure
+        config["language"] = {
+            "conversation_language": conversation_language,
+            "conversation_language_name": language_name,
+        }
+
+    # 2. Language settings migration
+    # Old: "language": "ko"
+    # New: "language": {"conversation_language": "ko", "conversation_language_name": "Korean"}
+    if "language" in config and isinstance(config["language"], str):
+        old_lang = config["language"]
+        lang_names = {
+            "ko": "Korean",
+            "en": "English",
+            "ja": "Japanese",
+            "zh": "Chinese",
+        }
+        config["language"] = {
+            "conversation_language": old_lang,
+            "conversation_language_name": lang_names.get(old_lang, "English"),
+        }
+
+    return config
+
+
+def get_conversation_language(config: dict[str, Any]) -> str:
+    """Get conversation language from config with fallback handling.
+
+    Handles both legacy flat and new nested config structures.
+
+    Args:
+        config: Configuration dictionary.
+
+    Returns:
+        Language code (e.g., "ko", "en", "ja").
+    """
+    # First, try to get from nested structure (new format)
+    language_config = config.get("language", {})
+    if isinstance(language_config, dict):
+        result = language_config.get("conversation_language")
+        if result:
+            return result
+
+    # Fall back to legacy flat structure
+    result = config.get("conversation_language")
+    if result:
+        return result
+
+    # Default to English
+    return "en"
+
+
+def get_conversation_language_name(config: dict[str, Any]) -> str:
+    """Get conversation language name from config with fallback handling.
+
+    Handles both legacy flat and new nested config structures.
+
+    Args:
+        config: Configuration dictionary.
+
+    Returns:
+        Language name (e.g., "한국어", "English").
+    """
+    # First, try to get from nested structure (new format)
+    language_config = config.get("language", {})
+    if isinstance(language_config, dict):
+        result = language_config.get("conversation_language_name")
+        if result:
+            return result
+
+    # If we have the language code, try to map it
+    language_code = get_conversation_language(config)
+
+    # Import enhanced language configuration
+    from ..language_config import LANGUAGE_CONFIG
+
+    # Extract language names from enhanced config
+    language_names = {code: info["native_name"] for code, info in LANGUAGE_CONFIG.items()}
+    return language_names.get(language_code, "English")
+
+
+def migrate_config_schema_v0_17_0(config: dict[str, Any]) -> dict[str, Any]:
+    """Migrate config schema for v0.16.0 → v0.17.0 (report generation feature).
+
+    Adds new sections:
+    - report_generation: Control automatic report generation
+    - Enhanced github: auto_delete_branches, spec_git_workflow settings
+
+    This function is backward-compatible and safe for existing configs.
+
+    Args:
+        config: Configuration dictionary (may be v0.16.0 or earlier).
+
+    Returns:
+        Configuration dictionary with v0.17.0 schema.
+    """
+    # 1. Add report_generation section if missing (defaults to enabled=true, auto_create=false)
+    if "report_generation" not in config:
+        config["report_generation"] = {
+            "enabled": True,
+            "auto_create": False,
+            "warn_user": True,
+            "user_choice": "Minimal",
+            "configured_at": None,  # Will be set when user configures
+            "allowed_locations": [
+                ".moai/docs/",
+                ".moai/reports/",
+                ".moai/analysis/",
+                ".moai/specs/SPEC-*/",
+            ],
+            "notes": (
+                "Control automatic report generation. 'enabled': turn on/off, "
+                "'auto_create': full (true) vs minimal (false) reports. "
+                "Helps reduce token usage."
+            ),
+        }
+
+    # 2. Enhance github section with new fields
+    if "github" not in config:
+        config["github"] = {}
+
+    github_config = config["github"]
+
+    # Add auto_delete_branches settings if missing
+    if "auto_delete_branches" not in github_config:
+        github_config["auto_delete_branches"] = None
+        github_config["auto_delete_branches_checked"] = False
+        github_config["auto_delete_branches_rationale"] = "Not configured"
+
+    # Add spec_git_workflow settings if missing
+    if "spec_git_workflow" not in github_config:
+        github_config["spec_git_workflow"] = "per_spec"
+        github_config["spec_git_workflow_configured"] = False
+        github_config["spec_git_workflow_rationale"] = "Ask per SPEC (flexible, user controls each workflow)"
+
+    # Add notes for new fields if missing
+    if "notes_new_fields" not in github_config:
+        github_config["notes_new_fields"] = (
+            "auto_delete_branches: whether to auto-delete feature branches after merge. "
+            "spec_git_workflow: 'feature_branch' (auto), 'develop_direct' (direct), "
+            "'per_spec' (ask per SPEC)"
+        )
+
+    return config
+
+
+def get_report_generation_config(config: dict[str, Any]) -> dict[str, Any]:
+    """Get report generation configuration with safe defaults.
+
+    Args:
+        config: Configuration dictionary.
+
+    Returns:
+        Report generation configuration with defaults.
+    """
+    default_config = {
+        "enabled": True,
+        "auto_create": False,
+        "warn_user": True,
+        "user_choice": "Minimal",
+        "configured_at": None,
+        "allowed_locations": [
+            ".moai/docs/",
+            ".moai/reports/",
+            ".moai/analysis/",
+            ".moai/specs/SPEC-*/",
+        ],
+    }
+
+    report_gen = config.get("report_generation", {})
+    if isinstance(report_gen, dict):
+        # Merge with defaults to ensure all keys exist
+        return {**default_config, **report_gen}
+
+    return default_config
+
+
+def get_spec_git_workflow(config: dict[str, Any]) -> str:
+    """Get SPEC git workflow setting with safe default.
+
+    Options:
+    - 'per_spec': Ask per SPEC (flexible, user controls)
+    - 'feature_branch': Auto-create branch for each SPEC
+    - 'develop_direct': Direct commits to develop
+
+    Args:
+        config: Configuration dictionary.
+
+    Returns:
+        Workflow setting string.
+    """
+    github_config = config.get("github", {})
+    if isinstance(github_config, dict):
+        workflow = github_config.get("spec_git_workflow")
+        if workflow in ["per_spec", "feature_branch", "develop_direct"]:
+            return workflow
+
+    # Default: per_spec (ask user)
+    return "per_spec"