moai-adk 0.32.8__py3-none-any.whl → 0.41.2__py3-none-any.whl

moai_adk/core/migration/version_detector.py

@@ -8,7 +8,9 @@ which migrations are needed.
 import json
 import logging
 from pathlib import Path
-from typing import Any, Dict
+from typing import Any, Dict, Optional
+
+import yaml
 
 logger = logging.getLogger(__name__)
 
@@ -24,26 +26,79 @@ class VersionDetector:
             project_root: Root directory of the project
         """
         self.project_root = Path(project_root)
+        # Legacy config paths (pre-v0.24.0)
         self.old_config = self.project_root / ".moai" / "config.json"
-        self.new_config = self.project_root / ".moai" / "config" / "config.json"
+        # Intermediate config path (v0.24.0)
+        self.intermediate_config = self.project_root / ".moai" / "config" / "config.json"
+        # New section YAML paths (v0.36.0+)
+        self.sections_dir = self.project_root / ".moai" / "config" / "sections"
+        self.system_yaml = self.sections_dir / "system.yaml"
+        # Statusline config paths
         self.old_statusline = self.project_root / ".claude" / "statusline-config.yaml"
         self.new_statusline = self.project_root / ".moai" / "config" / "statusline-config.yaml"
 
+    def _read_yaml_file(self, file_path: Path) -> Optional[Dict[str, Any]]:
+        """
+        Read a YAML file safely
+
+        Args:
+            file_path: Path to the YAML file
+
+        Returns:
+            Dictionary with file contents, or None if read failed
+        """
+        try:
+            if file_path.exists():
+                with open(file_path, "r", encoding="utf-8") as f:
+                    return yaml.safe_load(f)
+        except Exception as e:
+            logger.warning(f"Failed to read YAML file {file_path}: {e}")
+        return None
+
+    def _get_version_from_section_yaml(self) -> Optional[str]:
+        """
+        Get version from section YAML files (new format)
+
+        Returns:
+            Version string from system.yaml, or None if not found
+        """
+        system_data = self._read_yaml_file(self.system_yaml)
+        if system_data and "moai" in system_data:
+            version = system_data["moai"].get("version")
+            if version:
+                return str(version)
+        return None
+
     def detect_version(self) -> str:
         """
         Detect current project version based on file structure
 
         Returns:
-            Version string (e.g., "0.23.0", "0.24.0+", "unknown")
+            Version string (e.g., "0.23.0", "0.24.0+", "0.36.0+", "unknown")
         """
-        # Check if already migrated to v0.24.0+
-        if self.new_config.exists():
-            return "0.24.0+"
+        # Check if using new section YAML format (v0.36.0+)
+        if self.sections_dir.exists() and self.system_yaml.exists():
+            version = self._get_version_from_section_yaml()
+            if version:
+                return version
+            return "0.36.0+"
+
+        # Check if already migrated to v0.24.0+ (intermediate config.json)
+        if self.intermediate_config.exists():
+            try:
+                with open(self.intermediate_config, "r", encoding="utf-8") as f:
+                    config_data = json.load(f)
+                    if "moai_version" in config_data:
+                        return config_data["moai_version"]
+                    return "0.24.0+"
+            except Exception as e:
+                logger.warning(f"Failed to read intermediate config: {e}")
+                return "0.24.0+"
 
-        # Check if v0.23.0 or earlier
+        # Check if v0.23.0 or earlier (old config.json at .moai/config.json)
         if self.old_config.exists():
             try:
-                with open(self.old_config, "r") as f:
+                with open(self.old_config, "r", encoding="utf-8") as f:
                     config_data = json.load(f)
                     # Try to get version from config
                     if "moai_version" in config_data:
@@ -67,10 +122,16 @@ class VersionDetector:
             logger.info("Unknown version, assuming no migration needed")
             return False
 
-        if version == "0.24.0+":
-            logger.info("Project already on v0.24.0+")
+        # Check if using new section YAML format (v0.36.0+)
+        if self.sections_dir.exists() and self.system_yaml.exists():
+            logger.info("Project already using section YAML format (v0.36.0+)")
             return False
 
+        if version == "0.24.0+":
+            logger.info("Project on v0.24.0+, may need migration to section YAML format")
+            # Could still need migration to section YAML format
+            return not self.sections_dir.exists()
+
         # Version 0.23.0 or earlier needs migration
         return True
 
@@ -83,24 +144,46 @@ class VersionDetector:
             {
                 "move": [{"from": "...", "to": "..."}],
                 "create": ["directory1", "directory2"],
-                "cleanup": ["old_file1", "old_file2"]
+                "cleanup": ["old_file1", "old_file2"],
+                "convert": [{"from": "...", "to_dir": "...", "description": "..."}]
             }
         """
