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

moai_adk/core/spec_status_manager.py

@@ -8,9 +8,9 @@ import logging
 import re
 from datetime import datetime
 from pathlib import Path
-from typing import Dict, Set
+from typing import Any, Dict, List, Set
 
-import yaml
+import yaml  # type: ignore
 
 logger = logging.getLogger(__name__)
 
@@ -43,7 +43,7 @@ class SpecStatusManager:
         Returns:
             Set of SPEC IDs that have draft status
         """
-        draft_specs = set()
+        draft_specs: Set[str] = set()
 
         if not self.specs_dir.exists():
             logger.warning(f"SPEC directory not found: {self.specs_dir}")
@@ -61,9 +61,7 @@ class SpecStatusManager:
                         frontmatter = None
 
                         # Handle JSON-like meta (common in older specs)
-                        meta_match = re.search(
-                            r"<%?\s*---\s*\n(.*?)\n---\s*%?>", content, re.DOTALL
-                        )
+                        meta_match = re.search(r"<%?\s*---\s*\n(.*?)\n---\s*%?>", content, re.DOTALL)
                         if meta_match:
                             try:
                                 meta_text = meta_match.group(1)
@@ -71,9 +69,7 @@ class SpecStatusManager:
                                 meta_text = meta_text.replace('"', "").replace("'", "")
                                 frontmatter = yaml.safe_load("{" + meta_text + "}")
                             except Exception as e:
-                                logger.debug(
-                                    f"JSON meta parsing failed for {spec_dir.name}: {e}"
-                                )
+                                logger.debug(f"JSON meta parsing failed for {spec_dir.name}: {e}")
 
                         # Handle regular YAML frontmatter
                         elif content.startswith("---"):
@@ -83,9 +79,7 @@ class SpecStatusManager:
                                 try:
                                     frontmatter = yaml.safe_load(frontmatter_text)
                                 except yaml.YAMLError as e:
-                                    logger.warning(
-                                        f"YAML parsing error for {spec_dir.name}: {e}"
-                                    )
+                                    logger.warning(f"YAML parsing error for {spec_dir.name}: {e}")
                                     # Try to fix common issues (like @ in author field)
                                     try:
                                         # Replace problematic @author entries
@@ -97,10 +91,8 @@ class SpecStatusManager:
                                                 fixed_text,
                                             )
                                         frontmatter = yaml.safe_load(fixed_text)
-                                    except:
-                                        logger.error(
-                                            f"Could not parse YAML for {spec_dir.name} even after fixes"
-                                        )
+                                    except yaml.YAMLError:
+                                        logger.error(f"Could not parse YAML for {spec_dir.name} even after fixes")
                                         continue
 
                         if frontmatter and frontmatter.get("status") == "draft":
@@ -135,19 +127,11 @@ class SpecStatusManager:
             spec_dir = spec_file.parent
 
             # Check for implementation files
-            src_files = (
-                list(spec_dir.rglob("*.py"))
-                if (spec_dir.parent.parent / "src").exists()
-                else []
-            )
+            src_files = list(spec_dir.rglob("*.py")) if (spec_dir.parent.parent / "src").exists() else []
 
             # Check for test files
             test_dir = spec_dir.parent.parent / "tests"
-            test_files = (
-                list(test_dir.rglob(f"test_*{spec_id.lower()}*.py"))
-                if test_dir.exists()
-                else []
-            )
+            test_files = list(test_dir.rglob(f"test_*{spec_id.lower()}*.py")) if test_dir.exists() else []
 
             # Simple completion criteria
             has_code = len(src_files) > 0
@@ -161,9 +145,7 @@ class SpecStatusManager:
             # Overall completion check
             is_complete = has_code and has_tests and has_acceptance_criteria
 
-            logger.info(
-                f"SPEC {spec_id} implementation status: {'COMPLETE' if is_complete else 'INCOMPLETE'}"
-            )
+            logger.info(f"SPEC {spec_id} implementation status: {'COMPLETE' if is_complete else 'INCOMPLETE'}")
             return is_complete
 
         except Exception as e:
@@ -204,14 +186,10 @@ class SpecStatusManager:
                         try:
                             fixed_text = frontmatter_text
                             if "author: @" in fixed_text:
-                                fixed_text = re.sub(
-                                    r"author:\s*@(\w+)", r'author: "\1"', fixed_text
-                                )
+                                fixed_text = re.sub(r"author:\s*@(\w+)", r'author: "\1"', fixed_text)
                             frontmatter = yaml.safe_load(fixed_text) or {}
-                        except:
-                            logger.error(
-                                f"Could not parse YAML for {spec_id} even after fixes"
-                            )
+                        except yaml.YAMLError:
+                            logger.error(f"Could not parse YAML for {spec_id} even after fixes")
                             return False
 
                     # Update status
@@ -219,14 +197,12 @@ class SpecStatusManager:
 
                     # Bump version if completing
                     if new_status == "completed":
-                        frontmatter["version"] = self._bump_version(
-                            frontmatter.get("version", "0.1.0")
-                        )
+                        frontmatter["version"] = self._bump_version(frontmatter.get("version", "0.1.0"))
                         frontmatter["updated"] = datetime.now().strftime("%Y-%m-%d")
 
                     # Reconstruct the file
                     new_frontmatter = yaml.dump(frontmatter, default_flow_style=False)
-                    new_content = f"---\n{new_frontmatter}---{content[end_marker+3:]}"
+                    new_content = f"---\n{new_frontmatter}---{content[end_marker + 3 :]}"
 
                     # Write back to file
                     with open(spec_file, "w", encoding="utf-8") as f:
@@ -247,7 +223,7 @@ class SpecStatusManager:
         """
         return self.validation_criteria.copy()
 
-    def validate_spec_for_completion(self, spec_id: str) -> Dict:
+    def validate_spec_for_completion(self, spec_id: str) -> Dict[str, Any]:
         """Validate if a SPEC is ready for completion
 
         Args:
@@ -262,7 +238,7 @@ class SpecStatusManager:
                 'recommendations': List[str]
             }
         """
-        result = {
+        result: Dict[str, Any] = {
             "is_ready": False,
             "criteria_met": {},
             "issues": [],
@@ -274,68 +250,74 @@ class SpecStatusManager:
             spec_file = spec_dir / "spec.md"
 
             if not spec_file.exists():
-                result["issues"].append(f"SPEC file not found: {spec_file}")
+                issues_list = result["issues"]
+                if isinstance(issues_list, list):
+                    issues_list.append(f"SPEC file not found: {spec_file}")
                 return result
 
             # Check implementation status
-            criteria_checks = {}
+            criteria_checks: Dict[str, bool] = {}
 
             # Check for code implementation
             spec_dir = spec_file.parent
             src_dir = spec_dir.parent.parent / "src"
-            criteria_checks["code_implemented"] = (
-                src_dir.exists() and len(list(src_dir.rglob("*.py"))) > 0
-            )
+            criteria_checks["code_implemented"] = src_dir.exists() and len(list(src_dir.rglob("*.py"))) > 0
             if not criteria_checks["code_implemented"]:
-                result["issues"].append("No source code files found")
+                issues_list = result["issues"]
+                if isinstance(issues_list, list):
+                    issues_list.append("No source code files found")
 
             # Check for test implementation
             test_dir = spec_dir.parent.parent / "tests"
             test_files = list(test_dir.rglob("test_*.py")) if test_dir.exists() else []
             criteria_checks["test_implemented"] = len(test_files) > 0
             if not criteria_checks["test_implemented"]:
-                result["issues"].append("No test files found")
+                issues_list = result["issues"]
+                if isinstance(issues_list, list):
+                    issues_list.append("No test files found")
 
             # Check for acceptance criteria
-            criteria_checks["tasks_completed"] = self._check_acceptance_criteria(
-                spec_file
-            )
+            criteria_checks["tasks_completed"] = self._check_acceptance_criteria(spec_file)
             if not criteria_checks["tasks_completed"]:
-                result["issues"].append("Missing acceptance criteria section")
+                issues_list = result["issues"]
+                if isinstance(issues_list, list):
+                    issues_list.append("Missing acceptance criteria section")
 
             # 4. Acceptance criteria present
-            criteria_checks["has_acceptance_criteria"] = (
-                self._check_acceptance_criteria(spec_file)
-            )
+            criteria_checks["has_acceptance_criteria"] = self._check_acceptance_criteria(spec_file)
             if (
                 not criteria_checks["has_acceptance_criteria"]
                 and self.validation_criteria["require_acceptance_criteria"]
             ):
-                result["issues"].append("Missing acceptance criteria section")
+                issues_list = result["issues"]
+                if isinstance(issues_list, list):
+                    issues_list.append("Missing acceptance criteria section")
 
             # 5. Documentation sync
             criteria_checks["docs_synced"] = self._check_documentation_sync(spec_id)
             if not criteria_checks["docs_synced"]:
-                result["recommendations"].append(
-                    "Consider running /alfred:3-sync to update documentation"
-                )
+                recs_list = result["recommendations"]
+                if isinstance(recs_list, list):
+                    recs_list.append("Consider running /moai:3-sync to update documentation")
 
             result["criteria_met"] = criteria_checks
             result["is_ready"] = all(criteria_checks.values())
 
             # Add recommendations
             if result["is_ready"]:
-                result["recommendations"].append(
-                    "SPEC is ready for completion. Consider updating status to 'completed'"
-                )
+                recs_list = result["recommendations"]
+                if isinstance(recs_list, list):
+                    recs_list.append("SPEC is ready for completion. Consider updating status to 'completed'")
 
         except Exception as e:
             logger.error(f"Error validating SPEC {spec_id}: {e}")
-            result["issues"].append(f"Validation error: {e}")
+            issues_list = result["issues"]
+            if isinstance(issues_list, list):
+                issues_list.append(f"Validation error: {e}")
 
         return result
 
-    def batch_update_completed_specs(self) -> Dict:
+    def batch_update_completed_specs(self) -> Dict[str, List[str]]:
         """Batch update all draft SPECs that have completed implementations
 
         Returns:
@@ -346,7 +328,7 @@ class SpecStatusManager:
                 'skipped': List[str]   # Incomplete SPEC IDs
             }
         """
-        results = {"updated": [], "failed": [], "skipped": []}
+        results: Dict[str, List[str]] = {"updated": [], "failed": [], "skipped": []}
 
         draft_specs = self.detect_draft_specs()
         logger.info(f"Checking {len(draft_specs)} draft SPECs for completion")
@@ -359,23 +341,31 @@ class SpecStatusManager:
                 if validation["is_ready"]:
                     # Update status
                     if self.update_spec_status(spec_id, "completed"):
-                        results["updated"].append(spec_id)
+                        updated_list = results["updated"]
+                        if isinstance(updated_list, list):
+                            updated_list.append(spec_id)
                         logger.info(f"Updated SPEC {spec_id} to completed")
                     else:
-                        results["failed"].append(spec_id)
+                        failed_list = results["failed"]
+                        if isinstance(failed_list, list):
+                            failed_list.append(spec_id)
                         logger.error(f"Failed to update SPEC {spec_id}")
                 else:
-                    results["skipped"].append(spec_id)
-                    logger.debug(
-                        f"SPEC {spec_id} not ready for completion: {validation['issues']}"
-                    )
+                    skipped_list = results["skipped"]
+                    if isinstance(skipped_list, list):
+                        skipped_list.append(spec_id)
+                    logger.debug(f"SPEC {spec_id} not ready for completion: {validation['issues']}")
 
             except Exception as e:
-                results["failed"].append(spec_id)
+                failed_list = results["failed"]
+                if isinstance(failed_list, list):
+                    failed_list.append(spec_id)
                 logger.error(f"Error processing SPEC {spec_id}: {e}")
 
         logger.info(
-            f"Batch update complete: {len(results['updated'])} updated, {len(results['failed'])} failed, {len(results['skipped'])} skipped"
+            f"Batch update complete: {len(results['updated'])} updated, "
+            f"{len(results['failed'])} failed, "
+            f"{len(results['skipped'])} skipped"
         )
         return results
 

moai_adk/core/template/backup.py

@@ -5,7 +5,9 @@ Creates and manages backups to protect user data during template updates.
 
 from __future__ import annotations
 
+import re
 import shutil
+from datetime import datetime
 from pathlib import Path
 
 
@@ -41,29 +43,26 @@ 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 single backup (always at .moai-backups/backup/).
+        """Create a timestamped backup under .moai-backups/.
 
-        Existing backups are overwritten to maintain only one backup copy.
+        Creates a new timestamped backup directory for each update.
+        Maintains backward compatibility by supporting both new and legacy structures.
 
         Returns:
-            Backup path (always .moai-backups/backup/).
+            Path to timestamped backup directory (e.g., .moai-backups/20241201_143022/).
         """
-        backup_path = self.target_path / ".moai-backups" / "backup"
-
-        # Remove existing backup if present
-        if backup_path.exists():
-            shutil.rmtree(backup_path)
+        # Generate timestamp for backup directory name
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        backup_path = self.target_path / ".moai-backups" / timestamp
 
         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
@@ -80,6 +79,35 @@ class TemplateBackup:
 
         return backup_path
 
+    def get_latest_backup(self) -> Path | None:
+        """Get the most recent backup, supporting both new and legacy structures.
+
+        Searches for backups in order of preference:
+        1. Latest timestamped backup (new structure)
+        2. Legacy backup/ directory (old structure)
+
+        Returns:
+            Path to the most recent backup directory, or None if no backups exist.
+        """
+        # Check for new timestamped backups first
+        backup_dir = self.target_path / ".moai-backups"
+        if backup_dir.exists():
+            # Match pattern: YYYYMMDD_HHMMSS (8 digits + underscore + 6 digits)
+            timestamp_pattern = re.compile(r"^\d{8}_\d{6}$")
+            timestamped_backups = [d for d in backup_dir.iterdir() if d.is_dir() and timestamp_pattern.match(d.name)]
+
+            if timestamped_backups:
+                # Sort by name (timestamp) and return the latest
+                latest_backup = max(timestamped_backups, key=lambda x: x.name)
+                return latest_backup
+
+        # Fall back to legacy backup/ directory
+        legacy_backup = backup_dir / "backup"
+        if legacy_backup.exists():
+            return legacy_backup
+
+        return None
+
     def _copy_exclude_protected(self, src: Path, dst: Path) -> None:
         """Copy backup content while excluding protected paths.
 
@@ -94,10 +122,7 @@ class TemplateBackup:
             rel_path_str = str(rel_path)
 
             # Skip excluded paths
-            if any(
-                rel_path_str.startswith(exclude_dir)
-                for exclude_dir in self.BACKUP_EXCLUDE_DIRS
-            ):
+            if any(rel_path_str.startswith(exclude_dir) for exclude_dir in self.BACKUP_EXCLUDE_DIRS):
                 continue
 
             dst_item = dst / rel_path
@@ -112,22 +137,23 @@ class TemplateBackup:
 
         Restores .moai, .claude, .github directories and CLAUDE.md file
         from a backup created by create_backup().
+        Supports both new timestamped and legacy backup structures.
 
         Args:
             backup_path: Backup path to restore from.
-                        Defaults to .moai-backups/backup/
+                        If None, automatically finds the latest backup.
 
         Raises:
-            FileNotFoundError: When backup_path doesn't exist.
+            FileNotFoundError: When no backup is found.
         """
         if backup_path is None:
-            backup_path = self.backup_dir / "backup"
+            backup_path = self.get_latest_backup()
 
-        if not backup_path.exists():
+        if backup_path is None or not backup_path.exists():
             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