moai-adk 0.25.4__py3-none-any.whl → 0.32.8__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,8 +443,8 @@ 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
@@ -487,9 +467,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 +515,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,9 +539,7 @@ 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 = [
@@ -574,9 +549,7 @@ class RollbackManager:
 
             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}"
-                )
+                warnings.append(f"Missing backup files: {missing_files}")
 
         except Exception as e:
             validation_result["valid"] = False
@@ -584,13 +557,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 +569,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 +619,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 +642,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 +650,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,16 +663,17 @@ 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:
@@ -721,14 +681,14 @@ class RollbackManager:
             config_file = self.project_root / ".moai" / "config" / "config.json"
             if config_file.exists():
                 try:
-                    with open(config_file, "r") as f:
+                    with open(config_file, "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")
+                    issues.append("Invalid JSON in config.json")
             else:
                 validation_results["config_valid"] = False
-                validation_results["issues"].append("config.json not found")
+                issues.append("config.json not found")
 
             # Validate research components
             for research_dir in self.research_dirs:
@@ -740,23 +700,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 +731,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 +740,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 +784,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 +832,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 +863,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 +874,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 +882,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 +890,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 +901,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")

moai_adk/core/session_manager.py

@@ -57,12 +57,8 @@ class SessionManager:
         """
         # Default paths
         project_root = Path.cwd()
-        self._session_file = (
-            session_file or project_root / ".moai" / "memory" / "agent-sessions.json"
-        )
-        self._transcript_dir = (
-            transcript_dir or project_root / ".moai" / "logs" / "agent-transcripts"
-        )
+        self._session_file = session_file or project_root / ".moai" / "memory" / "agent-sessions.json"
+        self._transcript_dir = transcript_dir or project_root / ".moai" / "logs" / "agent-transcripts"
 
         # Ensure directories exist
         self._session_file.parent.mkdir(parents=True, exist_ok=True)
@@ -86,9 +82,7 @@ class SessionManager:
                     self._sessions = data.get("sessions", {})
                     self._chains = data.get("chains", {})
                     self._metadata = data.get("metadata", {})
-                logger.info(
-                    f"Loaded {len(self._sessions)} sessions from {self._session_file}"
-                )
+                logger.info(f"Loaded {len(self._sessions)} sessions from {self._session_file}")
             except json.JSONDecodeError as e:
                 logger.warning(f"Failed to load sessions: {e}")
                 self._sessions = {}
@@ -158,9 +152,7 @@ class SessionManager:
         # Persist to disk
         self._save_sessions()
 
-        logger.info(
-            f"Registered agent result: {agent_name} (agentId: {agent_id[:8]}..., chain: {chain_id})"
-        )
+        logger.info(f"Registered agent result: {agent_name} (agentId: {agent_id[:8]}..., chain: {chain_id})")
 
     def get_resume_id(
         self,
@@ -192,10 +184,7 @@ class SessionManager:
         if chain_id:
             metadata = self._metadata.get(agent_id, {})
             if metadata.get("chain_id") != chain_id:
-                logger.debug(
-                    f"Chain mismatch: {agent_name} was in {metadata.get('chain_id')}, "
-                    f"requested {chain_id}"
-                )
+                logger.debug(f"Chain mismatch: {agent_name} was in {metadata.get('chain_id')}, requested {chain_id}")
                 return None
 
         logger.info(f"Resume ID for {agent_name}: {agent_id[:8]}...")
@@ -236,17 +225,13 @@ class SessionManager:
         resume_count = metadata.get("resume_count", 0)
 
         if resume_count >= 5:  # Max resume depth from config
-            logger.warning(
-                f"{agent_name} has been resumed {resume_count} times, starting new session"
-            )
+            logger.warning(f"{agent_name} has been resumed {resume_count} times, starting new session")
             return False
 
         # Heuristic: Check if tasks are related
         # (This can be enhanced with semantic similarity)
         task_keywords_match = any(
-            keyword in current_task.lower()
-            for keyword in previous_task.lower().split()
-            if len(keyword) > 4
+            keyword in current_task.lower() for keyword in previous_task.lower().split() if len(keyword) > 4
         )
 
         if task_keywords_match:
@@ -442,9 +427,7 @@ class SessionManager:
         with open(chains_file, "w", encoding="utf-8") as f:
             json.dump(chains_data, f, indent=2, ensure_ascii=False)
 
-        logger.info(
-            f"Created workflow chain: {chain_id} with {len(agent_sequence)} agents"
-        )
+        logger.info(f"Created workflow chain: {chain_id} with {len(agent_sequence)} agents")
 
 
 # Global instance (singleton pattern)
@@ -647,9 +630,10 @@ if __name__ == "__main__":
     }
 
     for expert_name, data in experts_results.items():
+        agent_id_value: str = data["agent_id"]  # type: ignore[assignment]
         manager.register_agent_result(
             agent_name=expert_name,
-            agent_id=data["agent_id"],
+            agent_id=agent_id_value,
             result={k: v for k, v in data.items() if k != "agent_id"},
             chain_id="SPEC-AUTH-001-review",
         )