-        plan: Dict[str, Any] = {"move": [], "create": [], "cleanup": []}
+        plan: Dict[str, Any] = {"move": [], "create": [], "cleanup": [], "convert": []}
 
         if not self.needs_migration():
             return plan
 
-        # Create config directory
-        plan["create"].append(str(self.project_root / ".moai" / "config"))
+        # Create config directory structure
+        config_dir = self.project_root / ".moai" / "config"
+        plan["create"].append(str(config_dir))
 
-        # Move config.json
-        if self.old_config.exists() and not self.new_config.exists():
+        # Create sections directory for new YAML format
+        if not self.sections_dir.exists():
+            plan["create"].append(str(self.sections_dir))
+
+        # Handle old config.json migration (pre-v0.24.0)
+        if self.old_config.exists() and not self.intermediate_config.exists():
             plan["move"].append(
                 {
                     "from": str(self.old_config.relative_to(self.project_root)),
-                    "to": str(self.new_config.relative_to(self.project_root)),
-                    "description": "Main configuration file",
+                    "to": str(self.intermediate_config.relative_to(self.project_root)),
+                    "description": "Main configuration file (legacy)",
+                }
+            )
+
+        # Mark config.json files for conversion to section YAML
+        config_json_to_convert = None
+        if self.intermediate_config.exists():
+            config_json_to_convert = self.intermediate_config
+        elif self.old_config.exists():
+            config_json_to_convert = self.old_config
+
+        if config_json_to_convert and not self.system_yaml.exists():
+            plan["convert"].append(
+                {
+                    "from": str(config_json_to_convert.relative_to(self.project_root)),
+                    "to_dir": str(self.sections_dir.relative_to(self.project_root)),
+                    "description": "Convert config.json to section YAML files",
                 }
             )
 
@@ -119,6 +202,9 @@ class VersionDetector:
             plan["cleanup"].append(str(self.old_config.relative_to(self.project_root)))
         if self.old_statusline.exists():
             plan["cleanup"].append(str(self.old_statusline.relative_to(self.project_root)))
+        # Also cleanup intermediate config.json after conversion to YAML
+        if self.intermediate_config.exists() and self.sections_dir.exists():
+            plan["cleanup"].append(str(self.intermediate_config.relative_to(self.project_root)))
 
         return plan
 
@@ -133,7 +219,25 @@ class VersionDetector:
             "detected_version": self.detect_version(),
             "needs_migration": self.needs_migration(),
             "has_old_config": self.old_config.exists(),
-            "has_new_config": self.new_config.exists(),
+            "has_intermediate_config": self.intermediate_config.exists(),
+            "has_sections_dir": self.sections_dir.exists(),
+            "has_system_yaml": self.system_yaml.exists(),
             "has_old_statusline": self.old_statusline.exists(),
             "has_new_statusline": self.new_statusline.exists(),
+            "config_format": self._get_config_format(),
         }
+
+    def _get_config_format(self) -> str:
+        """
+        Determine the current configuration format
+
+        Returns:
+            One of: "section_yaml", "intermediate_json", "legacy_json", "none"
+        """
+        if self.sections_dir.exists() and self.system_yaml.exists():
+            return "section_yaml"
+        elif self.intermediate_config.exists():
+            return "intermediate_json"
+        elif self.old_config.exists():
+            return "legacy_json"
+        return "none"

moai_adk/core/migration/version_migrator.py

@@ -3,12 +3,20 @@ Main version migration orchestrator for MoAI-ADK
 
 Coordinates version detection, backup creation, file migration,
 and cleanup processes for automatic project upgrades.
