moai-adk 0.34.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

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)
 
@@ -175,6 +120,8 @@ class ProjectInitializer:
         backup_enabled: bool = True,
         progress_callback: ProgressCallback | None = None,
         reinit: bool = False,
+        tag_enabled: bool = True,  # NEW - SPEC-TAG-002
+        tag_mode: str = "warn",  # NEW - SPEC-TAG-002
     ) -> InstallationResult:
         """Execute project initialization (5-phase process)
 
@@ -186,6 +133,8 @@ class ProjectInitializer:
             backup_enabled: Whether to enable backup
             progress_callback: Progress callback
             reinit: Reinitialization mode (v0.3.0, SPEC-INIT-003)
+            tag_enabled: Enable TAG validation - Default: True (TDD recommended) - NEW - SPEC-TAG-002
+            tag_mode: TAG validation mode (warn|enforce|off) - Default: warn - NEW - SPEC-TAG-002
 
         Returns:
             InstallationResult object
@@ -213,12 +162,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 +217,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,
@@ -288,6 +239,15 @@ class ProjectInitializer:
                     "enforce_tdd": True,
                     "test_coverage_target": 85,
                 },
+                # TAG System v2.0 Configuration (NEW - SPEC-TAG-002)
+                "quality": {
+                    "tag_validation": {
+                        "enabled": tag_enabled,  # From user prompt (Q7.1)
+                        "mode": tag_mode,  # From user prompt (Q7.2)
+                        "check_spec_exists": True,
+                        "max_tags_per_file": 100,
+                    },
+                },
                 "git_strategy": {
                     "personal": {
                         "auto_checkpoint": "disabled",
@@ -331,10 +291,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
@@ -346,7 +303,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,103 @@ 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}")
+
+        # Update quality.yaml with TAG settings (NEW - SPEC-TAG-002)
+        quality_yaml = sections_dir / "quality.yaml"
+        if quality_yaml.exists() and "quality" in config:
+            quality_config = config["quality"]
+            if "tag_validation" in quality_config:
+                tag_config = quality_config["tag_validation"]
+                self._update_section_yaml(
+                    quality_yaml,
+                    {
+                        "tag_validation.enabled": tag_config.get("enabled", True),
+                        "tag_validation.mode": tag_config.get("mode", "warn"),
+                    },
+                )
+                updated_files.append(str(quality_yaml))
+                logger.debug(f"Updated {quality_yaml} with TAG settings")
+
+        logger.info(f"Updated {len(updated_files)} section configuration files")
+        return updated_files
+
+    def _update_section_yaml(self, yaml_path: Path, updates: dict[str, str]) -> None:
+        """
+        Update specific values in a YAML section file.
 
-        # Enhanced config merging with comprehensive version preservation
-        merged_config = self._merge_configuration_preserving_versions(config, 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
 
-        # Enhanced version handling using VersionReader for consistency
         try:
-            version_reader = self._get_version_reader()
-            current_config_version = version_reader.get_version()
+            with open(yaml_path, "r", encoding="utf-8") as f:
+                content = yaml.safe_load(f) or {}
 
-            # Ensure version consistency across the merged config
-            self._ensure_version_consistency(merged_config, current_config_version, existing_config)
+            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
 
-            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__
+            with open(yaml_path, "w", encoding="utf-8") as f:
+                yaml.dump(content, f, default_flow_style=False, allow_unicode=True, sort_keys=False)
 
-        # Write final config with enhanced formatting
-        self._write_configuration_file(config_path, merged_config)
-        logger.info(f"Configuration file written to {config_path}")
-
-        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]

moai_adk/core/project/validator.py

@@ -32,8 +32,9 @@ class ProjectValidator:
     ]
 
     # Required files
+    # Note: .moai/config/config.yaml is no longer required (replaced by section-based YAML files)
+    # Section files are now in .moai/config/sections/ and are validated separately
     REQUIRED_FILES = [
-        ".moai/config/config.yaml",
         "CLAUDE.md",
     ]
 
@@ -115,6 +116,20 @@ class ProjectValidator:
             missing_list = ", ".join(missing_commands)
             raise ValidationError(f"Required Alfred command files not found: {missing_list}")
 
+        # Verify required section files (section-based configuration replaces config.yaml)
+        sections_dir = project_path / ".moai" / "config" / "sections"
+        if sections_dir.exists():
+            required_sections = ["system.yaml", "language.yaml", "user.yaml", "project.yaml"]
+            missing_sections = []
+            for section in required_sections:
+                section_path = sections_dir / section
+                if not section_path.exists():
+                    missing_sections.append(section)
+
+            if missing_sections:
+                missing_list = ", ".join(missing_sections)
+                raise ValidationError(f"Required section files not found: {missing_list}")
+
     def _is_inside_moai_package(self, project_path: Path) -> bool:
         """Determine whether the path is inside the MoAI-ADK package.
 

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/rollback_manager.py

@@ -450,24 +450,39 @@ 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")
+        # Skip backing up actual project files during pytest execution
+        # to prevent modification of user's working directory
+        is_pytest_env = os.getenv("PYTEST_CURRENT_TEST") is not None
+
+        # 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"
-        if settings_file.exists():
-            shutil.copy2(settings_file, config_backup_path / "settings.json")
+        # Skip during pytest to prevent creating .backup files in user's project
+        if not is_pytest_env:
+            settings_file = self.project_root / ".claude" / "settings.json"
+            if settings_file.exists():
+                shutil.copy2(settings_file, config_backup_path / "settings.json")
 
         # Backup .claude/settings.local.json
-        local_settings_file = self.project_root / ".claude" / "settings.local.json"
-        if local_settings_file.exists():
-            shutil.copy2(local_settings_file, config_backup_path / "settings.local.json")
+        # Skip during pytest to prevent creating .backup files in user's project
+        if not is_pytest_env:
+            local_settings_file = self.project_root / ".claude" / "settings.local.json"
+            if local_settings_file.exists():
+                shutil.copy2(local_settings_file, config_backup_path / "settings.local.json")
 
         return str(config_backup_path)
 
@@ -541,15 +556,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 +695,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: