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

moai_adk/core/quality/trust_checker.py

@@ -342,17 +342,37 @@ class TrustChecker:
         Returns:
             dict[str, str]: Selected tool dictionary
         """
-        config_path = project_path / ".moai" / "config" / "config.json"
-        if not config_path.exists():
-            return {
-                "test_framework": "pytest",
-                "coverage_tool": "coverage.py",
-                "linter": "ruff",
-                "type_checker": "mypy",
-            }
+        import yaml
 
-        config = json.loads(config_path.read_text())
-        language = config.get("project", {}).get("language", "python")
+        language = "python"  # Default
+
+        # Try section YAML file first (new format)
+        project_section_path = project_path / ".moai" / "config" / "sections" / "project.yaml"
+        if project_section_path.exists():
+            try:
+                with open(project_section_path, encoding="utf-8") as f:
+                    project_config = yaml.safe_load(f) or {}
+                language = project_config.get("project", {}).get("language", "python")
+            except (yaml.YAMLError, OSError):
+                pass  # Use default
+        else:
+            # Fall back to main config file (YAML or JSON)
+            yaml_config_path = project_path / ".moai" / "config" / "config.yaml"
+            json_config_path = project_path / ".moai" / "config" / "config.json"
+
+            if yaml_config_path.exists():
+                try:
+                    with open(yaml_config_path, encoding="utf-8") as f:
+                        config = yaml.safe_load(f) or {}
+                    language = config.get("project", {}).get("language", "python")
+                except (yaml.YAMLError, OSError):
+                    pass  # Use default
+            elif json_config_path.exists():
+                try:
+                    config = json.loads(json_config_path.read_text())
+                    language = config.get("project", {}).get("language", "python")
+                except (json.JSONDecodeError, OSError):
+                    pass  # Use default
 
         if language == "python":
             return {

moai_adk/core/realtime_monitoring_dashboard.py

@@ -208,7 +208,7 @@ class MetricsCollector:
         self.metrics_buffer: Dict[str, deque] = defaultdict(lambda: deque(maxlen=buffer_size))
         self.aggregated_metrics: Dict[str, Dict[str, Any]] = defaultdict(dict)
         self.tenant_metrics: Dict[str, Dict[str, deque]] = defaultdict(lambda: defaultdict(deque))
-        self._lock = threading.Lock()
+        self._lock = threading.RLock()
         self._last_cleanup = datetime.now()
 
     def add_metric(self, metric: MetricData) -> None:
@@ -437,7 +437,7 @@ class AlertManager:
         self.alert_history: List[Alert] = []
         self.alert_callbacks: List[Callable[[Alert], None]] = []
         self.tenant_alerts: Dict[str, Dict[str, Alert]] = defaultdict(dict)
-        self._lock = threading.Lock()
+        self._lock = threading.RLock()
 
     def add_alert_rule(
         self,
@@ -706,7 +706,7 @@ class DashboardManager:
         self.dashboards: Dict[str, Dashboard] = {}
         self.tenant_dashboards: Dict[str, Dict[str, Dashboard]] = defaultdict(dict)
         self.default_dashboards: Dict[str, Dashboard] = {}
-        self._lock = threading.Lock()
+        self._lock = threading.RLock()
 
         # Create default dashboards
         self._create_default_dashboards()

moai_adk/core/rollback_manager.py

@@ -450,14 +450,21 @@ class RollbackManager:
             raise
 
     def _backup_configuration(self, rollback_dir: Path) -> str:
-        """Backup configuration files"""
+        """Backup configuration files (both legacy and section-based)"""
         config_backup_path = rollback_dir / "config"
         config_backup_path.mkdir(parents=True, exist_ok=True)
 
-        # Backup .moai/config/config.json
-        config_file = self.project_root / ".moai" / "config" / "config.json"
-        if config_file.exists():
-            shutil.copy2(config_file, config_backup_path / "config.json")
+        # Backup legacy monolithic config files
+        for config_name in ["config.json", "config.yaml"]:
+            config_file = self.project_root / ".moai" / "config" / config_name
+            if config_file.exists():
+                shutil.copy2(config_file, config_backup_path / config_name)
+
+        # Backup section-based config directory
+        sections_dir = self.project_root / ".moai" / "config" / "sections"
+        if sections_dir.exists():
+            sections_backup_path = config_backup_path / "sections"
+            shutil.copytree(sections_dir, sections_backup_path, dirs_exist_ok=True)
 
         # Backup .claude/settings.json
         settings_file = self.project_root / ".claude" / "settings.json"
@@ -541,15 +548,18 @@ class RollbackManager:
             if current_checksum != rollback_point.checksum:
                 warnings.append("Backup checksum mismatch - possible corruption")
 
-            # Check essential files exist
-            required_files = [
-                backup_path / "config" / "config.json",
-                backup_path / "research",
-            ]
+            # Check essential files exist (check for either legacy or section-based config)
+            config_exists = (
+                (backup_path / "config" / "config.json").exists()
+                or (backup_path / "config" / "config.yaml").exists()
+                or (backup_path / "config" / "sections").exists()
+            )
+
+            if not config_exists:
+                warnings.append("No configuration backup found (expected config.json, config.yaml, or sections/)")
 
-            missing_files = [f for f in required_files if not f.exists()]
-            if missing_files:
-                warnings.append(f"Missing backup files: {missing_files}")
+            if not (backup_path / "research").exists():
+                warnings.append("Missing research component backup")
 
         except Exception as e:
             validation_result["valid"] = False
@@ -677,18 +687,35 @@ class RollbackManager:
         }
 
         try:
-            # Validate configuration
-            config_file = self.project_root / ".moai" / "config" / "config.json"
-            if config_file.exists():
+            # Validate configuration (check for both legacy and section-based)
+            config_json = self.project_root / ".moai" / "config" / "config.json"
+            config_yaml = self.project_root / ".moai" / "config" / "config.yaml"
+            sections_dir = self.project_root / ".moai" / "config" / "sections"
+
+            config_found = False
+
+            # Validate legacy JSON config
+            if config_json.exists():
+                config_found = True
                 try:
-                    with open(config_file, "r", encoding="utf-8") as f:
+                    with open(config_json, "r", encoding="utf-8") as f:
                         json.load(f)  # Validate JSON syntax
                 except json.JSONDecodeError:
                     validation_results["config_valid"] = False
                     issues.append("Invalid JSON in config.json")
-            else:
+
+            # Validate legacy YAML config
+            if config_yaml.exists():
+                config_found = True
+                # YAML validation would require PyYAML, skip for now
+
+            # Check for section-based config
+            if sections_dir.exists() and sections_dir.is_dir():
+                config_found = True
+
+            if not config_found:
                 validation_results["config_valid"] = False
-                issues.append("config.json not found")
+                issues.append("No configuration found (expected config.json, config.yaml, or sections/)")
 
             # Validate research components
             for research_dir in self.research_dirs:

moai_adk/core/template/backup.py

@@ -43,7 +43,8 @@ class TemplateBackup:
         Returns:
             True when any tracked file exists.
         """
