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

moai_adk/templates/.claude/hooks/{alfred/shared/core → moai/lib}/project.py

@@ -12,14 +12,27 @@ from contextlib import contextmanager
 from pathlib import Path
 from typing import Any
 
+import yaml
+
+# Import TimeoutError from lib.timeout (canonical definition)
+try:
+    from lib.timeout import TimeoutError  # noqa: F401
+except ImportError:
+    # Fallback if lib.timeout not available
+    class TimeoutError(Exception):  # type: ignore[no-redef]
+        """Signal-based timeout exception"""
+
+        pass
+
+
 # Cache directory for version check results
 CACHE_DIR_NAME = ".moai/cache"
 
 
 def find_project_root(start_path: str | Path = ".") -> Path:
-    """Find MoAI-ADK project root by searching upward for .moai/config.json
+    """Find MoAI-ADK project root by searching upward for .moai/config/config.yaml
 
-    Traverses up the directory tree until it finds .moai/config.json or CLAUDE.md,
+    Traverses up the directory tree until it finds .moai/config/config.yaml or CLAUDE.md,
     which indicates the project root. This ensures cache and other files are
     always created in the correct location, regardless of where hooks execute.
 
@@ -36,22 +49,22 @@ def find_project_root(start_path: str | Path = ".") -> Path:
         Path("/Users/user/my-project")  # Found root 3 levels up
 
     Notes:
-        - Searches for .moai/config.json first (most reliable)
-        - Falls back to CLAUDE.md if config.json not found
+        - Searches for .moai/config/config.yaml first (most reliable)
+        - Falls back to CLAUDE.md if config.yaml not found
         - Max depth: 10 levels up (prevent infinite loop)
         - Returns absolute path for consistency
 
     TDD History:
         - RED: 4 test scenarios (root, nested, not found, symlinks)
-        - GREEN: Minimal upward search with .moai/config.json detection
+        - GREEN: Minimal upward search with .moai/config/config.yaml detection
         - REFACTOR: Add CLAUDE.md fallback, max depth limit, absolute path return
     """
     current = Path(start_path).resolve()
     max_depth = 10  # Prevent infinite loop
 
     for _ in range(max_depth):
-        # Check for .moai/config.json (primary indicator)
-        if (current / ".moai" / "config.json").exists():
+        # Check for .moai/config/config.yaml (primary indicator)
+        if (current / ".moai" / "config" / "config.yaml").exists():
             return current
 
         # Check for CLAUDE.md (secondary indicator)
@@ -68,12 +81,6 @@ def find_project_root(start_path: str | Path = ".") -> Path:
     return Path(start_path).resolve()
 
 
-class TimeoutError(Exception):
-    """Signal-based timeout exception"""
-
-    pass
-
-
 @contextmanager
 def timeout_handler(seconds: int):
     """Hard timeout using SIGALRM (works on Unix systems including macOS)
@@ -112,7 +119,7 @@ def detect_language(cwd: str) -> str:
         cwd: Project root directory path (both absolute and relative paths are possible)
 
     Returns:
-        Detected language name (lowercase). If detection fails, "Unknown Language" is returned.
+        str: Detected language name (lowercase). If detection fails, "Unknown Language" is returned.
         Supported languages: python, typescript, javascript, java, go, rust,
                   dart, swift, kotlin, php, ruby, elixir, scala,
                   clojure, cpp, c, csharp, haskell, shell, lua
@@ -189,10 +196,10 @@ def _run_git_command(args: list[str], cwd: str, timeout: int = 2) -> str:
     Args:
         args: Git command argument list (git adds automatically)
         cwd: Execution directory path
-        timeout: Timeout (seconds, default 2 seconds)
+        timeout: Timeout in seconds (default: 2 seconds)
 
     Returns:
-        Git command output (stdout, removing leading and trailing spaces)
+        str: Git command output (stdout, removing leading and trailing spaces)
 
     Raises:
         subprocess.TimeoutExpired: Timeout exceeded (via TimeoutError)
@@ -219,9 +226,7 @@ def _run_git_command(args: list[str], cwd: str, timeout: int = 2) -> str:
 
             # Check exit code manually
             if result.returncode != 0:
-                raise subprocess.CalledProcessError(
-                    result.returncode, ["git"] + args, result.stdout, result.stderr
-                )
+                raise subprocess.CalledProcessError(result.returncode, ["git"] + args, result.stdout, result.stderr)
 
             return result.stdout.strip()
 
@@ -289,7 +294,11 @@ def get_git_info(cwd: str) -> dict[str, Any]:
             "last_commit": last_commit,
         }
 
-    except (subprocess.TimeoutExpired, subprocess.CalledProcessError, FileNotFoundError):
+    except (
+        subprocess.TimeoutExpired,
+        subprocess.CalledProcessError,
+        FileNotFoundError,
+    ):
         return {}
 
 
@@ -371,7 +380,7 @@ def count_specs(cwd: str) -> dict[str, int]:
 
 
 def get_project_language(cwd: str) -> str:
-    """Determine the primary project language (prefers config.json).
+    """Determine the primary project language (prefers config.yaml).
 
     Args:
         cwd: Project root directory (or any subdirectory, will search upward).
@@ -380,20 +389,20 @@ def get_project_language(cwd: str) -> str:
         Language string in lower-case.
 
     Notes:
-        - Reads ``.moai/config.json`` first for a quick answer.
+        - Reads ``.moai/config/config.yaml`` first for a quick answer.
         - Falls back to ``detect_language`` if configuration is missing.
