moai-adk 0.25.4__py3-none-any.whl → 0.41.0__py3-none-any.whl

moai_adk/core/rollback_manager.py

@@ -224,9 +224,7 @@ class RollbackManager:
                 restored_files=[],
             )
 
-    def rollback_research_integration(
-        self, component_type: str = None, component_name: str = None
-    ) -> RollbackResult:
+    def rollback_research_integration(self, component_type: str = None, component_name: str = None) -> RollbackResult:
         """
         Specialized rollback for research integration changes
 
@@ -237,15 +235,11 @@ class RollbackManager:
         Returns:
             RollbackResult with operation details
         """
-        logger.info(
-            f"Rolling back research integration: {component_type}:{component_name}"
-        )
+        logger.info(f"Rolling back research integration: {component_type}:{component_name}")
 
         try:
             # Find relevant rollback points for research integration
-            research_rollback_points = self._find_research_rollback_points(
-                component_type, component_name
-            )
+            research_rollback_points = self._find_research_rollback_points(component_type, component_name)
 
             if not research_rollback_points:
                 return RollbackResult(
@@ -256,9 +250,7 @@ class RollbackManager:
                 )
 
             # Use the most recent suitable rollback point
-            latest_rollback = max(
-                research_rollback_points, key=lambda x: x["timestamp"]
-            )
+            latest_rollback = max(research_rollback_points, key=lambda x: x["timestamp"])
 
             # Perform targeted rollback
             restored_files, failed_files = self._perform_research_rollback(
@@ -273,7 +265,8 @@ class RollbackManager:
             return RollbackResult(
                 success=success,
                 rollback_point_id=latest_rollback["id"],
-                message=f"Research integration rollback {'completed successfully' if success else 'completed with errors'}",
+                message=f"Research integration rollback "
+                f"{'completed successfully' if success else 'completed with errors'}",
                 restored_files=restored_files,
                 failed_files=failed_files or [],
                 validation_results=validation_results,
@@ -322,10 +315,12 @@ class RollbackManager:
         Returns:
             Validation results with system health information
         """
+        issues: List[str] = []
+        recommendations: List[str] = []
         validation_results = {
             "system_healthy": True,
-            "issues": [],
-            "recommendations": [],
+            "issues": issues,
+            "recommendations": recommendations,
             "rollback_points_count": len(self.registry),
             "backup_size": self._calculate_backup_size(),
             "last_rollback": None,
@@ -342,48 +337,38 @@ class RollbackManager:
 
             for dir_path in required_dirs:
                 if not dir_path.exists():
-                    validation_results["issues"].append(
-                        f"Missing backup directory: {dir_path}"
-                    )
+                    issues.append(f"Missing backup directory: {dir_path}")
                     validation_results["system_healthy"] = False
 
             # Validate rollback points
-            invalid_rollback_points = []
+            invalid_rollback_points: List[str] = []
             for rollback_id, rollback_data in self.registry.items():
                 backup_path = Path(rollback_data["backup_path"])
                 if not backup_path.exists():
                     invalid_rollback_points.append(rollback_id)
 
             if invalid_rollback_points:
-                validation_results["issues"].append(
-                    f"Invalid rollback points: {invalid_rollback_points}"
-                )
+                issues.append(f"Invalid rollback points: {invalid_rollback_points}")
                 validation_results["system_healthy"] = False
 
             # Check available disk space
-            backup_size = validation_results["backup_size"]
+            backup_size: int = validation_results["backup_size"]  # type: ignore[assignment]
             free_space = shutil.disk_usage(self.backup_root).free
             if backup_size > free_space * 0.8:  # Using more than 80% of free space
-                validation_results["recommendations"].append(
-                    "Consider cleaning up old rollback points"
-                )
+                recommendations.append("Consider cleaning up old rollback points")
 
             # Check last rollback
             if self.registry:
-                last_rollback = max(
-                    self.registry.values(), key=lambda x: x["timestamp"]
-                )
+                last_rollback = max(self.registry.values(), key=lambda x: x["timestamp"])
                 validation_results["last_rollback"] = last_rollback["timestamp"]
 
         except Exception as e:
             validation_results["system_healthy"] = False
-            validation_results["issues"].append(f"Validation error: {str(e)}")
+            issues.append(f"Validation error: {str(e)}")
 
         return validation_results
 
-    def cleanup_old_rollbacks(
-        self, keep_count: int = 10, dry_run: bool = True
-    ) -> Dict[str, Any]:
+    def cleanup_old_rollbacks(self, keep_count: int = 10, dry_run: bool = True) -> Dict[str, Any]:
         """
         Clean up old rollback points
 
@@ -406,10 +391,7 @@ class RollbackManager:
                 "dry_run": True,
                 "would_delete_count": len(to_delete),
                 "would_keep_count": len(to_keep),
-                "would_free_space": sum(
-                    self._get_directory_size(Path(rp["backup_path"]))
-                    for rp in to_delete
-                ),
+                "would_free_space": sum(self._get_directory_size(Path(rp["backup_path"])) for rp in to_delete),
             }
 
         # Perform actual cleanup
@@ -429,9 +411,7 @@ class RollbackManager:
                 deleted_count += 1
 
             except Exception as e:
-                logger.warning(
-                    f"Failed to delete rollback point {rollback_point['id']}: {str(e)}"
-                )
+                logger.warning(f"Failed to delete rollback point {rollback_point['id']}: {str(e)}")
 
         # Save updated registry
         self._save_registry()
@@ -446,14 +426,14 @@ class RollbackManager:
     def _generate_rollback_id(self) -> str:
         """Generate unique rollback point ID"""
         timestamp = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
-        random_suffix = hashlib.md5(os.urandom(4)).hexdigest()[:8]
+        random_suffix = hashlib.md5(os.urandom(4), usedforsecurity=False).hexdigest()[:8]
         return f"rollback_{timestamp}_{random_suffix}"
 
     def _load_registry(self) -> Dict[str, Any]:
         """Load rollback registry from file"""
         if self.registry_file.exists():
             try:
-                with open(self.registry_file, "r") as f:
+                with open(self.registry_file, "r", encoding="utf-8") as f:
                     return json.load(f)
             except Exception as e:
                 logger.warning(f"Failed to load rollback registry: {str(e)}")
@@ -463,21 +443,28 @@ class RollbackManager:
     def _save_registry(self):
         """Save rollback registry to file"""
         try:
-            with open(self.registry_file, "w") as f:
-                json.dump(self.registry, f, indent=2, default=str)
+            with open(self.registry_file, "w", encoding="utf-8") as f:
+                json.dump(self.registry, f, indent=2, default=str, ensure_ascii=False)
         except Exception as e:
             logger.error(f"Failed to save rollback registry: {str(e)}")
             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"
@@ -487,9 +474,7 @@ class RollbackManager:
         # 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"
-            )
+            shutil.copy2(local_settings_file, config_backup_path / "settings.local.json")
 
         return str(config_backup_path)
 