-        return any((self.target_path / item).exists() for item in [".moai", ".claude", ".github", "CLAUDE.md"])
+        tracked_items = [".moai", ".claude", ".github", "CLAUDE.md", ".mcp.json", ".lsp.json", ".git-hooks"]
+        return any((self.target_path / item).exists() for item in tracked_items)
 
     def create_backup(self) -> Path:
         """Create a timestamped backup under .moai-backups/.
@@ -61,7 +62,7 @@ class TemplateBackup:
         backup_path.mkdir(parents=True, exist_ok=True)
 
         # Copy backup targets
-        for item in [".moai", ".claude", ".github", "CLAUDE.md"]:
+        for item in [".moai", ".claude", ".github", "CLAUDE.md", ".mcp.json", ".lsp.json", ".git-hooks"]:
             src = self.target_path / item
             if not src.exists():
                 continue
@@ -152,7 +153,7 @@ class TemplateBackup:
             raise FileNotFoundError(f"Backup not found: {backup_path}")
 
         # Restore each item from backup
-        for item in [".moai", ".claude", ".github", "CLAUDE.md"]:
+        for item in [".moai", ".claude", ".github", "CLAUDE.md", ".mcp.json", ".lsp.json", ".git-hooks"]:
             src = backup_path / item
             dst = self.target_path / item
 

moai_adk/core/template/config.py

@@ -1,13 +1,29 @@
-"""Configuration Manager (Migrated to Unified Config)
+"""Configuration Manager (Migrated to Unified Config).
 
-DEPRECATED: This module is maintained for backward compatibility.
-New code should use: moai_adk.core.config.unified.UnifiedConfigManager
+⚠️ DEPRECATED: This module is deprecated and will be removed in a future version.
 
-Manage .moai/config/config.json:
-- Read and write configuration files
-- Support deep merges
-- Preserve UTF-8 content
-- Create directories automatically
+New code should use: from moai_adk.core.config.unified import UnifiedConfigManager, get_unified_config
+
+Migration Guide:
+    OLD:
+        >>> from moai_adk.core.template.config import ConfigManager
+        >>> config = ConfigManager()
+
+    NEW:
+        >>> from moai_adk.core.config.unified import UnifiedConfigManager
+        >>> config = UnifiedConfigManager()
+        >>> data = config.get_all()
+
+Configuration sources (in priority order):
+    1. Section YAML files: .moai/config/sections/*.yaml (new approach)
+       - language.yaml: Language settings
+       - user.yaml: User settings
+       - project.yaml: Project metadata
+       - system.yaml: MoAI system settings
+       - git-strategy.yaml: Git workflow settings
+       - quality.yaml: Quality and TDD settings
+    2. Monolithic config.yaml: .moai/config/config.yaml (legacy)
+    3. Monolithic config.json: .moai/config/config.json (legacy fallback)
 
 Migration Path:
     OLD:
@@ -19,6 +35,10 @@ Migration Path:
         >>> from moai_adk.core.config.unified import get_unified_config
         >>> config = get_unified_config()
         >>> data = config.get_all()
+
+Status: Deprecated - Maintained for backward compatibility only
+Removal Target: v10.0.0
+Last Updated: 2026-01-06
 """
 
 import json
@@ -36,10 +56,14 @@ except ImportError:
 
 class ConfigManager:
     """
-    Read and write .moai/config/config.json.
+    Read and write MoAI configuration.
 
     DEPRECATED: Use moai_adk.core.config.unified.UnifiedConfigManager instead.
     This class is now a thin wrapper around UnifiedConfigManager for backward compatibility.
+
+    Supports both:
+    - New: Section YAML files (.moai/config/sections/*.yaml)
+    - Legacy: Monolithic config.json (.moai/config/config.json)
     """
 
     DEFAULT_CONFIG = {"mode": "personal", "locale": "ko", "moai": {"version": "0.3.0"}}

moai_adk/core/template/merger.py

@@ -93,7 +93,11 @@ class TemplateMerger:
         existing_path.write_text("\n".join(merged_lines) + "\n", encoding="utf-8")
 
     def merge_config(self, detected_language: str | None = None) -> dict[str, str]:
-        """Smart merge for config.json.
+        """Smart merge for configuration using section YAML files with JSON fallback.
+
+        Supports both:
+        - New: Section YAML files (.moai/config/sections/*.yaml)
+        - Legacy: Monolithic config.json (.moai/config/config.json)
 
         Rules:
         - Prefer existing settings.
@@ -105,19 +109,41 @@ class TemplateMerger:
         Returns:
             Merged configuration dictionary.
         """
-        config_path = self.target_path / ".moai" / "config" / "config.json"
+        try:
+            import yaml
+
+            yaml_available = True
+        except ImportError:
+            yaml_available = False
 
-        # Load existing config if present
+        # Check for section-based YAML configuration first (new approach)
+        sections_dir = self.target_path / ".moai" / "config" / "sections"
         existing_config: dict[str, Any] = {}
-        if config_path.exists():
-            with open(config_path, encoding="utf-8") as f:
-                existing_config = json.load(f)
+
+        if yaml_available and sections_dir.exists() and sections_dir.is_dir():
+            # Load from section YAML files
+            for section_file in sections_dir.glob("*.yaml"):
+                try:
+                    with open(section_file, "r", encoding="utf-8") as f:
+                        section_data = yaml.safe_load(f) or {}
+                        existing_config.update(section_data)
+                except Exception:
+                    pass  # Skip unreadable section files
+        else:
+            # Fallback to legacy config.json
+            config_path = self.target_path / ".moai" / "config" / "config.json"
+            if config_path.exists():
+                with open(config_path, encoding="utf-8") as f:
+                    existing_config = json.load(f)
+
+        # Extract project-related settings from nested structure
+        project_config = existing_config.get("project", {})
 
         # Build new config while preferring existing values
         new_config: dict[str, str] = {
-            "projectName": existing_config.get("projectName", self.target_path.name),
+            "projectName": project_config.get("name", existing_config.get("projectName", self.target_path.name)),
             "mode": existing_config.get("mode", "personal"),
-            "locale": existing_config.get("locale", "ko"),
+            "locale": project_config.get("locale", existing_config.get("locale", "ko")),
             "language": existing_config.get("language", detected_language or "generic"),
         }
 

moai_adk/core/template/processor.py

@@ -85,7 +85,8 @@ class TemplateProcessor:
         ".moai/specs/",  # User SPEC documents
         ".moai/reports/",  # User reports
         ".moai/project/",  # User project documents (product/structure/tech.md)
-        # config.json is now FORCE OVERWRITTEN (backup in .moai-backups/)
+        ".moai/config/sections/",  # User configuration section files (YAML)
+        # config.json/config.yaml is now FORCE OVERWRITTEN (backup in .moai-backups/)
         # Merge via /moai:0-project when optimized=false
     ]
 
@@ -107,6 +108,7 @@ class TemplateProcessor:
         "MOAI_VERSION_SOURCE": "Version source information",
         "MOAI_VERSION_CACHE_AGE": "Cache age for debugging",
         "CREATION_TIMESTAMP": "Project creation timestamp",
+        "STATUSLINE_COMMAND": "Cross-platform statusline command (OS-specific)",
     }
 
     def __init__(self, target_path: Path, config: Optional[TemplateProcessorConfig] = None) -> None:
@@ -800,7 +802,7 @@ class TemplateProcessor:
             "output-styles/moai",
             "agents/alfred",
             "agents/moai",
-            "skills",  # NEW: Complete replacement for skills folder
+            # NOTE: "skills" handled by _sync_skills_selective() to preserve custom skills
         ]
 
         # 1. Copy Alfred and Moai folders wholesale (backup before delete & overwrite)
@@ -847,6 +849,9 @@ class TemplateProcessor:
                 if not silent:
                     console.print(f"   ✅ .claude/{rel_subdir}/ copied")
 
+        # 1.6 Sync skills selectively (preserve custom skills, update moai-* skills)
+        self._sync_skills_selective(src, dst, silent)
+
         # 2. Copy other files/folders individually (smart merge for settings.json and config.json)
         all_warnings = []
         for item in src.iterdir():
@@ -854,11 +859,13 @@ class TemplateProcessor:
             dst_item = dst / rel_path
 
             # Skip Alfred parent folders (already handled above)
+            # Also skip "skills" - handled by _sync_skills_selective()
             if item.is_dir() and item.name in [
                 "hooks",
                 "commands",
                 "output-styles",
                 "agents",
+                "skills",  # Handled by _sync_skills_selective() to preserve custom skills
             ]:
                 continue
 
@@ -896,6 +903,54 @@ class TemplateProcessor:
         if not silent:
             console.print("   ✅ .claude/ copy complete (variables substituted)")
 
+    def _sync_skills_selective(self, src: Path, dst: Path, silent: bool = False) -> None:
+        """Sync only moai-* template skills, preserve custom skills.
+
+        This method ensures that:
+        - Template skills (moai-* prefix) are updated from source
+        - Custom skills (any other prefix) are preserved untouched
+
+        Args:
+            src: Source .claude directory from template
+            dst: Destination .claude directory in project
+            silent: Suppress console output if True
+        """
+        skills_src = src / "skills"
+        skills_dst = dst / "skills"
+
+        if not skills_src.exists():
+            return
+
+        skills_dst.mkdir(parents=True, exist_ok=True)
+
+        # Step 1: Identify template skills in source (moai-* prefix)
+        template_skills = {d.name for d in skills_src.iterdir() if d.is_dir() and d.name.startswith("moai-")}
+
+        # Step 2: Delete only template skills in destination
+        if skills_dst.exists():
+            for skill_dir in list(skills_dst.iterdir()):
+                if skill_dir.is_dir() and skill_dir.name.startswith("moai-"):
+                    shutil.rmtree(skill_dir)
+                    if not silent:
+                        console.print(f"   [dim]Updating template skill: {skill_dir.name}[/dim]")
+
+        # Step 3: Copy template skills from source
+        for skill_name in sorted(template_skills):
+            src_skill = skills_src / skill_name
+            dst_skill = skills_dst / skill_name
+            shutil.copytree(src_skill, dst_skill)
+
+        if not silent and template_skills:
+            console.print(f"   ✅ Synced {len(template_skills)} template skill(s)")
+
+        # Step 4: Report preserved custom skills
+        if skills_dst.exists():
+            custom_skills = [d.name for d in skills_dst.iterdir() if d.is_dir() and not d.name.startswith("moai-")]
+            if custom_skills and not silent:
+                preview = ", ".join(sorted(custom_skills)[:3])
+                suffix = "..." if len(custom_skills) > 3 else ""
+                console.print(f"   ✅ Preserved {len(custom_skills)} custom skill(s): {preview}{suffix}")
+
     def _copy_moai(self, silent: bool = False) -> None:
         """.moai/ directory copy with variable substitution (excludes protected paths)."""
         src = self.template_root / ".moai"
@@ -906,11 +961,11 @@ class TemplateProcessor:
                 console.print("⚠️ .moai/ template not found")
             return
 
-        # Paths excluded from template copying (specs/, reports/, .moai/config/config.json)
+        # Paths excluded from template copying (specs/, reports/, sections/)
         template_protected_paths = [
             "specs",
             "reports",
-            ".moai/config/config.json",
+            "config/sections",  # User section YAML files
         ]
 
         all_warnings = []
@@ -1015,14 +1070,34 @@ class TemplateProcessor:
         self.merger.merge_settings_json(src, dst, backup_path)
 
     def _merge_config_json(self, src: Path, dst: Path) -> None:
-        """Smart merge for config.json using LanguageConfigResolver priority system.
+        """Smart merge for config using section YAML files with JSON fallback.
+
+        Supports both new section-based YAML files and legacy config.json.
+        Priority: Section YAML files > config.json fallback
 
         Args:
-            src: Template config.json.
-            dst: Project config.json.
+            src: Template config file (config.json for legacy projects).
+            dst: Project config file destination.
         """
         import json
+        import os
+
+        try:
+            import yaml  # noqa: F401
 
+            yaml_available = True
+        except ImportError:
+            yaml_available = False
+
+        # Check for section-based YAML configuration (new approach)
+        sections_dir = self.target_path / ".moai" / "config" / "sections"
+
+        if yaml_available and sections_dir.exists() and sections_dir.is_dir():
+            # Use section YAML files - merge each section individually
+            self._merge_section_yaml_files(sections_dir)
+            return
+
+        # Fallback to legacy config.json merging
         # Load template config
         try:
             template_config = json.loads(src.read_text(encoding="utf-8"))
@@ -1071,8 +1146,6 @@ class TemplateProcessor:
                         merged_config[key] = value
 
             # Apply environment variables (highest priority)
-            import os
-
             env_mappings = {
                 "MOAI_USER_NAME": ("user", "name"),
                 "MOAI_CONVERSATION_LANG": ("language", "conversation_language"),
@@ -1119,6 +1192,68 @@ class TemplateProcessor:
             )
             console.print("   ⚠️ Warning: Using simple merge (LanguageConfigResolver not available)")
 
+    def _merge_section_yaml_files(self, sections_dir: Path) -> None:
+        """Merge section YAML files with user-specific values preserved.
+
+        Args:
+            sections_dir: Path to sections directory (.moai/config/sections/)
+        """
+        import os
+
+        try:
+            import yaml
+        except ImportError:
+            console.print("⚠️ Warning: PyYAML not available, skipping section merge")
+            return
+
+        # Environment variable mappings for each section
+        env_mappings = {
+            "language.yaml": {
+                "MOAI_CONVERSATION_LANG": ["language", "conversation_language"],
+                "MOAI_AGENT_PROMPT_LANG": ["language", "agent_prompt_language"],
+                "MOAI_CONVERSATION_LANG_NAME": ["language", "conversation_language_name"],
+                "MOAI_GIT_COMMIT_MESSAGES_LANG": ["language", "git_commit_messages"],
+                "MOAI_CODE_COMMENTS_LANG": ["language", "code_comments"],
+                "MOAI_DOCUMENTATION_LANG": ["language", "documentation"],
+                "MOAI_ERROR_MESSAGES_LANG": ["language", "error_messages"],
+            },
+            "user.yaml": {
+                "MOAI_USER_NAME": ["user", "name"],
+            },
+        }
+
+        for section_file in sections_dir.glob("*.yaml"):
+            try:
+                # Read existing section content
+                with open(section_file, "r", encoding="utf-8") as f:
+                    section_data = yaml.safe_load(f) or {}
+
+                # Apply environment variable overrides if applicable
+                if section_file.name in env_mappings:
+                    for env_var, path in env_mappings[section_file.name].items():
+                        env_value = os.getenv(env_var)
+                        if env_value:
+                            # Navigate to the correct nested location
+                            current = section_data
+                            for key in path[:-1]:
+                                if key not in current:
+                                    current[key] = {}
+                                current = current[key]
+                            current[path[-1]] = env_value
+
+                # Write back if environment variables were applied
+                with open(section_file, "w", encoding="utf-8") as f:
+                    yaml.safe_dump(
+                        section_data,
+                        f,
+                        default_flow_style=False,
+                        allow_unicode=True,
+                        sort_keys=False,
+                    )
+
+            except Exception as e:
+                console.print(f"⚠️ Warning: Failed to merge {section_file.name}: {e}")
+
     def _copy_gitignore(self, silent: bool = False) -> None:
         """.gitignore copy (optional)."""
         src = self.template_root / ".gitignore"

moai_adk/core/template_engine.py

@@ -209,7 +209,16 @@ class TemplateEngine:
         Extract template variables from project configuration.
 
         Args:
-            config: Project configuration dictionary (from .moai/config/config.json)
+            config: Project configuration dictionary (from section YAML files
+                   or legacy .moai/config/config.json)
+
+        Configuration sources (in priority order):
+        1. Section YAML files: .moai/config/sections/*.yaml
+           - project.yaml: Project settings (name, description, owner)
+           - language.yaml: Language settings
+           - user.yaml: User settings
+           - system.yaml: MoAI/GitHub settings
+        2. Legacy: .moai/config/config.json
 
         Returns:
             Dictionary of template variables

moai_adk/core/template_variable_synchronizer.py

@@ -41,7 +41,8 @@ class TemplateVariableSynchronizer:
     TEMPLATE_TRACKING_PATTERNS = [
         ".claude/settings.json",
         ".claude/settings.local.json",
-        ".moai/config/config.json",
+        ".moai/config/sections/*.yaml",  # Section YAML files (new)
+        ".moai/config/config.json",  # Legacy config.json (fallback)
         ".claude/output-styles/**/*.md",
         ".claude/hooks/**/*.py",
         ".claude/commands/**/*.md",
@@ -126,12 +127,25 @@ class TemplateVariableSynchronizer:
         # If a specific config file changed, prioritize files that depend on it
         if changed_config_path:
             dependency_map = {
+                # Section YAML file dependencies (new approach)
+                ".moai/config/sections/language.yaml": [
+                    ".claude/settings.json",
+                    ".claude/settings.local.json",
+                    ".claude/output-styles",
+                    ".claude/hooks",
+                ],
+                ".moai/config/sections/user.yaml": [
+                    ".claude/settings.json",
+                    ".claude/settings.local.json",
+                    ".claude/output-styles",
+                ],
+                # Legacy config.json dependencies (fallback)
                 ".moai/config/config.json": [
                     ".claude/settings.json",
                     ".claude/settings.local.json",
                     ".claude/output-styles",
                     ".claude/hooks",
-                ]
+                ],
             }
 
             config_key = str(changed_config_path.relative_to(self.project_root))