-        - Automatically finds project root to locate .moai/config.json
+        - Automatically finds project root to locate .moai/config/config.yaml
     """
     # Find project root to ensure we read config from correct location
     project_root = find_project_root(cwd)
-    config_path = project_root / ".moai" / "config.json"
+    config_path = project_root / ".moai" / "config" / "config.yaml"
     if config_path.exists():
         try:
-            config = json.loads(config_path.read_text())
+            config = yaml.safe_load(config_path.read_text()) or {}
             lang = config.get("language", "")
             if lang:
                 return lang
-        except (OSError, json.JSONDecodeError):
+        except (OSError, yaml.YAMLError):
             # Fall back to detection on parse errors
             pass
 
@@ -401,9 +410,21 @@ def get_project_language(cwd: str) -> str:
     return detect_language(str(project_root))
 
 
-# @CODE:CONFIG-INTEGRATION-001
+def _validate_project_structure(cwd: str) -> bool:
+    """Validate that project has required MoAI-ADK structure
+
+    Args:
+        cwd: Project root directory path
+
+    Returns:
+        bool: True if .moai/config/config.yaml exists, False otherwise
+    """
+    project_root = find_project_root(cwd)
+    return (project_root / ".moai" / "config" / "config.yaml").exists()
+
+
 def get_version_check_config(cwd: str) -> dict[str, Any]:
-    """Read version check configuration from .moai/config.json
+    """Read version check configuration from .moai/config/config.yaml
 
     Returns version check settings with sensible defaults.
     Supports frequency-based cache TTL configuration.
@@ -436,12 +457,12 @@ def get_version_check_config(cwd: str) -> dict[str, Any]:
 
     # Find project root to ensure we read config from correct location
     project_root = find_project_root(cwd)
-    config_path = project_root / ".moai" / "config.json"
+    config_path = project_root / ".moai" / "config" / "config.yaml"
     if not config_path.exists():
         return defaults
 
     try:
-        config = json.loads(config_path.read_text())
+        config = yaml.safe_load(config_path.read_text()) or {}
 
         # Extract moai.version_check section
         moai_config = config.get("moai", {})
@@ -464,14 +485,17 @@ def get_version_check_config(cwd: str) -> dict[str, Any]:
         if "cache_ttl_hours" in version_check_config:
             cache_ttl_hours = version_check_config["cache_ttl_hours"]
 
-        return {"enabled": enabled, "frequency": frequency, "cache_ttl_hours": cache_ttl_hours}
+        return {
+            "enabled": enabled,
+            "frequency": frequency,
+            "cache_ttl_hours": cache_ttl_hours,
+        }
 
     except (OSError, json.JSONDecodeError, KeyError):
         # Config read or parse error - return defaults
         return defaults
 
 
-# @CODE:NETWORK-DETECT-001
 def is_network_available(timeout_seconds: float = 0.1) -> bool:
     """Quick network availability check using socket.
 
@@ -508,7 +532,6 @@ def is_network_available(timeout_seconds: float = 0.1) -> bool:
         return False
 
 
-# @CODE:VERSION-DETECT-MAJOR-001
 def is_major_version_change(current: str, latest: str) -> bool:
     """Detect if version change is a major version bump.
 
@@ -555,7 +578,6 @@ def is_major_version_change(current: str, latest: str) -> bool:
         return False
 
 
-# @CODE:VERSION-CACHE-INTEGRATION-001
 def get_package_version_info(cwd: str = ".") -> dict[str, Any]:
     """Check MoAI-ADK current and latest version with caching and offline support.
 
@@ -593,8 +615,6 @@ def get_package_version_info(cwd: str = ".") -> dict[str, Any]:
         - RED: 5 test scenarios (network detection, cache integration, offline mode)
         - GREEN: Integrate VersionCache with network detection
         - REFACTOR: Extract cache directory constant, improve error handling
-        - Phase 3: Add release_notes_url and is_major_update fields (@CODE:VERSION-INTEGRATE-FIELDS-001)
-        - Phase 4: CRITICAL FIX - Always guarantee current version return (@CODE:VERSION-ALWAYS-VALID-001)
     """
     import importlib.util
     import urllib.error
@@ -690,9 +710,7 @@ def get_package_version_info(cwd: str = ".") -> dict[str, Any]:
                     release_url = project_urls.get("Changelog", "")
                     if not release_url:
                         # Fallback to GitHub releases URL pattern
-                        release_url = (
-                            f"https://github.com/modu-ai/moai-adk/releases/tag/v{result['latest']}"
-                        )
+                        release_url = f"https://github.com/modu-ai/moai-adk/releases/tag/v{result['latest']}"
                     result["release_notes_url"] = release_url
                 except (KeyError, AttributeError, TypeError):
                     result["release_notes_url"] = None
@@ -706,8 +724,11 @@ def get_package_version_info(cwd: str = ".") -> dict[str, Any]:
     if result["current"] != "unknown" and result["latest"] != "unknown":
         try:
             # Parse versions for comparison
-            current_parts = [int(x) for x in result["current"].split(".")]
-            latest_parts = [int(x) for x in result["latest"].split(".")]
+            current_str = str(result["current"])
+            latest_str = str(result["latest"])
+
+            current_parts = [int(x) for x in current_str.split(".")]
+            latest_parts = [int(x) for x in latest_str.split(".")]
 
             # Pad shorter version with zeros
             max_len = max(len(current_parts), len(latest_parts))
@@ -719,9 +740,7 @@ def get_package_version_info(cwd: str = ".") -> dict[str, Any]:
                 result["upgrade_command"] = "uv tool upgrade moai-adk"
 
                 # Detect major version change
-                result["is_major_update"] = is_major_version_change(
-                    result["current"], result["latest"]
-                )
+                result["is_major_update"] = is_major_version_change(current_str, latest_str)
             else:
                 result["is_major_update"] = False
         except (ValueError, AttributeError):