@@ -537,18 +522,17 @@ class RollbackManager:
                 with open(file_path, "rb") as f:
                     # Update hash with file content and path
                     checksum_hash.update(f.read())
-                    checksum_hash.update(
-                        str(file_path.relative_to(backup_dir)).encode()
-                    )
+                    checksum_hash.update(str(file_path.relative_to(backup_dir)).encode())
 
         return checksum_hash.hexdigest()
 
     def _validate_rollback_point(self, rollback_point: RollbackPoint) -> Dict[str, Any]:
         """Validate rollback point before restoration"""
+        warnings: List[str] = []
         validation_result = {
             "valid": True,
             "message": "Rollback point is valid",
-            "warnings": [],
+            "warnings": warnings,
         }
 
         try:
@@ -562,21 +546,20 @@ class RollbackManager:
             # Verify checksum
             current_checksum = self._calculate_backup_checksum(backup_path)
             if current_checksum != rollback_point.checksum:
-                validation_result["warnings"].append(
-                    "Backup checksum mismatch - possible corruption"
-                )
+                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()
+            )
 
-            missing_files = [f for f in required_files if not f.exists()]
-            if missing_files:
-                validation_result["warnings"].append(
-                    f"Missing backup files: {missing_files}"
-                )
+            if not config_exists:
+                warnings.append("No configuration backup found (expected config.json, config.yaml, or sections/)")
+
+            if not (backup_path / "research").exists():
+                warnings.append("Missing research component backup")
 
         except Exception as e:
             validation_result["valid"] = False