+
+Supports migration from:
+- Legacy config.json (.moai/config.json) - pre-v0.24.0
+- Intermediate config.json (.moai/config/config.json) - v0.24.0
+- Section YAML files (.moai/config/sections/*.yaml) - v0.36.0+
 """
 
+import json
 import logging
 from pathlib import Path
 from typing import Any, Dict
 
+import yaml
+
 from .backup_manager import BackupManager
 from .file_migrator import FileMigrator
 from .version_detector import VersionDetector
@@ -165,6 +173,13 @@ class VersionMigrator:
             print(f"   • {move_op['description']}")
             print(f"     {move_op['from']} → {move_op['to']}")
 
+        # Show conversion operations (config.json to section YAML)
+        if plan.get("convert"):
+            print("\n🔄 Files to convert:")
+            for convert_op in plan.get("convert", []):
+                print(f"   • {convert_op['description']}")
+                print(f"     {convert_op['from']} → {convert_op['to_dir']}/")
+
         print("\n🗑️  Files to cleanup after migration:")
         for cleanup_file in plan.get("cleanup", []):
             print(f"   - {cleanup_file}")
@@ -176,20 +191,40 @@ class VersionMigrator:
         Returns:
             True if verification passed
         """
-        # Check that new config exists
-        new_config = self.project_root / ".moai" / "config" / "config.json"
-        if not new_config.exists():
-            logger.error("Verification failed: new config.json not found")
-            return False
-
-        # Check that new config directory exists
+        # Check that config directory exists
         config_dir = self.project_root / ".moai" / "config"
         if not config_dir.is_dir():
             logger.error("Verification failed: config directory not found")
             return False
 
-        logger.debug("All verification checks passed")
-        return True
+        # Check for section YAML format (preferred v0.36.0+)
+        sections_dir = self.project_root / ".moai" / "config" / "sections"
+        system_yaml = sections_dir / "system.yaml"
+
+        if sections_dir.exists() and system_yaml.exists():
+            # Verify system.yaml is valid
+            try:
+                with open(system_yaml, "r", encoding="utf-8") as f:
+                    data = yaml.safe_load(f)
+                    if data and "moai" in data:
+                        logger.debug("Section YAML format verification passed")
+                        return True
+            except Exception as e:
+                logger.warning(f"Failed to verify system.yaml: {e}")
+
+        # Fallback: check for intermediate config.json (v0.24.0 format)
+        intermediate_config = self.project_root / ".moai" / "config" / "config.json"
+        if intermediate_config.exists():
+            try:
+                with open(intermediate_config, "r", encoding="utf-8") as f:
+                    json.load(f)
+                    logger.debug("Intermediate config.json verification passed")
+                    return True
+            except Exception as e:
+                logger.warning(f"Failed to verify config.json: {e}")
+
+        logger.error("Verification failed: no valid configuration found")
+        return False
 
     def check_status(self) -> Dict[str, Any]:
         """

moai_adk/core/project/backup_utils.py

@@ -8,13 +8,21 @@ Selective backup strategy:
 from pathlib import Path
 
 # Backup targets (OR condition - back up when any exist)
+# Note: Both YAML and JSON config files are checked for backward compatibility
 BACKUP_TARGETS = [
-    ".moai/config/config.json",
+    ".moai/config/config.yaml",
+    ".moai/config/config.json",  # Legacy support
+    ".moai/config/sections/",  # Section-based config files
     ".moai/project/",
     ".moai/memory/",
     ".claude/",
     ".github/",
     "CLAUDE.md",
+    # MCP/LSP configuration (v2.0.0)
+    ".mcp.json",  # MCP server configuration
+    ".lsp.json",  # LSP server configuration
+    # Git hooks (v2.0.0)
+    ".git-hooks/",  # Custom git hooks
 ]
 
 # User data protection paths (excluded from backups)

moai_adk/core/project/initializer.py

@@ -58,61 +58,6 @@ class ProjectInitializer:
         self.validator = ProjectValidator()
         self.executor = PhaseExecutor(self.validator)
 
-    def _create_memory_files(self) -> list[str]:
-        """Create runtime session and memory files (auto-generated per user/session)
-
-        Returns:
-            List of created memory files
-
-        """
-        memory_dir = self.path / ".moai" / "memory"
-        memory_dir.mkdir(parents=True, exist_ok=True)
-        created_files = []
-
-        # 1. project-notes.json - Project tracking notes (empty on init)
-        project_notes = {
-            "tech_debt": [],
-            "performance_bottlenecks": [],
-            "recent_patterns": {
-                "frequent_file_edits": [],
-                "test_failures": [],
-                "git_operations": "daily commits, feature branches",
-            },
-            "next_priorities": [],
-        }
-        project_notes_file = memory_dir / "project-notes.json"
-        project_notes_file.write_text(json.dumps(project_notes, indent=2))
-        created_files.append(str(project_notes_file))
-
-        # 2. session-hint.json - Last session state
-        session_hint = {
-            "last_command": None,
-            "command_timestamp": None,
-            "hours_ago": None,
-            "active_spec": None,
-            "current_branch": "main",
-        }
-        session_hint_file = memory_dir / "session-hint.json"
-        session_hint_file.write_text(json.dumps(session_hint, indent=2))
-        created_files.append(str(session_hint_file))
-
-        # 3. user-patterns.json - User preferences and expertise
-        user_patterns = {
-            "tech_preferences": {},
-            "expertise_signals": {
-                "ask_question_skip_rate": 0.0,
-                "custom_workflows": 0,
-                "estimated_level": "beginner",
-            },
-            "skip_questions": [],
-            "last_updated": datetime.now().isoformat() + "Z",
-        }
-        user_patterns_file = memory_dir / "user-patterns.json"
-        user_patterns_file.write_text(json.dumps(user_patterns, indent=2))
-        created_files.append(str(user_patterns_file))
-
-        return created_files
-
     def _create_user_settings(self) -> list[str]:
         """Create user-specific settings files (.claude/settings.local.json)
 
@@ -213,12 +158,38 @@ class ProjectInitializer:
             # Phase 2: Directory (create directories)
             self.executor.execute_directory_phase(self.path, progress_callback)
 
+            # Build language_config BEFORE Phase 3 for template variable substitution
+            # This fixes the bug where language selection was not applied to section files
+            language_names = {
+                "ko": "Korean",
+                "en": "English",
+                "ja": "Japanese",
+                "zh": "Chinese",
+            }
+            if locale == "other" and custom_language:
+                language_config = {
+                    "conversation_language": "other",
+                    "conversation_language_name": custom_language,
+                }
+            elif locale in language_names:
+                language_config = {
+                    "conversation_language": locale,
+                    "conversation_language_name": language_names[locale],
+                }
+            else:
+                # Default fallback
+                language_config = {
+                    "conversation_language": locale or "en",
+                    "conversation_language_name": language_names.get(locale, "English"),
+                }
+
             # Prepare config for template variable substitution (Phase 3)
             config = {
                 "name": self.path.name,
                 "mode": mode,
                 "locale": locale,
-                "language": detected_language,
+                "language": detected_language,  # Programming language (string)
+                "language_settings": language_config,  # Language settings (dict)
                 "description": "",
                 "version": "0.1.0",
                 "author": "@user",
@@ -242,32 +213,8 @@ class ProjectInitializer:
                     except Exception:
                         pass  # Silently ignore permission errors
 
-            # Phase 4: Configuration (generate config.json)
-            # Handle language configuration
-            language_config = {}
-            if locale == "other" and custom_language:
-                language_config = {
-                    "conversation_language": "other",
-                    "conversation_language_name": custom_language,
-                }
-            elif locale in ["ko", "en", "ja", "zh"]:
-                language_names = {
-                    "ko": "Korean",
-                    "en": "English",
-                    "ja": "Japanese",
-                    "zh": "Chinese",
-                }
-                language_config = {
-                    "conversation_language": locale,
-                    "conversation_language_name": language_names.get(locale, "English"),
-                }
-            else:
-                # Default fallback
-                language_config = {
-                    "conversation_language": locale,
-                    "conversation_language_name": "English",
-                }
-
+            # Phase 4: Configuration (update section YAML files)
+            # Note: language_config is already created before Phase 3
             config_data: dict[str, str | bool | dict] = {
                 "project": {
                     "name": self.path.name,
@@ -286,14 +233,7 @@ class ProjectInitializer:
                 "language": language_config,
                 "constitution": {
                     "enforce_tdd": True,
-                    "principles": {
-                        "simplicity": {
-                            "max_projects": 5,
-                            "notes": "Default recommendation. Adjust in .moai/config.json "
-                            "or via SPEC/ADR with documented rationale based on project size.",
-                        }
-                    },
-                    "test_coverage_target": 90,
+                    "test_coverage_target": 85,
                 },
                 "git_strategy": {
                     "personal": {
@@ -320,7 +260,7 @@ class ProjectInitializer:
                         "auto_pr": False,
                         "develop_branch": "develop",
                         "draft_pr": False,
-                        "feature_prefix": "feature/SPEC-",
+                        "branch_prefix": "feature/SPEC-",
                         "main_branch": "main",
                         "use_gitflow": True,
                         "default_pr_base": "develop",
@@ -338,10 +278,7 @@ class ProjectInitializer:
             # Phase 5: Validation (verify and finalize)
             self.executor.execute_validation_phase(self.path, mode, progress_callback)
 
-            # Phase 6: Create runtime memory files (auto-generated per user/session)
-            memory_files = self._create_memory_files()
-
-            # Phase 7: Create user settings (gitignored, user-specific)
+            # Phase 6: Create user settings (gitignored, user-specific)
             user_settings_files = self._create_user_settings()
 
             # Generate result
@@ -353,7 +290,7 @@ class ProjectInitializer:
                 mode=mode,
                 locale=locale,
                 duration=duration,
-                created_files=resource_files + config_files + memory_files + user_settings_files,
+                created_files=resource_files + config_files + user_settings_files,
             )
 
         except Exception as e:

moai_adk/core/project/phase_executor.py

@@ -304,13 +304,25 @@ class PhaseExecutor:
 
         # Set template variable context (if provided)
         if config:
-            language_config: dict[str, Any] = config.get("language", {})
-            if not isinstance(language_config, dict):
-                language_config = {}
+            # Get language settings from 'language_settings' key (dict)
+            # Falls back to 'language' key for backwards compatibility
+            language_config: dict[str, Any] = config.get("language_settings") or {}
+            if not language_config or not isinstance(language_config, dict):
+                # Backwards compatibility: try 'language' key as dict
+                legacy_lang = config.get("language", {})
+                language_config = legacy_lang if isinstance(legacy_lang, dict) else {}
 
             # Detect OS for cross-platform Hook path configuration
             hook_project_dir = "%CLAUDE_PROJECT_DIR%" if platform.system() == "Windows" else "$CLAUDE_PROJECT_DIR"
 
+            # Detect OS for cross-platform statusline command
+            # Windows: Use python -m for better PATH compatibility
+            # Unix: Use moai-adk directly (assumes installed via uv tool)
+            if platform.system() == "Windows":
+                statusline_command = "python -m moai_adk statusline"
+            else:
+                statusline_command = "moai-adk statusline"
+
             # Get enhanced version context with fallback strategies
             version_context = self._get_enhanced_version_context()
 
@@ -327,6 +339,7 @@ class PhaseExecutor:
                 "CONVERSATION_LANGUAGE_NAME": language_config.get("conversation_language_name", "English"),
                 "CODEBASE_LANGUAGE": config.get("language", "generic"),
                 "PROJECT_DIR": hook_project_dir,
+                "STATUSLINE_COMMAND": statusline_command,
             }
             processor.set_context(context)
 
@@ -365,54 +378,87 @@ class PhaseExecutor:
         config: dict[str, str | bool | dict[Any, Any]],
         progress_callback: ProgressCallback | None = None,
     ) -> list[str]:
-        """Phase 4: generate configuration.
+        """Phase 4: Update section YAML configuration files.
+
+        Note: As of v0.37.0, we use modular section YAML files instead of a single config.json.
+        Section files are located in .moai/config/sections/ and loaded by CLAUDE.md.
 
         Args:
             project_path: Project path.
-            config: Configuration dictionary.
+            config: Configuration dictionary with project, language, etc.
             progress_callback: Optional progress callback.
 
         Returns:
-            List of created files.
+            List of updated section files.
         """
         self.current_phase = 4
-        self._report_progress("Phase 4: Generating configurations...", progress_callback)
+        self._report_progress("Phase 4: Updating section configurations...", progress_callback)
 
         logger = logging.getLogger(__name__)
+        sections_dir = project_path / ".moai" / "config" / "sections"
+        updated_files: list[str] = []
+
+        # Update project.yaml with dynamic values
+        project_yaml = sections_dir / "project.yaml"
+        if project_yaml.exists():
+            self._update_section_yaml(
+                project_yaml,
+                {
+                    "project.name": config.get("project", {}).get("name", project_path.name),
+                    "project.initialized": "true",
+                    "project.created_at": datetime.now().isoformat() + "Z",
+                },
+            )
+            updated_files.append(str(project_yaml))
+            logger.debug(f"Updated {project_yaml}")
 
-        # Read existing config to preserve user settings (Issue #165)
-        config_path = project_path / ".moai" / "config" / "config.json"
-        existing_config: dict[str, Any] = {}
-        if config_path.exists():
+        # Update system.yaml with version
+        system_yaml = sections_dir / "system.yaml"
+        if system_yaml.exists():
             try:
-                with open(config_path, "r", encoding="utf-8") as f:
-                    existing_config = json.load(f)
-                logger.debug(f"Successfully read existing config from {config_path}")
-            except (json.JSONDecodeError, OSError) as e:
-                logger.warning(f"Failed to read existing config: {e}. Starting fresh.")
-                existing_config = {}
+                version_reader = self._get_version_reader()
+                current_version = version_reader.get_version()
+            except Exception:
+                current_version = __version__
+
+            self._update_section_yaml(
+                system_yaml,
+                {"moai.version": current_version},
+            )
+            updated_files.append(str(system_yaml))
+            logger.debug(f"Updated {system_yaml}")
 
-        # Enhanced config merging with comprehensive version preservation
-        merged_config = self._merge_configuration_preserving_versions(config, existing_config)
+        logger.info(f"Updated {len(updated_files)} section configuration files")
+        return updated_files
 
-        # Enhanced version handling using VersionReader for consistency
-        try:
-            version_reader = self._get_version_reader()
-            current_config_version = version_reader.get_version()
+    def _update_section_yaml(self, yaml_path: Path, updates: dict[str, str]) -> None:
+        """
+        Update specific values in a YAML section file.
 
-            # Ensure version consistency across the merged config
-            self._ensure_version_consistency(merged_config, current_config_version, existing_config)
+        Args:
+            yaml_path: Path to the YAML file
+            updates: Dictionary of dotted paths to new values (e.g., {"project.name": "MyProject"})
+        """
+        import yaml
 
-            logger.debug(f"Version consistency check completed. Current version: {current_config_version}")
-        except Exception as e:
-            logger.warning(f"Version consistency check failed: {e}. Using fallback version.")
-            merged_config["moai"]["version"] = __version__
+        try:
+            with open(yaml_path, "r", encoding="utf-8") as f:
+                content = yaml.safe_load(f) or {}
+
+            for dotted_key, value in updates.items():
+                keys = dotted_key.split(".")
+                current = content
+                for key in keys[:-1]:
+                    if key not in current:
+                        current[key] = {}
+                    current = current[key]
+                current[keys[-1]] = value
 
-        # Write final config with enhanced formatting
-        self._write_configuration_file(config_path, merged_config)
-        logger.info(f"Configuration file written to {config_path}")
+            with open(yaml_path, "w", encoding="utf-8") as f:
+                yaml.dump(content, f, default_flow_style=False, allow_unicode=True, sort_keys=False)
 
-        return [str(config_path)]
+        except Exception as e:
+            logging.getLogger(__name__).warning(f"Failed to update {yaml_path}: {e}")
 
     def _merge_configuration_preserving_versions(
         self, new_config: dict[str, Any], existing_config: dict[str, Any]