@@ -584,13 +567,11 @@ class RollbackManager:
 
         return validation_result
 
-    def _perform_rollback(
-        self, rollback_point: RollbackPoint
-    ) -> Tuple[List[str], List[str]]:
+    def _perform_rollback(self, rollback_point: RollbackPoint) -> Tuple[List[str], List[str]]:
         """Perform the actual rollback operation"""
         backup_path = Path(rollback_point.backup_path)
-        restored_files = []
-        failed_files = []
+        restored_files: List[str] = []
+        failed_files: List[str] = []
 
         try:
             # Restore configuration
@@ -598,51 +579,43 @@ class RollbackManager:
             if config_backup.exists():
                 for config_file in config_backup.rglob("*"):
                     if config_file.is_file():
-                        target_path = (
-                            self.project_root
-                            / ".moai"
-                            / config_file.relative_to(config_backup)
-                        )
+                        target_path = self.project_root / ".moai" / config_file.relative_to(config_backup)
                         target_path.parent.mkdir(parents=True, exist_ok=True)
                         try:
                             shutil.copy2(config_file, target_path)
                             restored_files.append(str(target_path))
                         except Exception as e:
-                            failed_files.append((str(target_path), str(e)))
+                            failed_files.append(f"{target_path}: {str(e)}")
 
             # Restore research components
             research_backup = backup_path / "research"
             if research_backup.exists():
                 for research_file in research_backup.rglob("*"):
                     if research_file.is_file():
-                        target_path = self.project_root / research_file.relative_to(
-                            research_backup
-                        )
+                        target_path = self.project_root / research_file.relative_to(research_backup)
                         target_path.parent.mkdir(parents=True, exist_ok=True)
                         try:
                             shutil.copy2(research_file, target_path)
                             restored_files.append(str(target_path))
                         except Exception as e:
-                            failed_files.append((str(target_path), str(e)))
+                            failed_files.append(f"{target_path}: {str(e)}")
 
             # Restore code files
             code_backup = backup_path / "code"
             if code_backup.exists():
                 for code_file in code_backup.rglob("*"):
                     if code_file.is_file():
-                        target_path = self.project_root / code_file.relative_to(
-                            code_backup
-                        )
+                        target_path = self.project_root / code_file.relative_to(code_backup)
                         target_path.parent.mkdir(parents=True, exist_ok=True)
                         try:
                             shutil.copy2(code_file, target_path)
                             restored_files.append(str(target_path))
                         except Exception as e:
-                            failed_files.append((str(target_path), str(e)))
+                            failed_files.append(f"{target_path}: {str(e)}")
 
         except Exception as e:
             logger.error(f"Rollback operation failed: {str(e)}")
-            failed_files.append(("rollback_operation", str(e)))
+            failed_files.append(f"rollback_operation: {str(e)}")
 
         return restored_files, failed_files
 
@@ -656,11 +629,11 @@ class RollbackManager:
         backup_path = Path(rollback_point["backup_path"])
         research_backup = backup_path / "research"
 
-        restored_files = []
-        failed_files = []
+        restored_files: List[str] = []
+        failed_files: List[str] = []
 
         if not research_backup.exists():
-            failed_files.append(("research_backup", "Research backup not found"))
+            failed_files.append("research_backup: Research backup not found")
             return restored_files, failed_files
 
         try:
@@ -679,9 +652,7 @@ class RollbackManager:
                             shutil.copy2(component_file, target_file)
                             restored_files.append(str(target_file))
                         else:
-                            failed_files.append(
-                                (component_name, "Component file not found in backup")
-                            )
+                            failed_files.append(f"{component_name}: Component file not found in backup")
                     else:
                         # Restore entire component type
                         if target_dir.exists():
@@ -689,9 +660,7 @@ class RollbackManager:
                         shutil.copytree(component_backup_dir, target_dir)
                         restored_files.append(str(target_dir))
                 else:
-                    failed_files.append(
-                        (component_type, "Component type not found in backup")
-                    )
+                    failed_files.append(f"{component_type}: Component type not found in backup")
             else:
                 # Restore all research components
                 for research_dir in research_backup.iterdir():
@@ -704,31 +673,49 @@ class RollbackManager:
 
         except Exception as e:
             logger.error(f"Research rollback failed: {str(e)}")
-            failed_files.append(("research_rollback", str(e)))
+            failed_files.append(f"research_rollback: {str(e)}")
 
         return restored_files, failed_files
 
     def _validate_system_after_rollback(self) -> Dict[str, Any]:
         """Validate system state after rollback"""
+        issues: List[str] = []
         validation_results = {
             "config_valid": True,
             "research_valid": True,
-            "issues": [],
+            "issues": issues,
         }
 
         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") 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
-                    validation_results["issues"].append("Invalid JSON in config.json")
-            else:
+                    issues.append("Invalid JSON in config.json")
+
+            # 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
-                validation_results["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:
@@ -740,23 +727,22 @@ class RollbackManager:
                                 f.read()  # Validate file can be read
                         except Exception as e:
                             validation_results["research_valid"] = False
-                            validation_results["issues"].append(
-                                f"Cannot read {file_path}: {str(e)}"
-                            )
+                            issues.append(f"Cannot read {file_path}: {str(e)}")
 
         except Exception as e:
-            validation_results["issues"].append(f"Validation error: {str(e)}")
+            issues.append(f"Validation error: {str(e)}")
 
         return validation_results
 
     def _validate_research_components(self) -> Dict[str, Any]:
         """Validate research components after rollback"""
+        issues: List[str] = []
         validation_results = {
             "skills_valid": True,
             "agents_valid": True,
             "commands_valid": True,
             "hooks_valid": True,
-            "issues": [],
+            "issues": issues,
         }
 
         component_checks = [
@@ -772,9 +758,7 @@ class RollbackManager:
                 files = list(component_path.rglob("*.md"))
                 if not files:
                     validation_results[f"{component_key}_valid"] = False
-                    validation_results["issues"].append(
-                        f"{component_name} directory is empty"
-                    )
+                    issues.append(f"{component_name} directory is empty")
 
                 # Validate file content
                 for file_path in files[:5]:  # Check first 5 files
@@ -783,19 +767,13 @@ class RollbackManager:
                             content = f.read()
                             if not content.strip():
                                 validation_results[f"{component_key}_valid"] = False
-                                validation_results["issues"].append(
-                                    f"Empty file: {file_path}"
-                                )
+                                issues.append(f"Empty file: {file_path}")
                     except Exception as e:
                         validation_results[f"{component_key}_valid"] = False
-                        validation_results["issues"].append(
-                            f"Cannot read {file_path}: {str(e)}"
-                        )
+                        issues.append(f"Cannot read {file_path}: {str(e)}")
             else:
                 validation_results[f"{component_key}_valid"] = False
-                validation_results["issues"].append(
-                    f"{component_name} directory not found"
-                )
+                issues.append(f"{component_name} directory not found")
 
         return validation_results
 
@@ -833,9 +811,7 @@ class RollbackManager:
         """Mark rollback point as used in registry"""
         if rollback_id in self.registry:
             self.registry[rollback_id]["used"] = True
-            self.registry[rollback_id]["used_timestamp"] = datetime.now(
-                timezone.utc
-            ).isoformat()
+            self.registry[rollback_id]["used_timestamp"] = datetime.now(timezone.utc).isoformat()
             self._save_registry()
 
     def _cleanup_partial_backup(self, rollback_id: str):
@@ -883,37 +859,25 @@ def main():
 
     # List rollback points
     list_parser = subparsers.add_parser("list", help="List rollback points")
-    list_parser.add_argument(
-        "--limit", type=int, default=10, help="Maximum number to show"
-    )
+    list_parser.add_argument("--limit", type=int, default=10, help="Maximum number to show")
 
     # Perform rollback
     rollback_parser = subparsers.add_parser("rollback", help="Rollback to point")
     rollback_parser.add_argument("rollback_id", help="Rollback point ID")
-    rollback_parser.add_argument(
-        "--no-validate", action="store_true", help="Skip validation"
-    )
+    rollback_parser.add_argument("--no-validate", action="store_true", help="Skip validation")
 
     # Research rollback
-    research_parser = subparsers.add_parser(
-        "research-rollback", help="Rollback research components"
-    )
-    research_parser.add_argument(
-        "--type", help="Component type (skills, agents, commands, hooks)"
-    )
+    research_parser = subparsers.add_parser("research-rollback", help="Rollback research components")
+    research_parser.add_argument("--type", help="Component type (skills, agents, commands, hooks)")
     research_parser.add_argument("--name", help="Component name")
 
     # Validate system
-    validate_parser = subparsers.add_parser("validate", help="Validate rollback system")
+    subparsers.add_parser("validate", help="Validate rollback system")
 
     # Cleanup
-    cleanup_parser = subparsers.add_parser(
-        "cleanup", help="Cleanup old rollback points"
-    )
+    cleanup_parser = subparsers.add_parser("cleanup", help="Cleanup old rollback points")
     cleanup_parser.add_argument("--keep", type=int, default=10, help="Number to keep")
-    cleanup_parser.add_argument(
-        "--execute", action="store_true", help="Execute cleanup (default: dry run)"
-    )
+    cleanup_parser.add_argument("--execute", action="store_true", help="Execute cleanup (default: dry run)")
 
     args = parser.parse_args()
 
@@ -926,9 +890,7 @@ def main():
 
     try:
         if args.command == "create":
-            rollback_id = rollback_manager.create_rollback_point(
-                args.description, args.changes
-            )
+            rollback_id = rollback_manager.create_rollback_point(args.description, args.changes)
             print(f"Rollback point created: {rollback_id}")
 
         elif args.command == "list":
@@ -939,9 +901,7 @@ def main():
                 print(f"  {rp['id']} - {rp['description']} ({status})")
 
         elif args.command == "rollback":
-            result = rollback_manager.rollback_to_point(
-                args.rollback_id, validate_before=not args.no_validate
-            )
+            result = rollback_manager.rollback_to_point(args.rollback_id, validate_before=not args.no_validate)
             if result.success:
                 print("Rollback completed successfully")
                 print(f"Restored {len(result.restored_files)} files")
@@ -949,9 +909,7 @@ def main():
                 print(f"Rollback failed: {result.message}")
 
         elif args.command == "research-rollback":
-            result = rollback_manager.rollback_research_integration(
-                args.type, args.name
-            )
+            result = rollback_manager.rollback_research_integration(args.type, args.name)
             if result.success:
                 print("Research rollback completed successfully")
             else:
@@ -959,9 +917,7 @@ def main():
 
         elif args.command == "validate":
             validation = rollback_manager.validate_rollback_system()
-            print(
-                f"Rollback system health: {'HEALTHY' if validation['system_healthy'] else 'UNHEALTHY'}"
-            )
+            print(f"Rollback system health: {'HEALTHY' if validation['system_healthy'] else 'UNHEALTHY'}")
             if validation["issues"]:
                 print("Issues found:")
                 for issue in validation["issues"]:
@@ -972,13 +928,9 @@ def main():
                     print(f"  - {rec}")
 
         elif args.command == "cleanup":
-            result = rollback_manager.cleanup_old_rollback_points(
-                args.keep, dry_run=not args.execute
-            )
+            result = rollback_manager.cleanup_old_rollbacks(args.keep, dry_run=not args.execute)
             if result["dry_run"]:
-                print(
-                    f"Dry run: Would delete {result['would_delete_count']} rollback points"
-                )
+                print(f"Dry run: Would delete {result['would_delete_count']} rollback points")
                 print(f"Would free {result['would_free_space'] / 1024 / 1024:.1f} MB")
             else:
                 print(f"Deleted {result['deleted_count']} rollback points")